lenso_plugin_sdk/
lib.rs

1//! Execution-target lowering for portable Rust Plugins.
2//!
3//! Product SDKs own Capability semantics and typed authoring. This crate owns
4//! only the final JSON request seam and lowers it to Wasm Component or Process
5//! transport glue. Plugin authors normally use a product SDK instead of this
6//! interface directly.
7
8use serde_json::Value;
9
10pub use lenso_plugin_sdk_macros::plugin;
11
12/// One source-declared Capability dependency of a portable Plugin.
13#[derive(Clone, Copy, Debug, Eq, PartialEq)]
14pub struct Requirement {
15    pub requirement_id: &'static str,
16    pub capability_id: &'static str,
17    pub descriptor_version: &'static str,
18    pub descriptor_digest: &'static str,
19    pub cardinality: Cardinality,
20}
21
22impl Requirement {
23    /// Declares exactly one provider for a typed dependency role.
24    pub const fn one<C: DependencyClient>(requirement_id: &'static str) -> Self {
25        Self::new::<C>(requirement_id, Cardinality::One)
26    }
27
28    /// Declares zero or one provider for a typed dependency role.
29    pub const fn optional<C: DependencyClient>(requirement_id: &'static str) -> Self {
30        Self::new::<C>(requirement_id, Cardinality::Optional)
31    }
32
33    /// Declares any number of providers for a typed dependency role.
34    pub const fn many<C: DependencyClient>(requirement_id: &'static str) -> Self {
35        Self::new::<C>(requirement_id, Cardinality::Many)
36    }
37
38    const fn new<C: DependencyClient>(
39        requirement_id: &'static str,
40        cardinality: Cardinality,
41    ) -> Self {
42        Self {
43            requirement_id,
44            capability_id: C::CAPABILITY_ID,
45            descriptor_version: C::DESCRIPTOR_VERSION,
46            descriptor_digest: C::DESCRIPTOR_DIGEST,
47            cardinality,
48        }
49    }
50}
51
52/// Supported dependency cardinalities.
53#[derive(Clone, Copy, Debug, Eq, PartialEq)]
54pub enum Cardinality {
55    One,
56    Optional,
57    Many,
58}
59
60/// One exact Host-selected provider route.
61#[derive(Clone, Debug, Eq, PartialEq)]
62pub struct Dependency {
63    requirement_id: String,
64    route_id: String,
65    provider_instance: String,
66    capability_id: String,
67    descriptor_version: String,
68    descriptor_digest: String,
69}
70
71impl Dependency {
72    /// Stable consumer-local role declared by the Plugin.
73    pub fn requirement_id(&self) -> &str {
74        &self.requirement_id
75    }
76
77    /// Exact provider instance selected by the immutable Plan.
78    pub fn provider_instance(&self) -> &str {
79        &self.provider_instance
80    }
81
82    /// Converts this exact route into its generated typed client.
83    pub fn client<C: DependencyClient>(self) -> Result<C, String> {
84        if self.capability_id != C::CAPABILITY_ID
85            || self.descriptor_version != C::DESCRIPTOR_VERSION
86            || self.descriptor_digest != C::DESCRIPTOR_DIGEST
87        {
88            return Err(format!(
89                "dependency `{}` does not match generated client `{}`",
90                self.requirement_id,
91                C::CAPABILITY_ID
92            ));
93        }
94        Ok(C::from_dependency(self))
95    }
96}
97
98/// Contract implemented by generated portable Capability clients.
99pub trait DependencyClient: Sized {
100    const CAPABILITY_ID: &'static str;
101    const DESCRIPTOR_VERSION: &'static str;
102    const DESCRIPTOR_DIGEST: &'static str;
103
104    #[doc(hidden)]
105    fn from_dependency(dependency: Dependency) -> Self;
106}
107
108/// Exact dependencies and configuration supplied while constructing a Plugin.
109#[derive(Clone, Debug)]
110pub struct CreateContext {
111    config: Value,
112    dependencies: Dependencies,
113    call: Ctx,
114}
115
116impl CreateContext {
117    /// Resolved configuration for this Plugin instance.
118    pub const fn config(&self) -> &Value {
119        &self.config
120    }
121
122    /// Exact named dependency routes selected by the Plan.
123    pub const fn dependencies(&self) -> &Dependencies {
124        &self.dependencies
125    }
126
127    /// Lifecycle call context. Constructor dependency calls inherit this scope.
128    pub const fn ctx(&self) -> &Ctx {
129        &self.call
130    }
131}
132
133/// Exact dependency routes selected for one Plugin generation.
134#[derive(Clone, Debug, Default)]
135pub struct Dependencies {
136    routes: Vec<Dependency>,
137}
138
139impl Dependencies {
140    /// Resolves exactly one provider for a named dependency role.
141    pub fn one(&self, requirement_id: &str) -> Result<Dependency, String> {
142        let matches = self
143            .routes
144            .iter()
145            .filter(|route| route.requirement_id == requirement_id)
146            .collect::<Vec<_>>();
147        match matches.as_slice() {
148            [route] => Ok((*route).clone()),
149            [] => Err(format!("dependency `{requirement_id}` has no provider")),
150            _ => Err(format!(
151                "dependency `{requirement_id}` has multiple providers"
152            )),
153        }
154    }
155
156    /// Resolves zero or one provider for a named dependency role.
157    pub fn optional(&self, requirement_id: &str) -> Result<Option<Dependency>, String> {
158        let matches = self
159            .routes
160            .iter()
161            .filter(|route| route.requirement_id == requirement_id)
162            .collect::<Vec<_>>();
163        match matches.as_slice() {
164            [] => Ok(None),
165            [route] => Ok(Some((*route).clone())),
166            _ => Err(format!(
167                "dependency `{requirement_id}` has multiple providers"
168            )),
169        }
170    }
171
172    /// Resolves all providers for a named dependency role in Plan order.
173    pub fn many(&self, requirement_id: &str) -> Vec<Dependency> {
174        self.routes
175            .iter()
176            .filter(|route| route.requirement_id == requirement_id)
177            .cloned()
178            .collect()
179    }
180}
181
182/// Domain, Runtime, and value failures from one portable dependency call.
183#[derive(Clone, Debug, PartialEq)]
184pub enum CallError<E> {
185    Domain(E),
186    Runtime(Value),
187    InvalidValue,
188}
189
190/// Current invocation or lifecycle authority supplied by the Runtime.
191#[derive(Clone, Debug)]
192pub struct Ctx {
193    #[cfg(not(target_arch = "wasm32"))]
194    inner: lenso_process_sdk::ProcessCallContext,
195}
196
197impl Ctx {
198    /// Whether cooperative cancellation has been requested.
199    #[must_use]
200    pub fn is_cancelled(&self) -> bool {
201        #[cfg(not(target_arch = "wasm32"))]
202        {
203            self.inner.is_cancelled()
204        }
205        #[cfg(target_arch = "wasm32")]
206        {
207            false
208        }
209    }
210
211    /// Calls one exact dependency route with generated request/response types.
212    #[cfg(not(target_arch = "wasm32"))]
213    pub fn request<Request, Response, DomainError>(
214        &self,
215        dependency: &Dependency,
216        operation: &str,
217        request: &Request,
218    ) -> Result<Response, CallError<DomainError>>
219    where
220        Request: serde::Serialize,
221        Response: serde::de::DeserializeOwned,
222        DomainError: serde::de::DeserializeOwned,
223    {
224        let payload = serde_json::to_value(request).map_err(|_| CallError::InvalidValue)?;
225        match self
226            .inner
227            .call(
228                dependency.requirement_id.clone(),
229                dependency.route_id.clone(),
230                operation,
231                payload,
232            )
233            .map_err(|detail| CallError::Runtime(serde_json::json!({ "detail": detail })))?
234        {
235            lenso_process_sdk::authoring::InvocationOutcome::Success { value } => {
236                serde_json::from_value(value).map_err(|_| CallError::InvalidValue)
237            }
238            lenso_process_sdk::authoring::InvocationOutcome::Domain { error } => {
239                match serde_json::from_value(error) {
240                    Ok(error) => Err(CallError::Domain(error)),
241                    Err(_) => Err(CallError::InvalidValue),
242                }
243            }
244            lenso_process_sdk::authoring::InvocationOutcome::Runtime { failure } => Err(
245                CallError::Runtime(serde_json::to_value(failure).unwrap_or(Value::Null)),
246            ),
247        }
248    }
249}
250
251/// Complete portable Plugin object constructed once per admitted generation.
252pub trait Plugin: Send + Sync + 'static {
253    /// Portable JSON Schema for this Plugin's configuration, when it accepts configuration.
254    const CONFIGURATION_SCHEMA: Option<&'static str> = None;
255
256    /// Source-declared named dependencies required by this object.
257    fn requirements() -> &'static [Requirement] {
258        &[]
259    }
260
261    /// Constructs the complete object. Dependency calls use `context.ctx()`.
262    fn create(context: CreateContext) -> Result<Self, String>
263    where
264        Self: Sized;
265
266    /// Attempts cleanup once after admitted work has drained.
267    fn stop(&self, _context: Ctx) -> Result<(), String> {
268        Ok(())
269    }
270}
271
272impl<T> Plugin for T
273where
274    T: Default + Send + Sync + 'static,
275{
276    fn create(_context: CreateContext) -> Result<Self, String> {
277        Ok(Self::default())
278    }
279}
280
281#[cfg(not(target_arch = "wasm32"))]
282#[doc(hidden)]
283pub fn __process_descriptor(
284    base: &str,
285    requirements: &[Requirement],
286    configuration_schema: Option<&str>,
287) -> String {
288    let mut value: Value = serde_json::from_str(base).expect("generated descriptor is valid JSON");
289    let object = value
290        .as_object_mut()
291        .expect("generated descriptor is a JSON object");
292    if let Some(schema) = configuration_schema {
293        let schema =
294            serde_json::from_str(schema).expect("Plugin configuration schema is valid JSON");
295        object.insert("configuration_schema".to_owned(), schema);
296    }
297    if !requirements.is_empty() {
298        object.insert(
299            "abi".to_owned(),
300            Value::String("lenso.json-host-imports@2".to_owned()),
301        );
302        let mut requirements = requirements
303            .iter()
304            .map(|requirement| {
305                serde_json::json!({
306                    "requirement_id": requirement.requirement_id,
307                    "capability_id": requirement.capability_id,
308                    "descriptor_version": requirement.descriptor_version,
309                    "cardinality": match requirement.cardinality {
310                        Cardinality::One => "one",
311                        Cardinality::Optional => "optional",
312                        Cardinality::Many => "many",
313                    },
314                })
315            })
316            .collect::<Vec<_>>();
317        requirements.sort_by(|left, right| {
318            left["requirement_id"]
319                .as_str()
320                .cmp(&right["requirement_id"].as_str())
321        });
322        object.insert(
323            "required_capabilities".to_owned(),
324            Value::Array(requirements),
325        );
326    }
327    serde_json::to_string(&value).expect("generated descriptor remains valid JSON")
328}
329
330#[cfg(not(target_arch = "wasm32"))]
331#[doc(hidden)]
332pub fn __validate_process_initialization<P: Plugin>(
333    params: &lenso_process_sdk::authoring::InitializeParams,
334) -> Result<(), String> {
335    use lenso_process_sdk::authoring::RequirementCardinality;
336
337    let declared = params
338        .required_declarations
339        .iter()
340        .map(|requirement| {
341            (
342                requirement.requirement_id.as_str(),
343                requirement.capability_id.as_str(),
344                requirement.descriptor_version.as_str(),
345                requirement.descriptor_digest.as_str(),
346                requirement.cardinality,
347            )
348        })
349        .collect::<Vec<_>>();
350    let expected = P::requirements()
351        .iter()
352        .map(|requirement| {
353            (
354                requirement.requirement_id,
355                requirement.capability_id,
356                requirement.descriptor_version,
357                requirement.descriptor_digest,
358                match requirement.cardinality {
359                    Cardinality::One => RequirementCardinality::One,
360                    Cardinality::Optional => RequirementCardinality::Optional,
361                    Cardinality::Many => RequirementCardinality::Many,
362                },
363            )
364        })
365        .collect::<Vec<_>>();
366    if declared == expected {
367        Ok(())
368    } else {
369        Err("Host initialization does not match source-declared dependencies".to_owned())
370    }
371}
372
373#[cfg(not(target_arch = "wasm32"))]
374#[doc(hidden)]
375pub fn __process_create_context(
376    initialization: &lenso_process_sdk::authoring::InitializeParams,
377    call: lenso_process_sdk::ProcessLifecycleContext,
378) -> CreateContext {
379    let routes = initialization
380        .routes
381        .iter()
382        .map(|route| Dependency {
383            requirement_id: route.requirement_id.clone(),
384            route_id: route.route_id.clone(),
385            provider_instance: route.provider_instance.clone(),
386            capability_id: route.capability_id.clone(),
387            descriptor_version: route.descriptor_version.clone(),
388            descriptor_digest: route.descriptor_digest.clone(),
389        })
390        .collect();
391    CreateContext {
392        config: initialization.config.clone(),
393        dependencies: Dependencies { routes },
394        call: Ctx { inner: call },
395    }
396}
397
398#[cfg(not(target_arch = "wasm32"))]
399#[doc(hidden)]
400pub fn __process_ctx(call: lenso_process_sdk::ProcessCallContext) -> Ctx {
401    Ctx { inner: call }
402}
403
404#[cfg(target_arch = "wasm32")]
405#[doc(hidden)]
406pub mod __wasm {
407    wit_bindgen::generate!({
408        inline: r#"
409            package lenso:runtime@1.0.0;
410
411            world plugin {
412              export describe: func() -> string;
413              export invoke: func(capability: string, operation: string, request-json: string) -> result<string, string>;
414            }
415        "#,
416        world: "plugin",
417        export_macro_name: "export_lenso_plugin",
418        pub_export_macro: true,
419        default_bindings_module: "::lenso::__wasm",
420    });
421}
422
423/// Transport-neutral result produced by a product SDK's generated dispatcher.
424#[doc(hidden)]
425#[derive(Clone, Debug)]
426pub enum InvocationOutcome {
427    /// A successful Capability response.
428    Success(Value),
429    /// A domain error defined by the Capability contract.
430    DomainError(Value),
431    /// An adapter-safe implementation failure.
432    Failure(String),
433}
434
435/// JSON request seam implemented by generated product SDK glue.
436///
437/// This interface deliberately has no knowledge of Agent Tools, Ingress,
438/// authentication, or any other product Capability.
439#[doc(hidden)]
440pub trait JsonRequestHandler {
441    /// Handles one validated Capability request.
442    fn invoke(&self, _capability: &str, _operation: &str, _request: Value) -> InvocationOutcome {
443        InvocationOutcome::Failure("this Plugin requires invocation context".to_owned())
444    }
445
446    /// Handles one request with its exact invocation authority.
447    fn invoke_with_context(
448        &self,
449        _context: Ctx,
450        capability: &str,
451        operation: &str,
452        request: Value,
453    ) -> InvocationOutcome {
454        self.invoke(capability, operation, request)
455    }
456}
457
458/// Lowers a generated JSON request handler to Wasm Component or Process.
459///
460/// Product SDK macros call this macro; Plugin business code should not need to.
461#[doc(hidden)]
462#[macro_export]
463macro_rules! __export_json_request_handler {
464    (
465        $plugin:ty {
466            capability_id: $capability_id:literal,
467            descriptor_version: $descriptor_version:literal,
468            descriptor_digest: $descriptor_digest:literal,
469            requests: [$first_request:literal $(, $request:literal)* $(,)?] $(,)?
470        }
471    ) => {
472        type __LensoExportedPlugin = $plugin;
473
474        #[cfg(target_arch = "wasm32")]
475        mod __lenso_wasm_export {
476            struct Component;
477
478            const DESCRIPTOR: &str = $crate::__private::lenso_guest_sdk::__request_plugin_descriptor!(
479                $capability_id,
480                $descriptor_version,
481                $first_request $(, $request)*
482            );
483
484            #[used]
485            #[unsafe(link_section = "lenso.plugin-descriptor.v1")]
486            static DESCRIPTOR_SECTION: [u8; DESCRIPTOR.len()] =
487                $crate::__private::lenso_guest_sdk::__descriptor_bytes(DESCRIPTOR);
488
489            impl $crate::__private::wasm::Guest for Component {
490                fn describe() -> ::std::string::String {
491                    DESCRIPTOR.to_owned()
492                }
493
494                fn invoke(
495                    capability: ::std::string::String,
496                    operation: ::std::string::String,
497                    request_json: ::std::string::String,
498                ) -> ::std::result::Result<::std::string::String, ::std::string::String> {
499                    let request = $crate::__private::serde_json::from_str(&request_json)
500                        .map_err(|_| "\"invalid_arguments\"".to_owned())?;
501                    match <super::__LensoExportedPlugin as $crate::JsonRequestHandler>::invoke(
502                        &<super::__LensoExportedPlugin as ::std::default::Default>::default(),
503                        &capability,
504                        &operation,
505                        request,
506                    ) {
507                        $crate::InvocationOutcome::Success(value) =>
508                            $crate::__private::serde_json::to_string(&value)
509                                .map_err(|error| error.to_string()),
510                        $crate::InvocationOutcome::DomainError(value) =>
511                            ::std::result::Result::Err(
512                                $crate::__private::serde_json::to_string(&value)
513                                    .unwrap_or_else(|_| "\"execution_failed\"".to_owned()),
514                            ),
515                        $crate::InvocationOutcome::Failure(detail) =>
516                            ::std::result::Result::Err(
517                                $crate::__private::serde_json::to_string(&detail)
518                                    .unwrap_or_else(|_| "\"execution_failed\"".to_owned()),
519                            ),
520                    }
521                }
522            }
523
524            $crate::__private::wasm::export_lenso_plugin!(Component);
525        }
526
527        #[cfg(not(target_arch = "wasm32"))]
528        mod __lenso_process_export {
529            #[derive(Default)]
530            struct Component {
531                initialization: ::std::sync::Mutex<::std::option::Option<
532                    $crate::__private::lenso_process_sdk::authoring::InitializeParams,
533                >>,
534            }
535
536            const DESCRIPTOR: &str =
537                $crate::__private::lenso_guest_sdk::__request_plugin_descriptor!(
538                    $capability_id,
539                    $descriptor_version,
540                    digest: $descriptor_digest,
541                    $first_request $(, $request)*
542                );
543
544            impl $crate::__private::lenso_process_sdk::ProcessPluginV2 for Component {
545                type Instance = super::__LensoExportedPlugin;
546
547                fn initialize(
548                    &self,
549                    params: &$crate::__private::lenso_process_sdk::authoring::InitializeParams,
550                ) -> ::std::result::Result<(), ::std::string::String> {
551                    $crate::__validate_process_initialization::<super::__LensoExportedPlugin>(params)?;
552                    let mut initialization = self
553                        .initialization
554                        .lock()
555                        .map_err(|_| "Plugin initialization state was poisoned".to_owned())?;
556                    if initialization.replace(params.clone()).is_some() {
557                        return Err("Plugin initialized more than once".to_owned());
558                    }
559                    Ok(())
560                }
561
562                fn construct(
563                    &self,
564                    _params: &$crate::__private::lenso_process_sdk::authoring::ConstructParams,
565                    context: $crate::__private::lenso_process_sdk::ProcessLifecycleContext,
566                ) -> ::std::result::Result<Self::Instance, ::std::string::String> {
567                    let initialization = self
568                        .initialization
569                        .lock()
570                        .map_err(|_| "Plugin initialization state was poisoned".to_owned())?
571                        .clone()
572                        .ok_or_else(|| "Plugin constructed before initialization".to_owned())?;
573                    <super::__LensoExportedPlugin as $crate::Plugin>::create(
574                        $crate::__process_create_context(&initialization, context),
575                    )
576                }
577
578                fn invoke(
579                    &self,
580                    instance: &Self::Instance,
581                    params: $crate::__private::lenso_process_sdk::authoring::InvokeParams,
582                    context: $crate::__private::lenso_process_sdk::ProcessInvocationContext,
583                ) -> $crate::__private::lenso_process_sdk::authoring::InvocationOutcome {
584                    match <super::__LensoExportedPlugin as $crate::JsonRequestHandler>::invoke_with_context(
585                        instance,
586                        $crate::__process_ctx(context),
587                        &params.capability_id,
588                        &params.operation,
589                        params.payload,
590                    ) {
591                        $crate::InvocationOutcome::Success(value) =>
592                            $crate::__private::lenso_process_sdk::authoring::InvocationOutcome::Success {
593                                value,
594                            },
595                        $crate::InvocationOutcome::DomainError(value) =>
596                            $crate::__private::lenso_process_sdk::authoring::InvocationOutcome::Domain {
597                                error: value,
598                            },
599                        $crate::InvocationOutcome::Failure(detail) =>
600                            $crate::__private::lenso_process_sdk::authoring::InvocationOutcome::Runtime {
601                                failure: $crate::__private::lenso_process_sdk::authoring::RuntimeFailure::PluginFailure {
602                                    detail,
603                                },
604                            },
605                    }
606                }
607
608                fn stop(
609                    &self,
610                    instance: &Self::Instance,
611                    _params: &$crate::__private::lenso_process_sdk::authoring::StopParams,
612                    context: $crate::__private::lenso_process_sdk::ProcessLifecycleContext,
613                ) -> $crate::__private::lenso_process_sdk::ProcessStopOutcome {
614                    match <super::__LensoExportedPlugin as $crate::Plugin>::stop(
615                        instance,
616                        $crate::__process_ctx(context),
617                    ) {
618                        Ok(()) => $crate::__private::lenso_process_sdk::ProcessStopOutcome::Completed,
619                        Err(detail) => $crate::__private::lenso_process_sdk::ProcessStopOutcome::Failed(detail),
620                    }
621                }
622            }
623
624            pub fn serve() {
625                if ::std::env::args_os().nth(1).as_deref()
626                    == Some(::std::ffi::OsStr::new("--lenso-describe"))
627                {
628                    println!(
629                        "{}",
630                        $crate::__process_descriptor(
631                            DESCRIPTOR,
632                            <super::__LensoExportedPlugin as $crate::Plugin>::requirements(),
633                            <super::__LensoExportedPlugin as $crate::Plugin>::CONFIGURATION_SCHEMA,
634                        ),
635                    );
636                    return;
637                }
638                $crate::__private::lenso_process_sdk::serve_v2(Component::default())
639                .expect("serve Lenso Process V2 Plugin");
640            }
641        }
642
643        #[cfg(not(target_arch = "wasm32"))]
644        fn main() {
645            __lenso_process_export::serve();
646        }
647    };
648}
649
650#[doc(hidden)]
651pub mod __private {
652    pub use serde_json;
653
654    #[cfg(target_arch = "wasm32")]
655    pub use crate::__wasm as wasm;
656    pub use lenso_guest_sdk;
657    #[cfg(not(target_arch = "wasm32"))]
658    pub use lenso_process_sdk;
659}
660
661#[cfg(all(test, not(target_arch = "wasm32")))]
662mod tests {
663    use super::*;
664    use lenso_process_sdk::authoring::{
665        AuthoringLimits, InitializeParams, ProvidedEndpoint, RequirementCardinality,
666        RequirementDeclaration, RouteDescriptor, SessionIdentity,
667    };
668
669    const STORE_DIGEST: &str =
670        "sha256:1111111111111111111111111111111111111111111111111111111111111111";
671    const REQUIREMENTS: &[Requirement] = &[
672        Requirement {
673            requirement_id: "destination",
674            capability_id: "example.store@1",
675            descriptor_version: "1.0.0",
676            descriptor_digest: STORE_DIGEST,
677            cardinality: Cardinality::One,
678        },
679        Requirement {
680            requirement_id: "source",
681            capability_id: "example.store@1",
682            descriptor_version: "1.0.0",
683            descriptor_digest: STORE_DIGEST,
684            cardinality: Cardinality::One,
685        },
686    ];
687
688    struct Stateful;
689
690    impl Plugin for Stateful {
691        fn requirements() -> &'static [Requirement] {
692            REQUIREMENTS
693        }
694
695        fn create(_context: CreateContext) -> Result<Self, String> {
696            Ok(Self)
697        }
698    }
699
700    fn initialization() -> InitializeParams {
701        InitializeParams {
702            api_version: 2,
703            identity: SessionIdentity {
704                session: "session-1".to_owned(),
705                plugin_instance: "sync".to_owned(),
706                plugin_generation: "generation-1".to_owned(),
707                artifact_digest: STORE_DIGEST.to_owned(),
708                contract_digest: STORE_DIGEST.to_owned(),
709                runtime_profile: "lenso.process-stdio@2".to_owned(),
710                value_profile: "lenso-json-value-v1".to_owned(),
711            },
712            config: serde_json::json!({ "prefix": "copied" }),
713            required_declarations: REQUIREMENTS
714                .iter()
715                .map(|requirement| RequirementDeclaration {
716                    requirement_id: requirement.requirement_id.to_owned(),
717                    capability_id: requirement.capability_id.to_owned(),
718                    descriptor_version: requirement.descriptor_version.to_owned(),
719                    descriptor_digest: requirement.descriptor_digest.to_owned(),
720                    cardinality: RequirementCardinality::One,
721                })
722                .collect(),
723            routes: REQUIREMENTS
724                .iter()
725                .enumerate()
726                .map(|(index, requirement)| RouteDescriptor {
727                    route_id: format!("route-{index}"),
728                    requirement_id: requirement.requirement_id.to_owned(),
729                    capability_id: requirement.capability_id.to_owned(),
730                    descriptor_version: requirement.descriptor_version.to_owned(),
731                    descriptor_digest: requirement.descriptor_digest.to_owned(),
732                    provider_instance: format!("store-{index}"),
733                    provider_order: 0,
734                })
735                .collect(),
736            provided_endpoints: vec![ProvidedEndpoint {
737                endpoint_id: "sync".to_owned(),
738                capability_id: "example.sync@1".to_owned(),
739                descriptor_version: "1.0.0".to_owned(),
740                descriptor_digest: STORE_DIGEST.to_owned(),
741            }],
742            limits: AuthoringLimits::defaults(),
743        }
744    }
745
746    #[test]
747    fn process_descriptor_contains_sorted_named_requirements() {
748        let base = r#"{"abi":"lenso.json-request@1","capabilities":[{"capability_id":"example.sync@1","descriptor_version":"1.0.0","request_operations":["sync"]}]}"#;
749        let descriptor: Value = serde_json::from_str(&__process_descriptor(
750            base,
751            REQUIREMENTS,
752            Some(r#"{"type":"object","required":["prefix"]}"#),
753        ))
754        .unwrap();
755        assert_eq!(descriptor["abi"], "lenso.json-host-imports@2");
756        assert_eq!(
757            descriptor["required_capabilities"][0]["requirement_id"],
758            "destination"
759        );
760        assert_eq!(
761            descriptor["required_capabilities"][1]["requirement_id"],
762            "source"
763        );
764        assert_eq!(descriptor["configuration_schema"]["type"], "object");
765    }
766
767    #[test]
768    fn process_initialization_must_match_source_declarations_exactly() {
769        let initialization = initialization();
770        assert!(__validate_process_initialization::<Stateful>(&initialization).is_ok());
771
772        let mut drifted = initialization;
773        drifted.required_declarations[0].descriptor_digest = STORE_DIGEST.replace('1', "2");
774        assert_eq!(
775            __validate_process_initialization::<Stateful>(&drifted).unwrap_err(),
776            "Host initialization does not match source-declared dependencies"
777        );
778    }
779}
lenso_plugin_sdk/lib.rs

lenso_plugin_sdk/
lib.rs
