1use serde::{Deserialize, Serialize};
4
5use crate::PluginId;
6
7#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
9#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
10#[serde(rename_all = "camelCase", deny_unknown_fields)]
11#[cfg_attr(feature = "codegen", schemars(title = "Modelith plugin manifest"))]
12pub struct PluginManifest {
13 pub id: PluginId,
14 pub name: String,
16 #[cfg_attr(
18 feature = "codegen",
19 schemars(regex(pattern = r"^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$"))
20 )]
21 pub version: String,
22 #[cfg_attr(feature = "codegen", schemars(regex(pattern = r"^\d+$")))]
24 pub api_version: String,
25 pub runtime: Runtime,
26 #[serde(default, skip_serializing_if = "Option::is_none")]
27 #[cfg_attr(feature = "codegen", ts(optional))]
28 pub description: Option<String>,
29 #[serde(default, skip_serializing_if = "Option::is_none")]
31 #[cfg_attr(feature = "codegen", ts(optional))]
32 pub author: Option<String>,
33 pub license: String,
35 #[serde(default, skip_serializing_if = "Option::is_none")]
37 #[cfg_attr(feature = "codegen", ts(optional))]
38 pub engines: Option<Engines>,
39 #[serde(default, skip_serializing_if = "Option::is_none")]
44 #[cfg_attr(feature = "codegen", ts(optional))]
45 pub main: Option<String>,
46 #[serde(default)]
48 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Permission>>", optional))]
49 pub permissions: Vec<Permission>,
50 #[serde(default)]
51 #[cfg_attr(feature = "codegen", ts(as = "Option<Contributes>", optional))]
52 pub contributes: Contributes,
53}
54
55#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
60#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
61#[serde(rename_all = "camelCase", deny_unknown_fields)]
62pub struct Engines {
63 #[cfg_attr(
67 feature = "codegen",
68 schemars(regex(
69 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*$"
70 ))
71 )]
72 pub modelith: String,
73}
74
75#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
77#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
78#[serde(rename_all = "kebab-case")]
79pub enum Runtime {
80 Rules,
82 Browser,
84 WasmComponent,
86}
87
88#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
90#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
91pub enum Permission {
92 #[serde(rename = "model:read")]
94 ModelRead,
95 #[serde(rename = "edits:propose")]
97 EditsPropose,
98 #[serde(rename = "network")]
100 Network,
101 #[serde(rename = "storage")]
103 Storage,
104}
105
106#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
108#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
109#[serde(rename_all = "camelCase", deny_unknown_fields)]
110pub struct Contributes {
111 #[serde(default, skip_serializing_if = "Vec::is_empty")]
113 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<String>>", optional))]
114 pub rules: Vec<String>,
115 #[serde(default, skip_serializing_if = "Vec::is_empty")]
116 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Importer>>", optional))]
117 pub importers: Vec<Importer>,
118 #[serde(default, skip_serializing_if = "Vec::is_empty")]
119 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Exporter>>", optional))]
120 pub exporters: Vec<Exporter>,
121 #[serde(default, skip_serializing_if = "Vec::is_empty")]
122 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<View>>", optional))]
123 pub views: Vec<View>,
124 #[serde(default, skip_serializing_if = "Vec::is_empty")]
125 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<PaletteItem>>", optional))]
126 pub palette: Vec<PaletteItem>,
127 #[serde(default, skip_serializing_if = "Vec::is_empty")]
128 #[cfg_attr(feature = "codegen", ts(as = "Option<Vec<Command>>", optional))]
129 pub commands: Vec<Command>,
130}
131
132#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
133#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
134#[serde(rename_all = "camelCase", deny_unknown_fields)]
135pub struct Importer {
136 pub id: String,
137 pub label: String,
138 pub extensions: Vec<String>,
140}
141
142#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
143#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
144#[serde(rename_all = "camelCase", deny_unknown_fields)]
145pub struct Exporter {
146 pub id: String,
147 pub label: String,
148 pub extension: String,
150}
151
152#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
153#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
154#[serde(rename_all = "camelCase", deny_unknown_fields)]
155pub struct View {
156 pub id: String,
157 pub label: String,
158}
159
160#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
161#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
162#[serde(rename_all = "camelCase", deny_unknown_fields)]
163pub struct PaletteItem {
164 pub id: String,
165 pub label: String,
166 pub snippet: String,
168}
169
170#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
171#[cfg_attr(feature = "codegen", derive(schemars::JsonSchema, ts_rs::TS))]
172#[serde(rename_all = "camelCase", deny_unknown_fields)]
173pub struct Command {
174 pub id: String,
175 pub title: String,
176}
177
178#[cfg(test)]
179mod tests {
180 use super::*;
181
182 const BASE: &str = r#""id":"a.b","name":"x","version":"0.1.0","apiVersion":"0","runtime":"browser","license":"MIT""#;
183
184 #[test]
185 fn parses_minimal_rules_manifest() {
186 let json = r#"{
188 "id": "jp.modelith.iso15288-rules",
189 "name": "ISO 15288 フェーズ検査",
190 "version": "0.1.0",
191 "apiVersion": "0",
192 "runtime": "rules",
193 "license": "MIT",
194 "permissions": ["model:read"],
195 "contributes": { "rules": ["rules/phases.yaml"] }
196 }"#;
197 let m: PluginManifest = serde_json::from_str(json).unwrap();
199 assert_eq!(
201 (m.runtime, m.permissions, m.contributes.rules),
202 (
203 Runtime::Rules,
204 vec![Permission::ModelRead],
205 vec!["rules/phases.yaml".to_owned()]
206 )
207 );
208 }
209
210 #[test]
211 fn omitted_optional_fields_default_to_empty() {
212 let json = format!("{{{BASE}}}");
214 let m: PluginManifest = serde_json::from_str(&json).unwrap();
216 assert_eq!(
218 (m.permissions.len(), m.contributes, m.main),
219 (0, Contributes::default(), None)
220 );
221 }
222
223 #[test]
224 fn parses_author() {
225 let json = format!("{{{BASE},\"author\":\"Example Inc.\"}}");
227 let m: PluginManifest = serde_json::from_str(&json).unwrap();
229 assert_eq!(m.author.as_deref(), Some("Example Inc."));
231 }
232
233 #[test]
234 fn omitted_author_is_none() {
235 let json = format!("{{{BASE}}}");
237 let m: PluginManifest = serde_json::from_str(&json).unwrap();
239 assert_eq!(m.author, None);
241 }
242
243 #[test]
244 fn parses_engines_range() {
245 let json = format!("{{{BASE},\"engines\":{{\"modelith\":\">=0.1.0, <0.3.0\"}}}}");
247 let m: PluginManifest = serde_json::from_str(&json).unwrap();
249 assert_eq!(
251 m.engines.map(|e| e.modelith).as_deref(),
252 Some(">=0.1.0, <0.3.0")
253 );
254 }
255
256 #[test]
257 fn omitted_engines_is_none() {
258 let json = format!("{{{BASE}}}");
260 let m: PluginManifest = serde_json::from_str(&json).unwrap();
262 assert_eq!(m.engines, None);
264 }
265
266 #[test]
267 fn rejects_engines_without_modelith_or_with_unknown_host() {
268 let missing = format!("{{{BASE},\"engines\":{{}}}}");
270 let unknown = format!("{{{BASE},\"engines\":{{\"modelith\":\"^0.2\",\"cli\":\"^1\"}}}}");
271 assert!(serde_json::from_str::<PluginManifest>(&missing).is_err());
273 assert!(serde_json::from_str::<PluginManifest>(&unknown).is_err());
274 }
275
276 #[test]
277 fn rejects_unknown_field() {
278 let json = format!("{{{BASE},\"extra\":1}}");
280 let result = serde_json::from_str::<PluginManifest>(&json);
282 assert!(result.is_err());
284 }
285
286 #[test]
287 fn rejects_unknown_permission() {
288 let json = format!("{{{BASE},\"permissions\":[\"fs\"]}}");
290 let result = serde_json::from_str::<PluginManifest>(&json);
292 assert!(result.is_err());
294 }
295
296 #[test]
297 fn rejects_missing_required_field() {
298 let json =
300 r#"{"id":"a.b","name":"x","version":"0.1.0","apiVersion":"0","runtime":"browser"}"#;
301 let result = serde_json::from_str::<PluginManifest>(json);
303 assert!(result.is_err());
305 }
306}