new: Generate JSON schemas. (#1541)

* Move to new crate.

* Wrap in feature.

* Update actions.

* Rename function.

* Update report.

* Add command.

.yarn/versions/42cf3f6e.yml

@@ -1,9 +1,16 @@
 releases:
-  "@moonrepo/cli": minor
-  "@moonrepo/core-linux-arm64-gnu": minor
-  "@moonrepo/core-linux-arm64-musl": minor
-  "@moonrepo/core-linux-x64-gnu": minor
-  "@moonrepo/core-linux-x64-musl": minor
-  "@moonrepo/core-macos-arm64": minor
-  "@moonrepo/core-macos-x64": minor
-  "@moonrepo/core-windows-x64-msvc": minor
+  '@moonrepo/cli': minor
+  '@moonrepo/core-linux-arm64-gnu': minor
+  '@moonrepo/core-linux-arm64-musl': minor
+  '@moonrepo/core-linux-x64-gnu': minor
+  '@moonrepo/core-linux-x64-musl': minor
+  '@moonrepo/core-macos-arm64': minor
+  '@moonrepo/core-macos-x64': minor
+  '@moonrepo/core-windows-x64-msvc': minor
+  '@moonrepo/report': patch
+  '@moonrepo/types': minor
+
+declined:
+  - '@moonrepo/nx-compat'
+  - '@moonrepo/runtime'
+  - website

crates/actions/Cargo.toml

@@ -12,6 +12,8 @@ moon_cache_item = { path = "../cache-item" }
 moon_codeowners = { path = "../codeowners" }
 moon_common = { path = "../common" }
 moon_config = { path = "../config" }
+moon_config_schema = { path = "../config-schema" }
+moon_hash = { path = "../hash" }
 moon_project = { path = "../project" }
 moon_project_graph = { path = "../project-graph" }
 moon_task_runner = { path = "../task-runner" }

crates/actions/src/actions/sync_workspace.rs

@@ -1,4 +1,4 @@
-use crate::operations::{sync_codeowners, sync_vcs_hooks};
+use crate::operations::{sync_codeowners, sync_config_schemas, sync_vcs_hooks};
 use crate::utils::should_skip_action;
 use miette::IntoDiagnostic;
 use moon_action::{Action, ActionStatus, Operation};
@@ -37,6 +37,21 @@ pub async fn sync_workspace(
     // Run operations in parallel
     let mut futures = vec![];
 
+    {
+        debug!("Syncing config schemas");
+
+        let app_context = Arc::clone(&app_context);
+
+        futures.push(task::spawn(async move {
+            Operation::sync_operation("Config schemas")
+                .track_async_with_check(
+                    || sync_config_schemas(&app_context, false),
+                    |result| result,
+                )
+                .await
+        }));
+    }
+
     if app_context.workspace_config.codeowners.sync_on_run {
         debug!(
             "Syncing code owners ({} enabled)",

crates/actions/src/operations/mod.rs

@@ -1,5 +1,7 @@
 mod sync_codeowners;
+mod sync_config_schemas;
 mod sync_vcs_hooks;
 
 pub use sync_codeowners::*;
+pub use sync_config_schemas::*;
 pub use sync_vcs_hooks::*;

crates/actions/src/operations/sync_config_schemas.rs

@@ -0,0 +1,41 @@
+use moon_app_context::AppContext;
+use moon_common::color;
+use moon_config::Version;
+use moon_config_schema::json_schemas::generate_json_schemas;
+use moon_hash::hash_content;
+use tracing::{instrument, warn};
+
+hash_content!(
+    pub struct ConfigSchemaHash<'cfg> {
+        moon_version: &'cfg Version,
+    }
+);
+
+#[instrument(skip_all)]
+pub async fn sync_config_schemas(app_context: &AppContext, force: bool) -> miette::Result<bool> {
+    let out_dir = app_context.cache_engine.cache_dir.join("schemas");
+
+    if let Err(error) = if force {
+        generate_json_schemas(out_dir).map(|_| true)
+    } else {
+        app_context
+            .cache_engine
+            .execute_if_changed(
+                "configSchemas.json",
+                ConfigSchemaHash {
+                    moon_version: &app_context.cli_version,
+                },
+                || async { generate_json_schemas(out_dir) },
+            )
+            .await
+    } {
+        warn!(
+            "Failed to generate schemas for configuration: {}",
+            color::muted_light(error.to_string())
+        );
+
+        return Ok(false);
+    }
+
+    Ok(true)
+}

crates/app-context/src/app_context.rs

@@ -1,12 +1,14 @@
 use moon_cache::CacheEngine;
-use moon_config::{ToolchainConfig, WorkspaceConfig};
+use moon_config::{ToolchainConfig, Version, WorkspaceConfig};
 use moon_console::Console;
 use moon_vcs::BoxedVcs;
 use std::path::PathBuf;
 use std::sync::Arc;
 
 #[derive(Clone)]
 pub struct AppContext {
+    pub cli_version: Version,
+
     // Components
     pub cache_engine: Arc<CacheEngine>,
     pub console: Arc<Console>,

crates/app/src/commands/sync.rs

@@ -1,4 +1,5 @@
 use super::syncs::codeowners::SyncCodeownersArgs;
+use super::syncs::config_schemas::SyncConfigSchemasArgs;
 use super::syncs::hooks::SyncHooksArgs;
 use crate::session::CliSession;
 use clap::Subcommand;
@@ -14,6 +15,12 @@ pub enum SyncCommands {
     )]
     Codeowners(SyncCodeownersArgs),
 
+    #[command(
+        name = "config-schemas",
+        about = "Generate and sync configuration JSON schemas for use within editors."
+    )]
+    ConfigSchemas(SyncConfigSchemasArgs),
+
     #[command(
         name = "hooks",
         about = "Generate and sync hook scripts for the workspace configured VCS."

crates/app/src/commands/syncs/config_schemas.rs

@@ -0,0 +1,25 @@
+use crate::helpers::create_progress_bar;
+use crate::session::CliSession;
+use clap::Args;
+use moon_actions::operations::sync_config_schemas;
+use starbase::AppResult;
+use tracing::instrument;
+
+#[derive(Args, Clone, Debug)]
+pub struct SyncConfigSchemasArgs {
+    #[arg(long, help = "Bypass cache and force create schemas")]
+    force: bool,
+}
+
+#[instrument(skip_all)]
+pub async fn sync(session: CliSession, args: SyncConfigSchemasArgs) -> AppResult {
+    let done = create_progress_bar("Generating configuration schemas...");
+
+    let context = session.get_app_context()?;
+
+    sync_config_schemas(&context, args.force).await?;
+
+    done("Successfully generated schemas", true);
+
+    Ok(())
+}

crates/app/src/commands/syncs/mod.rs

@@ -1,3 +1,4 @@
 pub mod codeowners;
+pub mod config_schemas;
 pub mod hooks;
 pub mod projects;

crates/app/src/session.rs

@@ -92,6 +92,7 @@ impl CliSession {
 
     pub fn get_app_context(&self) -> AppResult<Arc<AppContext>> {
         Ok(Arc::new(AppContext {
+            cli_version: self.cli_version.clone(),
             cache_engine: self.get_cache_engine()?,
             console: Arc::new(self.console.clone()),
             vcs: self.get_vcs_adapter()?,

crates/cli/src/main.rs

@@ -174,6 +174,9 @@ async fn main() -> MainResult {
                     Some(SyncCommands::Codeowners(args)) => {
                         commands::syncs::codeowners::sync(session, args).await
                     }
+                    Some(SyncCommands::ConfigSchemas(args)) => {
+                        commands::syncs::config_schemas::sync(session, args).await
+                    }
                     Some(SyncCommands::Hooks(args)) => {
                         commands::syncs::hooks::sync(session, args).await
                     }

crates/cli/tests/sync_test.rs

@@ -47,6 +47,26 @@ mod sync_codeowners {
     }
 }
 
+mod sync_config_schemas {
+    use super::*;
+
+    #[test]
+    fn creates_schemas_dir() {
+        let (workspace_config, _, _) = get_cases_fixture_configs();
+        let sandbox = create_sandbox_with_config("cases", Some(workspace_config), None, None);
+
+        assert!(!sandbox.path().join(".moon/cache/schemas").exists());
+
+        sandbox
+            .run_moon(|cmd| {
+                cmd.arg("sync").arg("config-schemas");
+            })
+            .success();
+
+        assert!(sandbox.path().join(".moon/cache/schemas").exists());
+    }
+}
+
 mod sync_hooks {
     use super::*;
 

crates/config-schema/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "moon_config_schema"
+version = "0.0.1"
+edition = "2021"
+license = "MIT"
+description = "Config schema generator."
+homepage = "https://moonrepo.dev/moon"
+repository = "https://github.com/moonrepo/moon"
+publish = false
+
+[dependencies]
+moon_config = { path = "../config" }
+miette = { workspace = true }
+schematic = { workspace = true, features = ["renderer_json_schema", "schema"] }
+
+[features]
+default = []
+typescript = ["schematic/renderer_typescript"]
+
+[lints]
+workspace = true

crates/config-schema/src/json_schemas.rs

@@ -0,0 +1,62 @@
+use moon_config::*;
+use schematic::schema::json_schema::{JsonSchemaOptions, JsonSchemaRenderer};
+use schematic::schema::SchemaGenerator;
+use std::path::Path;
+
+fn create_jsonschema_renderer() -> JsonSchemaRenderer<'static> {
+    JsonSchemaRenderer::new(JsonSchemaOptions {
+        markdown_description: true,
+        mark_struct_fields_required: false,
+        set_field_name_as_title: true,
+        ..JsonSchemaOptions::default()
+    })
+}
+
+fn generate_project(out_dir: &Path) -> miette::Result<()> {
+    let mut generator = SchemaGenerator::default();
+    generator.add::<ProjectConfig>();
+    generator.generate(out_dir.join("project.json"), create_jsonschema_renderer())
+}
+
+fn generate_tasks(out_dir: &Path) -> miette::Result<()> {
+    let mut generator = SchemaGenerator::default();
+    generator.add::<InheritedTasksConfig>();
+    generator.generate(out_dir.join("tasks.json"), create_jsonschema_renderer())
+}
+
+fn generate_template(out_dir: &Path) -> miette::Result<()> {
+    let mut generator = SchemaGenerator::default();
+    generator.add::<TemplateConfig>();
+    generator.generate(out_dir.join("template.json"), create_jsonschema_renderer())?;
+
+    let mut generator = SchemaGenerator::default();
+    generator.add::<TemplateFrontmatterConfig>();
+    generator.generate(
+        out_dir.join("template-frontmatter.json"),
+        create_jsonschema_renderer(),
+    )
+}
+
+fn generate_toolchain(out_dir: &Path) -> miette::Result<()> {
+    let mut generator = SchemaGenerator::default();
+    generator.add::<ToolchainConfig>();
+    generator.generate(out_dir.join("toolchain.json"), create_jsonschema_renderer())
+}
+
+fn generate_workspace(out_dir: &Path) -> miette::Result<()> {
+    let mut generator = SchemaGenerator::default();
+    generator.add::<WorkspaceConfig>();
+    generator.generate(out_dir.join("workspace.json"), create_jsonschema_renderer())
+}
+
+pub fn generate_json_schemas(out_dir: impl AsRef<Path>) -> miette::Result<()> {
+    let out_dir = out_dir.as_ref();
+
+    generate_project(out_dir)?;
+    generate_tasks(out_dir)?;
+    generate_template(out_dir)?;
+    generate_toolchain(out_dir)?;
+    generate_workspace(out_dir)?;
+
+    Ok(())
+}

crates/config-schema/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod json_schemas;
+#[cfg(feature = "typescript")]
+pub mod typescript_types;

crates/config-schema/src/main.rs

@@ -0,0 +1,24 @@
+use moon_config_schema::json_schemas::generate_json_schemas;
+#[cfg(feature = "typescript")]
+use moon_config_schema::typescript_types::generate_typescript_types;
+use std::env;
+use std::process::Command;
+
+fn main() {
+    let cwd = env::current_dir().unwrap();
+
+    generate_json_schemas(cwd.join("website/static/schemas")).unwrap();
+
+    #[cfg(feature = "typescript")]
+    generate_typescript_types(cwd.join("packages/types/src")).unwrap();
+
+    // Run prettier
+    let prettier = cwd.join("node_modules/.bin/prettier");
+
+    if prettier.exists() {
+        let mut cmd = Command::new(prettier);
+        cmd.args(["--write", "packages/types"]);
+        cmd.current_dir(cwd);
+        cmd.output().unwrap();
+    }
+}