feat: add schema generation

Cargo.lock

@@ -3677,6 +3677,7 @@ dependencies = [
  "pathdiff",
  "relative-path",
  "reqwest",
+ "schemars",
  "semver",
  "serde",
  "serde_json",
@@ -4040,6 +4041,26 @@ dependencies = [
  "thiserror 1.0.69",
 ]
 
+[[package]]
+name = "ref-cast"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.90",
+]
+
 [[package]]
 name = "regex"
 version = "1.11.1"
@@ -4302,6 +4323,31 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "schemars"
+version = "1.0.0-alpha.17"
+source = "git+https://github.com/daimond113/schemars?rev=bc7c7d6#bc7c7d6a0c030177f3e5c0bcabf99d341e4f0e54"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "schemars_derive",
+ "semver",
+ "serde",
+ "serde_json",
+ "url",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "1.0.0-alpha.17"
+source = "git+https://github.com/daimond113/schemars?rev=bc7c7d6#bc7c7d6a0c030177f3e5c0bcabf99d341e4f0e54"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.90",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -4512,6 +4558,17 @@ dependencies = [
  "syn 2.0.90",
 ]
 
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.90",
+]
+
 [[package]]
 name = "serde_json"
 version = "1.0.133"

Cargo.toml

@@ -33,6 +33,7 @@ bin = [
 wally-compat = ["dep:async_zip", "dep:serde_json"]
 patches = ["dep:git2"]
 version-management = ["bin"]
+schema = ["dep:schemars"]
 
 [[bin]]
 name = "pesde"
@@ -73,6 +74,8 @@ git2 = { version = "0.19.0", optional = true }
 async_zip = { version = "0.0.17", features = ["tokio", "deflate", "deflate64", "tokio-fs"], optional = true }
 serde_json = { version = "1.0.133", optional = true }
 
+schemars = { git = "https://github.com/daimond113/schemars", rev = "bc7c7d6", features = ["semver1", "url2"], optional = true }
+
 anyhow = { version = "1.0.94", optional = true }
 open = { version = "5.3.1", optional = true }
 keyring = { version = "3.6.1", features = ["crypto-rust", "windows-native", "apple-native", "async-secret-service", "async-io"], optional = true }

src/manifest/mod.rs

@@ -19,6 +19,7 @@ pub mod target;
 
 /// A package manifest
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct Manifest {
     /// The name of the package
     pub name: PackageName,
@@ -43,6 +44,10 @@ pub struct Manifest {
     pub private: bool,
     /// The scripts of the package
     #[serde(default, skip_serializing)]
+    #[cfg_attr(
+        feature = "schema",
+        schemars(with = "BTreeMap<String, std::path::PathBuf>")
+    )]
     pub scripts: BTreeMap<String, RelativePathBuf>,
     /// The indices to use for the package
     #[serde(
@@ -50,6 +55,7 @@ pub struct Manifest {
         skip_serializing,
         deserialize_with = "crate::util::deserialize_gix_url_map"
     )]
+    #[cfg_attr(feature = "schema", schemars(with = "BTreeMap<String, url::Url>"))]
     pub indices: BTreeMap<String, gix::Url>,
     /// The indices to use for the package's wally dependencies
     #[cfg(feature = "wally-compat")]
@@ -58,6 +64,7 @@ pub struct Manifest {
         skip_serializing,
         deserialize_with = "crate::util::deserialize_gix_url_map"
     )]
+    #[cfg_attr(feature = "schema", schemars(with = "BTreeMap<String, url::Url>"))]
     pub wally_indices: BTreeMap<String, gix::Url>,
     /// The overrides this package has
     #[serde(default, skip_serializing)]
@@ -68,6 +75,12 @@ pub struct Manifest {
     /// The patches to apply to packages
     #[cfg(feature = "patches")]
     #[serde(default, skip_serializing)]
+    #[cfg_attr(
+        feature = "schema",
+        schemars(
+            with = "BTreeMap<crate::names::PackageNames, BTreeMap<crate::source::version_id::VersionId, std::path::PathBuf>>"
+        )
+    )]
     pub patches: BTreeMap<
         crate::names::PackageNames,
         BTreeMap<crate::source::version_id::VersionId, RelativePathBuf>,
@@ -92,6 +105,7 @@ pub struct Manifest {
     #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
     pub dev_dependencies: BTreeMap<String, DependencySpecifiers>,
     /// The user-defined fields of the package
+    #[cfg_attr(feature = "schema", schemars(skip))]
     #[serde(flatten)]
     pub user_defined_fields: HashMap<String, toml::Value>,
 }

src/manifest/overrides.rs

@@ -29,6 +29,20 @@ impl FromStr for OverrideKey {
     }
 }
 
+#[cfg(feature = "schema")]
+impl schemars::JsonSchema for OverrideKey {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "OverrideKey".into()
+    }
+
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        schemars::json_schema!({
+            "type": "string",
+            "pattern": r#"^([a-zA-Z]+(>[a-zA-Z]+)+)(,([a-zA-Z]+(>[a-zA-Z]+)+))*$"#,
+        })
+    }
+}
+
 impl Display for OverrideKey {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
@@ -51,6 +65,7 @@ impl Display for OverrideKey {
 
 /// A specifier for an override
 #[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum OverrideSpecifier {
     /// A specifier for a dependency

src/manifest/target.rs

@@ -11,6 +11,8 @@ use std::{
 #[derive(
     SerializeDisplay, DeserializeFromStr, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord,
 )]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schema", schemars(rename_all = "snake_case"))]
 pub enum TargetKind {
     /// A Roblox target
     Roblox,
@@ -77,12 +79,14 @@ impl TargetKind {
 
 /// A target of a package
 #[derive(Deserialize, Serialize, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "snake_case", tag = "environment")]
 pub enum Target {
     /// A Roblox target
     Roblox {
         /// The path to the lib export file
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
         lib: Option<RelativePathBuf>,
         /// The files to include in the sync tool's config
         #[serde(default)]
@@ -92,6 +96,7 @@ pub enum Target {
     RobloxServer {
         /// The path to the lib export file
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
         lib: Option<RelativePathBuf>,
         /// The files to include in the sync tool's config
         #[serde(default)]
@@ -101,24 +106,36 @@ pub enum Target {
     Lune {
         /// The path to the lib export file
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
         lib: Option<RelativePathBuf>,
         /// The path to the bin export file
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
         bin: Option<RelativePathBuf>,
         /// The exported scripts
         #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+        #[cfg_attr(
+            feature = "schema",
+            schemars(with = "BTreeMap<String, std::path::PathBuf>")
+        )]
         scripts: BTreeMap<String, RelativePathBuf>,
     },
     /// A Luau target
     Luau {
         /// The path to the lib export file
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
         lib: Option<RelativePathBuf>,
         /// The path to the bin export file
         #[serde(default, skip_serializing_if = "Option::is_none")]
+        #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
         bin: Option<RelativePathBuf>,
         /// The exported scripts
         #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+        #[cfg_attr(
+            feature = "schema",
+            schemars(with = "BTreeMap<String, std::path::PathBuf>")
+        )]
         scripts: BTreeMap<String, RelativePathBuf>,
     },
 }
@@ -183,6 +200,7 @@ impl Display for Target {
 #[derive(
     SerializeDisplay, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd,
 )]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "snake_case")]
 pub enum RobloxPlaceKind {
     /// The shared dependencies location

src/names.rs

@@ -73,6 +73,20 @@ impl Display for PackageName {
     }
 }
 
+#[cfg(feature = "schema")]
+impl schemars::JsonSchema for PackageName {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "PackageName".into()
+    }
+
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        schemars::json_schema!({
+            "type": "string",
+            "pattern": r#"^(?!_)(?![0-9]+\/)[a-z0-9_]{3,32}(?<!_)\/(?!_)(?![0-9]+\/)[a-z0-9_]{1,32}(?<!_)$"#
+        })
+    }
+}
+
 impl PackageName {
     /// Returns the parts of the package name
     pub fn as_str(&self) -> (&str, &str) {
@@ -89,6 +103,8 @@ impl PackageName {
 #[derive(
     Debug, DeserializeFromStr, SerializeDisplay, Clone, Hash, PartialEq, Eq, PartialOrd, Ord,
 )]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schema", schemars(untagged))]
 pub enum PackageNames {
     /// A pesde package name
     Pesde(PackageName),
@@ -201,6 +217,20 @@ pub mod wally {
         }
     }
 
+    #[cfg(feature = "schema")]
+    impl schemars::JsonSchema for WallyPackageName {
+        fn schema_name() -> std::borrow::Cow<'static, str> {
+            "WallyPackageName".into()
+        }
+
+        fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+            schemars::json_schema!({
+                "type": "string",
+                "pattern": r#"^(wally#)?[a-z0-9-]{1,64}\/[a-z0-9-]{1,64}$"#
+            })
+        }
+    }
+
     impl WallyPackageName {
         /// Returns the parts of the package name
         pub fn as_str(&self) -> (&str, &str) {

src/source/git/specifier.rs

@@ -6,17 +6,20 @@ use crate::source::DependencySpecifier;
 
 /// The specifier for a Git dependency
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct GitDependencySpecifier {
     /// The repository of the package
     #[serde(
         serialize_with = "crate::util::serialize_gix_url",
         deserialize_with = "crate::util::deserialize_git_like_url"
     )]
+    #[cfg_attr(feature = "schema", schemars(with = "url::Url"))]
     pub repo: gix::Url,
     /// The revision of the package
     pub rev: String,
     /// The path of the package in the repository
     #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[cfg_attr(feature = "schema", schemars(with = "Option<std::path::PathBuf>"))]
     pub path: Option<RelativePathBuf>,
 }
 impl DependencySpecifier for GitDependencySpecifier {}

src/source/path/specifier.rs

@@ -4,6 +4,7 @@ use std::{fmt::Display, path::PathBuf};
 
 /// The specifier for a path dependency
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct PathDependencySpecifier {
     /// The path to the package
     pub path: PathBuf,

src/source/pesde/specifier.rs

@@ -5,10 +5,12 @@ use std::fmt::Display;
 
 /// The specifier for a pesde dependency
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct PesdeDependencySpecifier {
     /// The name of the package
     pub name: PackageName,
     /// The version requirement for the package
+    #[cfg_attr(feature = "schema", schemars(with = "String"))]
     pub version: VersionReq,
     /// The index to use for the package
     #[serde(default, skip_serializing_if = "Option::is_none")]

src/source/specifiers.rs

@@ -4,6 +4,7 @@ use std::fmt::Display;
 
 /// All possible dependency specifiers
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 pub enum DependencySpecifiers {
     /// A pesde dependency specifier

src/source/version_id.rs

@@ -57,6 +57,35 @@ impl FromStr for VersionId {
     }
 }
 
+#[cfg(feature = "schema")]
+impl schemars::JsonSchema for VersionId {
+    fn schema_name() -> std::borrow::Cow<'static, str> {
+        "VersionId".into()
+    }
+
+    fn json_schema(_: &mut schemars::SchemaGenerator) -> schemars::Schema {
+        let version_schema = Version::json_schema(&mut schemars::SchemaGenerator::default());
+        let version_pattern = version_schema
+            .get("pattern")
+            .unwrap()
+            .as_str()
+            .unwrap()
+            .trim_start_matches('^')
+            .trim_end_matches('$');
+
+        let target_pattern = TargetKind::VARIANTS
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("|");
+
+        schemars::json_schema!({
+            "type": "string",
+            "pattern": format!(r#"^({version_pattern}) ({target_pattern})$"#),
+        })
+    }
+}
+
 /// Errors that can occur when using a version ID
 pub mod errors {
     use thiserror::Error;

src/source/wally/specifier.rs

@@ -7,11 +7,13 @@ use crate::{names::wally::WallyPackageName, source::DependencySpecifier};
 
 /// The specifier for a Wally dependency
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct WallyDependencySpecifier {
     /// The name of the package
     #[serde(rename = "wally")]
     pub name: WallyPackageName,
     /// The version requirement for the package
+    #[cfg_attr(feature = "schema", schemars(with = "String"))]
     pub version: VersionReq,
     /// The index to use for the package
     #[serde(default, skip_serializing_if = "Option::is_none")]

src/source/workspace/specifier.rs

@@ -5,6 +5,7 @@ use std::{fmt::Display, str::FromStr};
 
 /// The specifier for a workspace dependency
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub struct WorkspaceDependencySpecifier {
     /// The name of the workspace package
     #[serde(rename = "workspace")]
@@ -27,15 +28,20 @@ impl Display for WorkspaceDependencySpecifier {
 #[derive(
     Debug, SerializeDisplay, DeserializeFromStr, Clone, Copy, PartialEq, Eq, Hash, Default,
 )]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 pub enum VersionType {
     /// The "^" version type
     #[default]
+    #[cfg_attr(feature = "schema", serde(rename = "^"))]
     Caret,
     /// The "~" version type
+    #[cfg_attr(feature = "schema", serde(rename = "~"))]
     Tilde,
     /// The "=" version type
+    #[cfg_attr(feature = "schema", serde(rename = "="))]
     Exact,
     /// The "*" version type
+    #[cfg_attr(feature = "schema", serde(rename = "*"))]
     Wildcard,
 }
 
@@ -68,10 +74,13 @@ impl FromStr for VersionType {
 
 /// Either a version type or a version requirement
 #[derive(Debug, SerializeDisplay, DeserializeFromStr, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+#[cfg_attr(feature = "schema", schemars(untagged))]
 pub enum VersionTypeOrReq {
     /// A version type
     VersionType(VersionType),
     /// A version requirement
+    #[cfg_attr(feature = "schema", schemars(with = "String"))]
     Req(semver::VersionReq),
 }