use serde::{Deserialize, Serialize};
use crate::PluginId;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
#[cfg_attr(feature = "codegen", schemars(title = "Modelith plugin manifest"))]
pub struct PluginManifest {
pub id: PluginId,
pub name: String,
#[cfg_attr(
feature = "codegen",
schemars(regex(pattern = r"^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$"))
)]
pub version: String,
#[cfg_attr(feature = "codegen", schemars(regex(pattern = r"^\d+$")))]
pub api_version: String,
pub runtime: Runtime,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub author: Option<String>,
pub license: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub engines: Option<Engines>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[cfg_attr(feature = "codegen", ts(optional))]
pub main: Option<String>,
#[serde(default)]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Permission>>", optional))]
pub permissions: Vec<Permission>,
#[serde(default)]
#[cfg_attr(feature = "codegen", ts(as = "Option<Contributes>", optional))]
pub contributes: Contributes,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Engines {
#[cfg_attr(
feature = "codegen",
schemars(regex(
pattern = r"^\s*(\*|(=|>=?|<=?|~|\^)?\s*\d+(\.(\d+|[xX*])){0,2}([-+][0-9A-Za-z.-]+)*)(\s*,\s*(\*|(=|>=?|<=?|~|\^)?\s*\d+(\.(\d+|[xX*])){0,2}([-+][0-9A-Za-z.-]+)*))*\s*$"
))
)]
pub modelith: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "kebab-case")]
pub enum Runtime {
Rules,
Browser,
WasmComponent,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
pub enum Permission {
#[serde(rename = "model:read")]
ModelRead,
#[serde(rename = "edits:propose")]
EditsPropose,
#[serde(rename = "network")]
Network,
#[serde(rename = "storage")]
Storage,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Contributes {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<String>>", optional))]
pub rules: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Importer>>", optional))]
pub importers: Vec<Importer>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Exporter>>", optional))]
pub exporters: Vec<Exporter>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<View>>", optional))]
pub views: Vec<View>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<PaletteItem>>", optional))]
pub palette: Vec<PaletteItem>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Command>>", optional))]
pub commands: Vec<Command>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Importer {
pub id: String,
pub label: String,
pub extensions: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Exporter {
pub id: String,
pub label: String,
pub extension: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct View {
pub id: String,
pub label: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct PaletteItem {
pub id: String,
pub label: String,
pub snippet: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Command {
pub id: String,
pub title: String,
}
#[cfg(test)]
mod tests {
use super::*;
const BASE: &str = r#""id":"a.b","name":"x","version":"0.1.0","apiVersion":"0","runtime":"browser","license":"MIT""#;
#[test]
fn parses_minimal_rules_manifest() {
let json = r#"{
"id": "jp.modelith.iso15288-rules",
"name": "ISO 15288 フェーズ検査",
"version": "0.1.0",
"apiVersion": "0",
"runtime": "rules",
"license": "MIT",
"permissions": ["model:read"],
"contributes": { "rules": ["rules/phases.yaml"] }
}"#;
let m: PluginManifest = serde_json::from_str(json).unwrap();
assert_eq!(
(m.runtime, m.permissions, m.contributes.rules),
(
Runtime::Rules,
vec![Permission::ModelRead],
vec!["rules/phases.yaml".to_owned()]
)
);
}
#[test]
fn omitted_optional_fields_default_to_empty() {
let json = format!("{{{BASE}}}");
let m: PluginManifest = serde_json::from_str(&json).unwrap();
assert_eq!(
(m.permissions.len(), m.contributes, m.main),
(0, Contributes::default(), None)
);
}
#[test]
fn parses_author() {
let json = format!("{{{BASE},\"author\":\"Example Inc.\"}}");
let m: PluginManifest = serde_json::from_str(&json).unwrap();
assert_eq!(m.author.as_deref(), Some("Example Inc."));
}
#[test]
fn omitted_author_is_none() {
let json = format!("{{{BASE}}}");
let m: PluginManifest = serde_json::from_str(&json).unwrap();
assert_eq!(m.author, None);
}
#[test]
fn parses_engines_range() {
let json = format!("{{{BASE},\"engines\":{{\"modelith\":\">=0.1.0, <0.3.0\"}}}}");
let m: PluginManifest = serde_json::from_str(&json).unwrap();
assert_eq!(
m.engines.map(|e| e.modelith).as_deref(),
Some(">=0.1.0, <0.3.0")
);
}
#[test]
fn omitted_engines_is_none() {
let json = format!("{{{BASE}}}");
let m: PluginManifest = serde_json::from_str(&json).unwrap();
assert_eq!(m.engines, None);
}
#[test]
fn rejects_engines_without_modelith_or_with_unknown_host() {
let missing = format!("{{{BASE},\"engines\":{{}}}}");
let unknown = format!("{{{BASE},\"engines\":{{\"modelith\":\"^0.2\",\"cli\":\"^1\"}}}}");
assert!(serde_json::from_str::<PluginManifest>(&missing).is_err());
assert!(serde_json::from_str::<PluginManifest>(&unknown).is_err());
}
#[test]
fn rejects_unknown_field() {
let json = format!("{{{BASE},\"extra\":1}}");
let result = serde_json::from_str::<PluginManifest>(&json);
assert!(result.is_err());
}
#[test]
fn rejects_unknown_permission() {
let json = format!("{{{BASE},\"permissions\":[\"fs\"]}}");
let result = serde_json::from_str::<PluginManifest>(&json);
assert!(result.is_err());
}
#[test]
fn rejects_missing_required_field() {
let json =
r#"{"id":"a.b","name":"x","version":"0.1.0","apiVersion":"0","runtime":"browser"}"#;
let result = serde_json::from_str::<PluginManifest>(json);
assert!(result.is_err());
}
}