Skip to main content

morphir_extension_sdk/
lib.rs

1//! Morphir Extension SDK
2//!
3//! This crate provides the SDK for building Morphir extensions as WASM plugins.
4//! Extensions communicate with the host daemon via JSON-RPC 2.0 payloads.
5//!
6//! # Platform boundary
7//!
8//! Protocol types and extension traits compile on native and WASM targets. The
9//! Extism PDK, guest exports, and imported host functions compile only for
10//! `wasm32`. Native hosts must use the Extism runtime crate and must not link
11//! guest PDK imports.
12//!
13//! # Quick Start
14//!
15//! ```rust
16//! use morphir_extension_sdk::prelude::*;
17//!
18//! #[derive(Default)]
19//! struct MyExtension;
20//!
21//! impl Extension for MyExtension {
22//!     fn info() -> ExtensionInfo {
23//!         ExtensionInfo {
24//!             id: "my-extension".into(),
25//!             name: "My Extension".into(),
26//!             version: env!("CARGO_PKG_VERSION").into(),
27//!             types: vec![ExtensionType::Frontend],
28//!             ..Default::default()
29//!         }
30//!     }
31//!
32//!     fn capabilities() -> ExtensionCapabilities {
33//!         ExtensionCapabilities {
34//!             frontend: Some(FrontendCapability {
35//!                 languages: vec![LanguageCapability {
36//!                     id: "my-lang".into(),
37//!                     file_extensions: vec![".ml".into()],
38//!                 }],
39//!                 ir_versions: vec!["3".into()],
40//!                 compile: true,
41//!                 incremental: false,
42//!                 fragments: false,
43//!                 multi_document: false,
44//!             }),
45//!             ..ExtensionCapabilities::default()
46//!         }
47//!     }
48//! }
49//!
50//! impl Frontend for MyExtension {
51//!     fn compile(&self, request: CompileRequest) -> Result<CompileResult> {
52//!         Ok(CompileResult {
53//!             success: true,
54//!             ir_version: Some(request.options.ir_version),
55//!             ir: Some(serde_json::json!({})),
56//!             diagnostics: vec![],
57//!             modules: request.package.exposed_modules.unwrap_or_default(),
58//!             module_results: vec![],
59//!             context_digest: None,
60//!         })
61//!     }
62//!
63//!     fn supported_languages() -> Vec<String> {
64//!         vec!["my-lang".into()]
65//!     }
66//!
67//!     fn file_extensions() -> Vec<String> {
68//!         vec![".ml".into()]
69//!     }
70//! }
71//!
72//! let request = CompileRequest {
73//!     language_id: "my-lang".into(),
74//!     sources: SourceSet {
75//!         root: None,
76//!         documents: vec![SourceDocument {
77//!             uri: "file:///workspace/Example.ml".into(),
78//!             language_id: "my-lang".into(),
79//!             version: 1,
80//!             text: "module Example".into(),
81//!         }],
82//!     },
83//!     package: CompilePackage {
84//!         name: "local/example".into(),
85//!         exposed_modules: Some(vec!["Example".into()]),
86//!     },
87//!     dependencies: vec![],
88//!     options: CompileOptions {
89//!         types_only: false,
90//!         ir_version: "3".into(),
91//!         extra: Default::default(),
92//!     },
93//!     baseline: None,
94//! };
95//! let result = MyExtension.compile(request).expect("frontend should compile");
96//! assert!(result.success);
97//!
98//! morphir_extension_sdk::export_extension!(MyExtension, frontend);
99//! ```
100
101pub mod claims;
102pub mod error;
103#[cfg(target_arch = "wasm32")]
104pub mod host;
105mod lifecycle;
106mod literal_json;
107pub mod model;
108pub mod native;
109pub mod prelude;
110pub mod protocol;
111pub mod source;
112pub mod traits;
113pub mod types;
114
115// Re-exports
116pub use error::{ExtensionError, Result};
117#[doc(hidden)]
118pub use lifecycle::ProtocolSession as __ProtocolSession;
119pub use native::{NativeBackend, NativeExtension, NativeFrontend, NativeProtocol, NativeWorkspace};
120pub use source::{SourceContextError, SourcePath, SourceRoot};
121pub use traits::{Backend, Extension, Frontend, Transform, Validator, Workspace};
122pub use types::*;
123
124/// Export an extension implementation with JSON-RPC dispatch
125///
126/// This macro generates the necessary WASM exports for your extension:
127/// - `morphir_extension_info`: Returns extension metadata
128/// - `handle`: Main JSON-RPC request handler
129#[macro_export]
130macro_rules! export_extension {
131    ($impl:ty, $($capability:ident),+ $(,)?) => {
132        #[cfg(target_arch = "wasm32")]
133        use $crate::extism_pdk as extism_pdk;
134        #[cfg(target_arch = "wasm32")]
135        use extism_pdk::*;
136
137        /// Extension info function (required by host)
138        #[cfg(target_arch = "wasm32")]
139        #[plugin_fn]
140        pub fn morphir_extension_info() -> FnResult<Json<$crate::ExtensionInfo>> {
141            let mut declared_types = Vec::new();
142            $crate::__push_extension_types!(declared_types, $($capability),+);
143            Ok(Json($crate::__extension_info::<$impl>(&declared_types)))
144        }
145
146        /// Extension capabilities function
147        #[cfg(target_arch = "wasm32")]
148        #[plugin_fn]
149        pub fn morphir_extension_capabilities() -> FnResult<Json<$crate::ExtensionCapabilities>> {
150            Ok(Json(<$impl as $crate::Extension>::capabilities()))
151        }
152
153        /// Main JSON-RPC handler
154        #[cfg(target_arch = "wasm32")]
155        #[plugin_fn]
156        pub fn handle(
157            Json(request): Json<$crate::protocol::ExtensionRequest>,
158        ) -> FnResult<Json<$crate::protocol::ExtensionResponse>> {
159            static SESSION: $crate::__ProtocolSession = $crate::__ProtocolSession::new();
160            let mut dispatchers: Vec<$crate::DispatchFn<$impl>> = Vec::new();
161            let mut declared_types = Vec::new();
162            $crate::__push_extension_dispatchers!(dispatchers, $impl, $($capability),+);
163            $crate::__push_extension_types!(declared_types, $($capability),+);
164            let result = SESSION.dispatch(&request, || $crate::__dispatch_request::<$impl>(
165                &request,
166                &dispatchers,
167                &declared_types,
168            ));
169            Ok(Json(result))
170        }
171    };
172}
173
174/// Add declared extension capability types to generated guest metadata.
175#[doc(hidden)]
176#[macro_export]
177macro_rules! __push_extension_types {
178    ($types:ident, backend $(, $remaining:ident)*) => {
179        $types.push($crate::ExtensionType::Backend);
180        $crate::__push_extension_types!($types $(, $remaining)*);
181    };
182    ($types:ident, frontend $(, $remaining:ident)*) => {
183        $types.push($crate::ExtensionType::Frontend);
184        $crate::__push_extension_types!($types $(, $remaining)*);
185    };
186    ($types:ident, validator $(, $remaining:ident)*) => {
187        $types.push($crate::ExtensionType::Validator);
188        $crate::__push_extension_types!($types $(, $remaining)*);
189    };
190    ($types:ident, transform $(, $remaining:ident)*) => {
191        $types.push($crate::ExtensionType::Transform);
192        $crate::__push_extension_types!($types $(, $remaining)*);
193    };
194    ($types:ident, workspace $(, $remaining:ident)*) => {
195        $types.push($crate::ExtensionType::Workspace);
196        $crate::__push_extension_types!($types $(, $remaining)*);
197    };
198    ($types:ident) => {};
199}
200
201/// Add declared extension capabilities to the generated guest dispatcher.
202#[doc(hidden)]
203#[macro_export]
204macro_rules! __push_extension_dispatchers {
205    ($dispatchers:ident, $impl:ty, backend $(, $remaining:ident)*) => {
206        $dispatchers.push($crate::__dispatch_backend::<$impl>);
207        $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
208    };
209    ($dispatchers:ident, $impl:ty, frontend $(, $remaining:ident)*) => {
210        $dispatchers.push($crate::__dispatch_frontend::<$impl>);
211        $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
212    };
213    ($dispatchers:ident, $impl:ty, validator $(, $remaining:ident)*) => {
214        $dispatchers.push($crate::__dispatch_validator::<$impl>);
215        $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
216    };
217    ($dispatchers:ident, $impl:ty, transform $(, $remaining:ident)*) => {
218        $dispatchers.push($crate::__dispatch_transform::<$impl>);
219        $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
220    };
221    ($dispatchers:ident, $impl:ty, workspace $(, $remaining:ident)*) => {
222        $dispatchers.push($crate::__dispatch_workspace::<$impl>);
223        $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
224    };
225    ($dispatchers:ident, $impl:ty) => {};
226}
227
228// Native builds exercise extension implementations without importing guest PDK symbols.
229#[cfg(not(target_arch = "wasm32"))]
230#[macro_export]
231macro_rules! host_debug {
232    ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
233}
234
235#[cfg(not(target_arch = "wasm32"))]
236#[macro_export]
237macro_rules! host_info {
238    ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
239}
240
241#[cfg(not(target_arch = "wasm32"))]
242#[macro_export]
243macro_rules! host_warn {
244    ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
245}
246
247#[cfg(not(target_arch = "wasm32"))]
248#[macro_export]
249macro_rules! host_error {
250    ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
251}
252
253/// A capability-specific request dispatcher used by [`export_extension!`].
254#[doc(hidden)]
255pub type DispatchFn<E> = fn(
256    &E,
257    &protocol::ExtensionRequest,
258) -> Option<std::result::Result<serde_json::Value, ExtensionError>>;
259
260/// A role's protocol dispatcher, erased over the extension type.
261///
262/// [`DispatchFn`] takes `&E`, so it cannot be stored beside a type-erased role
263/// handle. Capturing the shared `Arc<E>` in a closure lets one role record own
264/// its handle and its dispatcher together, which is what keeps them from
265/// disagreeing.
266pub(crate) type NativeRoleDispatch = std::sync::Arc<
267    dyn Fn(
268            &protocol::ExtensionRequest,
269        ) -> Option<std::result::Result<serde_json::Value, ExtensionError>>
270        + Send
271        + Sync,
272>;
273
274/// Bind a typed dispatcher to a shared extension instance.
275pub(crate) fn erase_dispatch<E>(
276    extension: std::sync::Arc<E>,
277    dispatch: DispatchFn<E>,
278) -> NativeRoleDispatch
279where
280    E: Send + Sync + 'static,
281{
282    std::sync::Arc::new(move |request| dispatch(extension.as_ref(), request))
283}
284
285/// Return extension metadata aligned with the macro-declared capabilities.
286#[doc(hidden)]
287pub fn __extension_info<E: Extension>(declared_types: &[ExtensionType]) -> ExtensionInfo {
288    let mut info = E::info();
289    info.types = declared_types.to_vec();
290    info
291}
292
293/// Stateless dispatch used inside the session guard in [`export_extension!`].
294///
295/// Calling this helper directly bypasses lifecycle checks. Generated guests
296/// keep a separate session guard across calls and construct a default extension
297/// only when dispatching an extension operation.
298#[doc(hidden)]
299pub fn __dispatch_request<E: Extension + Default>(
300    request: &protocol::ExtensionRequest,
301    dispatchers: &[DispatchFn<E>],
302    declared_types: &[ExtensionType],
303) -> protocol::ExtensionResponse {
304    use protocol::methods;
305
306    match request.method.as_str() {
307        methods::DESCRIBE => dispatch_response(
308            &request.id,
309            dispatch_describe_with_metadata(
310                request,
311                &__extension_info::<E>(declared_types),
312                &E::capabilities(),
313            ),
314        ),
315        methods::INITIALIZE => dispatch_response(
316            &request.id,
317            dispatch_initialize::<E>(request, declared_types),
318        ),
319        methods::PING => dispatch_response(&request.id, Ok(serde_json::json!({ "ok": true }))),
320        methods::INFO => dispatch_response(
321            &request.id,
322            serde_json::to_value(__extension_info::<E>(declared_types))
323                .map_err(ExtensionError::from),
324        ),
325        methods::CAPABILITIES => dispatch_response(
326            &request.id,
327            serde_json::to_value(E::capabilities()).map_err(ExtensionError::from),
328        ),
329        methods::SHUTDOWN => dispatch_response(&request.id, Ok(serde_json::json!({}))),
330        _ => __dispatch_request_with(&E::default(), request, dispatchers, declared_types),
331    }
332}
333
334/// Dispatch a protocol request to an existing extension instance.
335///
336/// This low-level helper does not enforce protocol lifecycle ordering. Native
337/// hosts use [`NativeExtension::protocol`] for session-aware dispatch. The WASM
338/// export helper instantiates a default extension through [`__dispatch_request`].
339#[doc(hidden)]
340pub fn __dispatch_request_with<E: Extension>(
341    extension: &E,
342    request: &protocol::ExtensionRequest,
343    dispatchers: &[DispatchFn<E>],
344    declared_types: &[ExtensionType],
345) -> protocol::ExtensionResponse {
346    use protocol::methods;
347
348    match request.method.as_str() {
349        methods::DESCRIBE => dispatch_response(
350            &request.id,
351            dispatch_describe_with_metadata(
352                request,
353                &__extension_info::<E>(declared_types),
354                &E::capabilities(),
355            ),
356        ),
357        methods::INITIALIZE => {
358            let info = __extension_info::<E>(declared_types);
359            let capabilities = E::capabilities();
360            dispatch_response(
361                &request.id,
362                dispatch_initialize_with_metadata(request, &info, &capabilities),
363            )
364        }
365        methods::PING => dispatch_response(&request.id, Ok(serde_json::json!({ "ok": true }))),
366        methods::INFO => dispatch_response(
367            &request.id,
368            serde_json::to_value(__extension_info::<E>(declared_types))
369                .map_err(ExtensionError::from),
370        ),
371        methods::CAPABILITIES => dispatch_response(
372            &request.id,
373            serde_json::to_value(E::capabilities()).map_err(ExtensionError::from),
374        ),
375        methods::SHUTDOWN => dispatch_response(&request.id, Ok(serde_json::json!({}))),
376        _ => dispatch_capability_response(extension, request, dispatchers),
377    }
378}
379
380fn dispatch_role_response(
381    request: &protocol::ExtensionRequest,
382    dispatchers: &[NativeRoleDispatch],
383) -> protocol::ExtensionResponse {
384    for dispatch in dispatchers {
385        if let Some(result) = dispatch(request) {
386            return dispatch_response(&request.id, result);
387        }
388    }
389    protocol::ExtensionResponse::error_with_id(
390        request.id.clone(),
391        protocol::RpcError::method_not_found(&request.method),
392    )
393}
394
395pub(crate) fn dispatch_request_with_roles(
396    request: &protocol::ExtensionRequest,
397    dispatchers: &[NativeRoleDispatch],
398    info: &ExtensionInfo,
399    capabilities: &ExtensionCapabilities,
400) -> protocol::ExtensionResponse {
401    use protocol::methods;
402
403    let result = match request.method.as_str() {
404        methods::DESCRIBE => dispatch_describe_with_metadata(request, info, capabilities),
405        methods::INITIALIZE => dispatch_initialize_with_metadata(request, info, capabilities),
406        methods::PING => Ok(serde_json::json!({ "ok": true })),
407        methods::INFO => serde_json::to_value(info).map_err(ExtensionError::from),
408        methods::CAPABILITIES => serde_json::to_value(capabilities).map_err(ExtensionError::from),
409        methods::SHUTDOWN => Ok(serde_json::json!({})),
410        _ => return dispatch_role_response(request, dispatchers),
411    };
412
413    dispatch_response(&request.id, result)
414}
415
416fn dispatch_capability_response<E>(
417    extension: &E,
418    request: &protocol::ExtensionRequest,
419    dispatchers: &[DispatchFn<E>],
420) -> protocol::ExtensionResponse {
421    match dispatch_capability_request(extension, request, dispatchers) {
422        Some(result) => dispatch_response(&request.id, result),
423        None => protocol::ExtensionResponse::error_with_id(
424            request.id.clone(),
425            protocol::RpcError::method_not_found(&request.method),
426        ),
427    }
428}
429
430fn dispatch_capability_request<E>(
431    extension: &E,
432    request: &protocol::ExtensionRequest,
433    dispatchers: &[DispatchFn<E>],
434) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
435    dispatchers
436        .iter()
437        .find_map(|dispatch| dispatch(extension, request))
438}
439
440fn dispatch_response(
441    request_id: &protocol::RequestId,
442    result: std::result::Result<serde_json::Value, ExtensionError>,
443) -> protocol::ExtensionResponse {
444    match result {
445        Ok(value) => protocol::ExtensionResponse {
446            jsonrpc: "2.0".to_string(),
447            result: Some(value),
448            error: None,
449            id: request_id.clone(),
450        },
451        Err(error) => {
452            protocol::ExtensionResponse::from_extension_error_with_id(request_id.clone(), &error)
453        }
454    }
455}
456
457fn dispatch_describe_with_metadata(
458    request: &protocol::ExtensionRequest,
459    info: &ExtensionInfo,
460    capabilities: &ExtensionCapabilities,
461) -> std::result::Result<serde_json::Value, ExtensionError> {
462    let params: protocol::DescribeParams = serde_json::from_value(request.params.clone())
463        .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
464    let implemented = model::guest::versions(capabilities);
465    if !params
466        .protocol_versions
467        .iter()
468        .any(|version| implemented.contains(version))
469    {
470        return Err(ExtensionError::ProtocolVersionMismatch {
471            host_versions: params.protocol_versions,
472            extension_versions: implemented,
473        });
474    }
475    let claims =
476        claims::CapabilityClaimSet::from_metadata(implemented, info.clone(), capabilities)?;
477    serde_json::to_value(claims).map_err(ExtensionError::from)
478}
479
480fn dispatch_initialize<E: Extension>(
481    request: &protocol::ExtensionRequest,
482    declared_types: &[ExtensionType],
483) -> std::result::Result<serde_json::Value, ExtensionError> {
484    let info = __extension_info::<E>(declared_types);
485    let capabilities = E::capabilities();
486    dispatch_initialize_with_metadata(request, &info, &capabilities)
487}
488
489fn dispatch_initialize_with_metadata(
490    request: &protocol::ExtensionRequest,
491    info: &ExtensionInfo,
492    capabilities: &ExtensionCapabilities,
493) -> std::result::Result<serde_json::Value, ExtensionError> {
494    let params: protocol::InitializeParams = serde_json::from_value(request.params.clone())
495        .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
496    serde_json::to_value(model::guest::initialize(&params, info, capabilities)?)
497        .map_err(ExtensionError::from)
498}
499
500#[doc(hidden)]
501pub fn __dispatch_frontend<E: Frontend>(
502    extension: &E,
503    request: &protocol::ExtensionRequest,
504) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
505    match request.method.as_str() {
506        protocol::methods::COMPILE => Some((|| {
507            let params: types::CompileRequest = serde_json::from_value(request.params.clone())
508                .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
509            serde_json::to_value(extension.compile(params)?).map_err(ExtensionError::from)
510        })()),
511        protocol::methods::COMPILE_MODEL => Some((|| {
512            let params: model::CompileModelRequest = serde_json::from_value(request.params.clone())
513                .map_err(|_| {
514                    ExtensionError::InvalidParams("Invalid model compilation request".into())
515                })?;
516            serde_json::to_value(extension.compile_model(params)?).map_err(ExtensionError::from)
517        })()),
518        _ => None,
519    }
520}
521
522#[doc(hidden)]
523pub fn __dispatch_backend<E: Backend>(
524    extension: &E,
525    request: &protocol::ExtensionRequest,
526) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
527    match request.method.as_str() {
528        protocol::methods::GENERATE => Some((|| {
529            let params: types::GenerateRequest = serde_json::from_value(request.params.clone())
530                .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
531            serde_json::to_value(extension.generate(params)?).map_err(ExtensionError::from)
532        })()),
533        protocol::methods::GENERATE_MODEL => Some((|| {
534            let params: model::GenerateModelRequest =
535                serde_json::from_value(request.params.clone()).map_err(|_| {
536                    ExtensionError::InvalidParams("Invalid model generation request".into())
537                })?;
538            serde_json::to_value(extension.generate_model(params)?).map_err(ExtensionError::from)
539        })()),
540        _ => None,
541    }
542}
543
544#[doc(hidden)]
545pub fn __dispatch_validator<E: Validator>(
546    extension: &E,
547    request: &protocol::ExtensionRequest,
548) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
549    (request.method == protocol::methods::VALIDATE).then(|| {
550        let params: types::ValidateRequest = serde_json::from_value(request.params.clone())
551            .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
552        serde_json::to_value(extension.validate(params)?).map_err(ExtensionError::from)
553    })
554}
555
556#[doc(hidden)]
557pub fn __dispatch_transform<E: Transform>(
558    extension: &E,
559    request: &protocol::ExtensionRequest,
560) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
561    (request.method == protocol::methods::TRANSFORM).then(|| {
562        let params: types::TransformRequest = serde_json::from_value(request.params.clone())
563            .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
564        serde_json::to_value(extension.transform(params)?).map_err(ExtensionError::from)
565    })
566}
567
568#[doc(hidden)]
569pub fn __dispatch_workspace<E: Workspace>(
570    extension: &E,
571    request: &protocol::ExtensionRequest,
572) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
573    (request.method == protocol::methods::WORKSPACE_DISCOVER).then(|| {
574        let params: morphir_workspace::DiscoveryRequest =
575            serde_json::from_value(request.params.clone())
576                .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
577        serde_json::to_value(extension.discover(params)?).map_err(ExtensionError::from)
578    })
579}
580
581// Re-export extism_pdk for use in macro
582#[doc(hidden)]
583#[cfg(target_arch = "wasm32")]
584pub use extism_pdk;
585
586#[cfg(test)]
587mod tests {
588    use super::*;
589    use crate::protocol::{ExtensionRequest, methods};
590    use morphir_workspace::{
591        DiscoveryRequest, DiscoveryResponse, FileEntry, FileTree, RelativePath,
592    };
593    use std::collections::BTreeMap;
594    use std::sync::atomic::{AtomicUsize, Ordering};
595
596    static LAZY_DEFAULT_CONSTRUCTIONS: AtomicUsize = AtomicUsize::new(0);
597    static LAZY_METADATA_INFO_CALLS: AtomicUsize = AtomicUsize::new(0);
598    static LAZY_METADATA_CAPABILITY_CALLS: AtomicUsize = AtomicUsize::new(0);
599
600    struct LazyDefaultExtension;
601
602    impl Default for LazyDefaultExtension {
603        fn default() -> Self {
604            LAZY_DEFAULT_CONSTRUCTIONS.fetch_add(1, Ordering::SeqCst);
605            Self
606        }
607    }
608
609    impl Extension for LazyDefaultExtension {
610        fn info() -> ExtensionInfo {
611            ExtensionInfo::default()
612        }
613    }
614
615    #[derive(Default)]
616    struct MetadataLazyExtension;
617
618    impl Extension for MetadataLazyExtension {
619        fn info() -> ExtensionInfo {
620            LAZY_METADATA_INFO_CALLS.fetch_add(1, Ordering::SeqCst);
621            ExtensionInfo::default()
622        }
623
624        fn capabilities() -> ExtensionCapabilities {
625            LAZY_METADATA_CAPABILITY_CALLS.fetch_add(1, Ordering::SeqCst);
626            ExtensionCapabilities::default()
627        }
628    }
629
630    #[derive(Default)]
631    struct RecordingBackend;
632
633    impl Extension for RecordingBackend {
634        fn info() -> ExtensionInfo {
635            ExtensionInfo {
636                id: "recording-backend".into(),
637                name: "Recording backend".into(),
638                types: vec![],
639                ..ExtensionInfo::default()
640            }
641        }
642    }
643
644    impl Backend for RecordingBackend {
645        fn generate(&self, request: GenerateRequest) -> Result<GenerateResult> {
646            Ok(GenerateResult {
647                success: true,
648                artifacts: vec![Artifact {
649                    path: "observed.json".into(),
650                    content: request.ir.to_string(),
651                    binary: false,
652                }],
653                diagnostics: vec![],
654            })
655        }
656
657        fn target_languages() -> Vec<String> {
658            vec!["recording".into()]
659        }
660    }
661
662    #[derive(Default)]
663    struct RecordingWorkspace;
664
665    impl Extension for RecordingWorkspace {
666        fn info() -> ExtensionInfo {
667            ExtensionInfo {
668                id: "recording-workspace".into(),
669                name: "Recording workspace".into(),
670                version: "1.0.0".into(),
671                types: vec![],
672                ..ExtensionInfo::default()
673            }
674        }
675
676        fn capabilities() -> ExtensionCapabilities {
677            ExtensionCapabilities {
678                workspace: Some(WorkspaceCapability {
679                    protocol_versions: vec![morphir_workspace::workspace_discovery_protocol()],
680                    discover: true,
681                }),
682                ..ExtensionCapabilities::default()
683            }
684        }
685    }
686
687    impl Workspace for RecordingWorkspace {
688        fn discover(&self, request: DiscoveryRequest) -> Result<DiscoveryResponse> {
689            Ok(morphir_workspace::discover(request))
690        }
691    }
692
693    fn a_workspace_request() -> DiscoveryRequest {
694        DiscoveryRequest {
695            protocol_version: morphir_workspace::workspace_discovery_protocol(),
696            development_root: FileTree {
697                entries: BTreeMap::from([
698                    (RelativePath::root(), FileEntry::Directory),
699                    (
700                        RelativePath::parse("morphir.toml").unwrap(),
701                        FileEntry::File {
702                            text: "[project]\nname = \"acme/orders\"\n".into(),
703                        },
704                    ),
705                ]),
706            },
707            morphir_home: None,
708            system_config: None,
709            environment: BTreeMap::new(),
710            cli_overlay: serde_json::json!({}),
711            purpose: Default::default(),
712        }
713    }
714
715    fn a_generate_request() -> ExtensionRequest {
716        ExtensionRequest::new(
717            methods::GENERATE,
718            GenerateRequest {
719                ir: serde_json::json!({ "observed": true }),
720                target: "recording".into(),
721                options: Default::default(),
722            },
723            7,
724        )
725        .expect("the request fixture should serialize")
726    }
727
728    fn an_initialize_request(protocol_versions: Vec<&str>) -> ExtensionRequest {
729        ExtensionRequest::new(
730            methods::INITIALIZE,
731            protocol::InitializeParams {
732                model_transport: None,
733                protocol_versions: protocol_versions.into_iter().map(str::to_string).collect(),
734                host: protocol::PeerInfo {
735                    kind: Default::default(),
736                    name: "conformance-host".into(),
737                    version: "0.1.0".into(),
738                },
739            },
740            1,
741        )
742        .expect("the initialization fixture should serialize")
743    }
744
745    #[test]
746    fn control_requests_do_not_construct_default_extensions() {
747        LAZY_DEFAULT_CONSTRUCTIONS.store(0, Ordering::SeqCst);
748        let control_requests = [
749            ExtensionRequest::new(methods::PING, serde_json::json!({}), 1).unwrap(),
750            ExtensionRequest::new(methods::INFO, serde_json::json!({}), 2).unwrap(),
751            ExtensionRequest::new(methods::CAPABILITIES, serde_json::json!({}), 3).unwrap(),
752            an_initialize_request(vec![protocol::MEP_VERSION]),
753            ExtensionRequest::new(methods::SHUTDOWN, serde_json::json!({}), 5).unwrap(),
754        ];
755
756        for request in control_requests {
757            let response = __dispatch_request::<LazyDefaultExtension>(&request, &[], &[]);
758            assert!(response.error.is_none());
759        }
760        assert_eq!(LAZY_DEFAULT_CONSTRUCTIONS.load(Ordering::SeqCst), 0);
761
762        let request =
763            ExtensionRequest::new("test.extension.method", serde_json::json!({}), 6).unwrap();
764        let _ = __dispatch_request::<LazyDefaultExtension>(&request, &[], &[]);
765        assert_eq!(LAZY_DEFAULT_CONSTRUCTIONS.load(Ordering::SeqCst), 1);
766    }
767
768    #[test]
769    fn extension_method_dispatch_does_not_refresh_static_metadata() {
770        LAZY_METADATA_INFO_CALLS.store(0, Ordering::SeqCst);
771        LAZY_METADATA_CAPABILITY_CALLS.store(0, Ordering::SeqCst);
772        let request =
773            ExtensionRequest::new("test.extension.method", serde_json::json!({}), 1).unwrap();
774
775        let _ = __dispatch_request::<MetadataLazyExtension>(&request, &[], &[]);
776
777        assert_eq!(LAZY_METADATA_INFO_CALLS.load(Ordering::SeqCst), 0);
778        assert_eq!(LAZY_METADATA_CAPABILITY_CALLS.load(Ordering::SeqCst), 0);
779    }
780
781    #[test]
782    fn backend_requests_reach_the_backend_implementation() {
783        let response = __dispatch_request::<RecordingBackend>(
784            &a_generate_request(),
785            &[__dispatch_backend::<RecordingBackend>],
786            &[ExtensionType::Backend],
787        );
788        let result: GenerateResult = serde_json::from_value(
789            response
790                .result
791                .expect("backend dispatch should return a successful result"),
792        )
793        .expect("backend dispatch should return a GenerateResult");
794
795        assert!(result.success);
796        assert_eq!(result.artifacts.len(), 1);
797        assert_eq!(result.artifacts[0].path, "observed.json");
798        assert_eq!(result.artifacts[0].content, r#"{"observed":true}"#);
799        assert!(result.diagnostics.is_empty());
800    }
801
802    #[test]
803    fn workspace_requests_reach_the_workspace_implementation() {
804        let response = __dispatch_request::<RecordingWorkspace>(
805            &ExtensionRequest::new(methods::WORKSPACE_DISCOVER, a_workspace_request(), 8)
806                .expect("the workspace request should serialize"),
807            &[__dispatch_workspace::<RecordingWorkspace>],
808            &[ExtensionType::Workspace],
809        );
810        let result: DiscoveryResponse = serde_json::from_value(
811            response
812                .result
813                .expect("workspace dispatch should return a discovery response"),
814        )
815        .expect("workspace dispatch should return a typed response");
816
817        let snapshot = result
818            .into_result()
819            .expect("the workspace fixture should discover");
820        assert_eq!(snapshot.projects[0].name, "acme/orders");
821    }
822
823    #[test]
824    fn malformed_workspace_parameters_are_invalid_params() {
825        let request = ExtensionRequest::new(
826            methods::WORKSPACE_DISCOVER,
827            serde_json::json!({ "protocolVersion": "one" }),
828            9,
829        )
830        .expect("the malformed request should still be valid JSON-RPC");
831        let response = __dispatch_request::<RecordingWorkspace>(
832            &request,
833            &[__dispatch_workspace::<RecordingWorkspace>],
834            &[ExtensionType::Workspace],
835        );
836
837        assert_eq!(
838            response
839                .error
840                .expect("workspace parameters should fail")
841                .code,
842            protocol::error_codes::INVALID_PARAMS
843        );
844    }
845
846    #[test]
847    fn initialization_reports_the_workspace_contract() {
848        let response = __dispatch_request::<RecordingWorkspace>(
849            &an_initialize_request(vec!["0.1"]),
850            &[__dispatch_workspace::<RecordingWorkspace>],
851            &[ExtensionType::Workspace],
852        );
853        let result: protocol::InitializeResult =
854            serde_json::from_value(response.result.expect("workspace peers should initialize"))
855                .expect("initialization should return the negotiated session");
856
857        assert_eq!(result.extension.types, vec![ExtensionType::Workspace]);
858        assert_eq!(
859            result.capabilities.workspace,
860            Some(WorkspaceCapability {
861                protocol_versions: vec![morphir_workspace::workspace_discovery_protocol()],
862                discover: true,
863            })
864        );
865    }
866
867    #[test]
868    fn initialization_negotiates_mep_0_1_and_reports_the_extension() {
869        let response = __dispatch_request::<RecordingBackend>(
870            &an_initialize_request(vec!["0.1"]),
871            &[__dispatch_backend::<RecordingBackend>],
872            &[ExtensionType::Backend],
873        );
874        let result: protocol::InitializeResult =
875            serde_json::from_value(response.result.expect("compatible peers should initialize"))
876                .expect("initialization should return the negotiated session");
877
878        assert_eq!(result.protocol_version, protocol::MEP_VERSION);
879        assert_eq!(result.extension.id, "recording-backend");
880        assert_eq!(result.extension.types, vec![ExtensionType::Backend]);
881    }
882
883    #[test]
884    fn initialization_rejects_incompatible_protocol_versions() {
885        let response = __dispatch_request::<RecordingBackend>(
886            &an_initialize_request(vec!["9.0"]),
887            &[__dispatch_backend::<RecordingBackend>],
888            &[ExtensionType::Backend],
889        );
890
891        assert!(response.result.is_none());
892        assert_eq!(
893            response.error.expect("initialization should fail").code,
894            protocol::error_codes::PROTOCOL_VERSION_MISMATCH
895        );
896    }
897
898    #[test]
899    fn malformed_method_parameters_are_invalid_params() {
900        let request = ExtensionRequest::new(methods::GENERATE, serde_json::json!({}), 9)
901            .expect("the malformed request should still be valid JSON-RPC");
902        let response = __dispatch_request::<RecordingBackend>(
903            &request,
904            &[__dispatch_backend::<RecordingBackend>],
905            &[ExtensionType::Backend],
906        );
907
908        assert_eq!(
909            response.error.expect("method parameters should fail").code,
910            protocol::error_codes::INVALID_PARAMS
911        );
912    }
913}