chore: publish clean community baseline

2026-06-17 06:15:46 +00:00
commit ae09eeba30
318 changed files with 73473 additions and 0 deletions
@@ -0,0 +1,600 @@
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use time::OffsetDateTime;
+
+use crate::{
+    edition::OperationSecurityLevel,
+    ids::{AuthProfileId, DescriptorId, OperationId, SampleId},
+    protocol::{ExportMode, GraphqlOperationType, HttpMethod, Protocol},
+    soap::{
+        SoapBindingStyle, SoapFaultContract, SoapHeaderConfig, SoapOperationMetadata, SoapVersion,
+    },
+    streaming::StreamingConfig,
+};
+
+fn default_operation_category() -> String {
+    "general".to_owned()
+}
+
+fn default_operation_security_level() -> OperationSecurityLevel {
+    OperationSecurityLevel::Standard
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum OperationStatus {
+    Draft,
+    Testing,
+    Published,
+    Archived,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RestTarget {
+    pub base_url: String,
+    pub method: HttpMethod,
+    pub path_template: String,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub static_headers: BTreeMap<String, String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GraphqlTarget {
+    pub endpoint: String,
+    pub operation_type: GraphqlOperationType,
+    pub operation_name: String,
+    pub query_template: String,
+    pub response_path: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GrpcTarget {
+    pub server_addr: String,
+    pub package: String,
+    pub service: String,
+    pub method: String,
+    #[serde(default)]
+    pub read_only: bool,
+    pub descriptor_ref: DescriptorId,
+    pub descriptor_set_b64: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct WebsocketTarget {
+    pub url: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub subprotocols: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub subscribe_message_template: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub unsubscribe_message_template: Option<Value>,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub static_headers: BTreeMap<String, String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SoapTarget {
+    pub wsdl_ref: SampleId,
+    pub service_name: String,
+    pub port_name: String,
+    pub operation_name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub endpoint_override: Option<String>,
+    pub soap_version: SoapVersion,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub soap_action: Option<String>,
+    pub binding_style: SoapBindingStyle,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub headers: Vec<SoapHeaderConfig>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fault_contract: Option<SoapFaultContract>,
+    #[serde(default)]
+    pub metadata: SoapOperationMetadata,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum Target {
+    Rest(RestTarget),
+    Graphql(GraphqlTarget),
+    Grpc(GrpcTarget),
+    Websocket(WebsocketTarget),
+    Soap(SoapTarget),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct RetryPolicy {
+    pub max_attempts: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ResponseCachePolicy {
+    pub ttl_ms: u64,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct GrpcProtocolOptions {
+    pub use_tls: bool,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct WebsocketProtocolOptions {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub heartbeat_interval_ms: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reconnect_max_attempts: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reconnect_backoff_ms: Option<u64>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct SoapProtocolOptions {
+    #[serde(default)]
+    pub use_tls: bool,
+    #[serde(default)]
+    pub validate_certificate: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ws_security_profile: Option<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct ProtocolOptions {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub grpc: Option<GrpcProtocolOptions>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub websocket: Option<WebsocketProtocolOptions>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub soap: Option<SoapProtocolOptions>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct ExecutionConfig {
+    pub timeout_ms: u64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub retry_policy: Option<RetryPolicy>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_cache: Option<ResponseCachePolicy>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub auth_profile_ref: Option<AuthProfileId>,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub headers: BTreeMap<String, String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub protocol_options: Option<ProtocolOptions>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub streaming: Option<StreamingConfig>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ToolExample {
+    pub input: Value,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ToolDescription {
+    pub title: String,
+    pub description: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tags: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub examples: Vec<ToolExample>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct Samples {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub input_json_sample_ref: Option<SampleId>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub output_json_sample_ref: Option<SampleId>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub proto_file_ref: Option<SampleId>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub descriptor_ref: Option<DescriptorId>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum GeneratedDraftStatus {
+    None,
+    Available,
+    Stale,
+    Failed,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct GeneratedDraft {
+    pub status: GeneratedDraftStatus,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub source_types: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub generated_at: Option<String>,
+    pub input_schema_generated: bool,
+    pub output_schema_generated: bool,
+    pub input_mapping_generated: bool,
+    pub output_mapping_generated: bool,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub warnings: Vec<String>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ConfigExport {
+    pub format_version: String,
+    pub export_mode: ExportMode,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub struct WizardState {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub input_sample: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub output_sample: Option<Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub test_input: Option<Value>,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Operation<TSchema, TMapping> {
+    pub id: OperationId,
+    pub name: String,
+    pub display_name: String,
+    #[serde(default = "default_operation_category")]
+    pub category: String,
+    pub protocol: Protocol,
+    #[serde(default = "default_operation_security_level")]
+    pub security_level: OperationSecurityLevel,
+    pub status: OperationStatus,
+    pub version: u32,
+    pub target: Target,
+    pub input_schema: TSchema,
+    pub output_schema: TSchema,
+    pub input_mapping: TMapping,
+    pub output_mapping: TMapping,
+    pub execution_config: ExecutionConfig,
+    pub tool_description: ToolDescription,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub samples: Option<Samples>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub generated_draft: Option<GeneratedDraft>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub config_export: Option<ConfigExport>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub wizard_state: Option<WizardState>,
+    #[serde(with = "time::serde::rfc3339")]
+    pub created_at: OffsetDateTime,
+    #[serde(with = "time::serde::rfc3339")]
+    pub updated_at: OffsetDateTime,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    #[serde(with = "time::serde::rfc3339::option")]
+    pub published_at: Option<OffsetDateTime>,
+}
+
+impl<TSchema, TMapping> Operation<TSchema, TMapping> {
+    pub fn tool_name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn is_draft(&self) -> bool {
+        self.status == OperationStatus::Draft
+    }
+
+    pub fn is_published(&self) -> bool {
+        self.status == OperationStatus::Published
+    }
+
+    pub fn protocol(&self) -> Protocol {
+        self.protocol
+    }
+
+    pub fn auth_profile_ref(&self) -> Option<&AuthProfileId> {
+        self.execution_config.auth_profile_ref.as_ref()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+
+    use serde_json::json;
+    use time::{OffsetDateTime, format_description::well_known::Rfc3339};
+
+    use crate::{
+        auth::{AuthConfig, AuthProfile, BearerAuthConfig},
+        edition::OperationSecurityLevel,
+        ids::{AuthProfileId, OperationId, SampleId},
+        operation::{
+            ConfigExport, ExecutionConfig, GraphqlTarget, Operation, OperationStatus,
+            ProtocolOptions, RestTarget, Samples, SoapProtocolOptions, SoapTarget, Target,
+            ToolDescription, ToolExample, WebsocketProtocolOptions, WebsocketTarget,
+        },
+        protocol::{AuthKind, ExportMode, GraphqlOperationType, HttpMethod, Protocol},
+        soap::{
+            SoapBindingStyle, SoapFaultContract, SoapHeaderConfig, SoapOperationMetadata,
+            SoapVersion,
+        },
+    };
+
+    fn timestamp(value: &str) -> OffsetDateTime {
+        OffsetDateTime::parse(value, &Rfc3339).unwrap()
+    }
+
+    #[test]
+    fn rest_target_serializes_with_kind_tag() {
+        let target = Target::Rest(RestTarget {
+            base_url: "https://api.example.com".to_owned(),
+            method: HttpMethod::Post,
+            path_template: "/v1/leads".to_owned(),
+            static_headers: BTreeMap::new(),
+        });
+
+        let value = serde_json::to_value(target).unwrap();
+
+        assert_eq!(value["kind"], "rest");
+        assert_eq!(value["method"], "POST");
+    }
+
+    #[test]
+    fn graphql_target_serializes_response_path() {
+        let target = Target::Graphql(GraphqlTarget {
+            endpoint: "https://api.example.com/graphql".to_owned(),
+            operation_type: GraphqlOperationType::Mutation,
+            operation_name: "CreateLead".to_owned(),
+            query_template: "mutation {}".to_owned(),
+            response_path: "$.response.body.data.createLead".to_owned(),
+        });
+
+        let value = serde_json::to_value(target).unwrap();
+
+        assert_eq!(value["kind"], "graphql");
+        assert_eq!(value["operation_type"], "mutation");
+    }
+
+    #[test]
+    fn websocket_target_serializes_templates() {
+        let target = Target::Websocket(WebsocketTarget {
+            url: "wss://events.example.com/stream".to_owned(),
+            subprotocols: vec!["graphql-transport-ws".to_owned()],
+            subscribe_message_template: Some(json!({ "type": "subscribe" })),
+            unsubscribe_message_template: Some(json!({ "type": "unsubscribe" })),
+            static_headers: BTreeMap::from([("x-env".to_owned(), "test".to_owned())]),
+        });
+
+        let value = serde_json::to_value(target).unwrap();
+
+        assert_eq!(value["kind"], "websocket");
+        assert_eq!(value["subprotocols"][0], "graphql-transport-ws");
+        assert_eq!(value["subscribe_message_template"]["type"], "subscribe");
+    }
+
+    #[test]
+    fn soap_target_serializes_binding_metadata() {
+        let target = Target::Soap(SoapTarget {
+            wsdl_ref: SampleId::new("sample_wsdl_01"),
+            service_name: "LeadService".to_owned(),
+            port_name: "LeadPort".to_owned(),
+            operation_name: "CreateLead".to_owned(),
+            endpoint_override: Some("https://soap.example.com/lead".to_owned()),
+            soap_version: SoapVersion::Soap12,
+            soap_action: Some("urn:createLead".to_owned()),
+            binding_style: SoapBindingStyle::DocumentLiteral,
+            headers: vec![SoapHeaderConfig {
+                name: "CorrelationId".to_owned(),
+                namespace_uri: Some("urn:crm".to_owned()),
+                required: true,
+                value_path: Some("$.mcp.correlation_id".to_owned()),
+            }],
+            fault_contract: Some(SoapFaultContract {
+                code_path: Some("$.Envelope.Body.Fault.Code.Value".to_owned()),
+                message_path: Some("$.Envelope.Body.Fault.Reason.Text".to_owned()),
+                detail_path: Some("$.Envelope.Body.Fault.Detail".to_owned()),
+            }),
+            metadata: SoapOperationMetadata {
+                input_part_names: vec!["LeadRequest".to_owned()],
+                output_part_names: vec!["LeadResponse".to_owned()],
+                namespaces: vec!["urn:crm".to_owned()],
+            },
+        });
+
+        let value = serde_json::to_value(target).unwrap();
+
+        assert_eq!(value["kind"], "soap");
+        assert_eq!(value["soap_version"], "soap_12");
+        assert_eq!(value["binding_style"], "document_literal");
+        assert_eq!(value["metadata"]["input_part_names"][0], "LeadRequest");
+    }
+
+    #[test]
+    fn operation_exposes_local_domain_helpers() {
+        let operation = Operation {
+            id: OperationId::new("op_01"),
+            name: "crm_create_lead".to_owned(),
+            display_name: "Create Lead".to_owned(),
+            category: "sales".to_owned(),
+            protocol: Protocol::Rest,
+            security_level: OperationSecurityLevel::Standard,
+            status: OperationStatus::Draft,
+            version: 1,
+            target: Target::Rest(RestTarget {
+                base_url: "https://api.example.com".to_owned(),
+                method: HttpMethod::Post,
+                path_template: "/v1/leads".to_owned(),
+                static_headers: BTreeMap::new(),
+            }),
+            input_schema: json!({"type":"object"}),
+            output_schema: json!({"type":"object"}),
+            input_mapping: json!({"rules":[]}),
+            output_mapping: json!({"rules":[]}),
+            execution_config: ExecutionConfig {
+                timeout_ms: 10_000,
+                retry_policy: None,
+                response_cache: None,
+                auth_profile_ref: Some(AuthProfileId::new("auth_01")),
+                headers: BTreeMap::new(),
+                protocol_options: Some(ProtocolOptions {
+                    grpc: None,
+                    websocket: Some(WebsocketProtocolOptions {
+                        heartbeat_interval_ms: Some(5_000),
+                        reconnect_max_attempts: Some(3),
+                        reconnect_backoff_ms: Some(250),
+                    }),
+                    soap: Some(SoapProtocolOptions {
+                        use_tls: true,
+                        validate_certificate: true,
+                        ws_security_profile: Some("username_token".to_owned()),
+                    }),
+                }),
+                streaming: None,
+            },
+            tool_description: ToolDescription {
+                title: "Create CRM lead".to_owned(),
+                description: "Creates a new lead.".to_owned(),
+                tags: Vec::new(),
+                examples: Vec::new(),
+            },
+            samples: Some(Samples::default()),
+            generated_draft: None,
+            config_export: None,
+            wizard_state: None,
+            created_at: timestamp("2026-03-25T08:00:00Z"),
+            updated_at: timestamp("2026-03-25T08:00:00Z"),
+            published_at: None,
+        };
+
+        assert_eq!(operation.tool_name(), "crm_create_lead");
+        assert!(operation.is_draft());
+        assert!(!operation.is_published());
+        assert_eq!(operation.protocol(), Protocol::Rest);
+        assert_eq!(
+            operation.auth_profile_ref().map(|value| value.as_str()),
+            Some("auth_01")
+        );
+    }
+
+    #[test]
+    fn auth_profile_serializes_secret_ids_without_secret_values() {
+        let profile = AuthProfile {
+            id: AuthProfileId::new("auth_01"),
+            workspace_id: crate::ids::WorkspaceId::new("ws_01"),
+            name: "crm-prod-bearer".to_owned(),
+            kind: AuthKind::Bearer,
+            config: AuthConfig::Bearer(BearerAuthConfig {
+                header_name: "Authorization".to_owned(),
+                secret_id: crate::ids::SecretId::new("secret_crm_prod_token"),
+            }),
+            created_at: timestamp("2026-03-25T08:00:00Z"),
+            updated_at: timestamp("2026-03-25T08:00:00Z"),
+        };
+
+        let value = serde_json::to_value(profile).unwrap();
+
+        assert_eq!(value["kind"], "bearer");
+        assert_eq!(
+            value["config"]["bearer"]["secret_id"],
+            "secret_crm_prod_token"
+        );
+    }
+
+    #[test]
+    fn operation_roundtrips_through_yaml() {
+        let operation = Operation {
+            id: OperationId::new("op_01"),
+            name: "crm_create_lead".to_owned(),
+            display_name: "Create Lead".to_owned(),
+            category: "sales".to_owned(),
+            protocol: Protocol::Rest,
+            security_level: OperationSecurityLevel::Standard,
+            status: OperationStatus::Published,
+            version: 3,
+            target: Target::Rest(RestTarget {
+                base_url: "https://api.example.com".to_owned(),
+                method: HttpMethod::Post,
+                path_template: "/v1/leads".to_owned(),
+                static_headers: BTreeMap::from([("X-App-Source".to_owned(), "crank".to_owned())]),
+            }),
+            input_schema: json!({"type":"object","fields":{"email":{"type":"string","required":true}}}),
+            output_schema: json!({"type":"object","fields":{"id":{"type":"string","required":true}}}),
+            input_mapping: json!({"rules":[{"source":"$.mcp.email","target":"$.request.body.email"}]}),
+            output_mapping: json!({"rules":[{"source":"$.response.body.id","target":"$.output.id"}]}),
+            execution_config: ExecutionConfig {
+                timeout_ms: 10_000,
+                retry_policy: None,
+                response_cache: None,
+                auth_profile_ref: Some(AuthProfileId::new("auth_01")),
+                headers: BTreeMap::new(),
+                protocol_options: Some(ProtocolOptions::default()),
+                streaming: None,
+            },
+            tool_description: ToolDescription {
+                title: "Create CRM lead".to_owned(),
+                description: "Creates a new lead.".to_owned(),
+                tags: vec!["crm".to_owned()],
+                examples: vec![ToolExample {
+                    input: json!({"email":"user@example.com"}),
+                }],
+            },
+            samples: Some(Samples::default()),
+            generated_draft: None,
+            config_export: Some(ConfigExport {
+                format_version: "1".to_owned(),
+                export_mode: ExportMode::Portable,
+            }),
+            wizard_state: None,
+            created_at: timestamp("2026-03-25T08:00:00Z"),
+            updated_at: timestamp("2026-03-25T08:10:00Z"),
+            published_at: Some(timestamp("2026-03-25T08:15:00Z")),
+        };
+
+        let yaml = serde_yaml::to_string(&operation).unwrap();
+        let restored: Operation<serde_json::Value, serde_json::Value> =
+            serde_yaml::from_str(&yaml).unwrap();
+
+        assert!(yaml.contains("protocol: rest"));
+        assert!(yaml.contains("security_level: standard"));
+        assert!(yaml.contains("export_mode: portable"));
+        assert_eq!(restored, operation);
+    }
+
+    #[test]
+    fn operation_yaml_deserializes_without_optional_published_at() {
+        let yaml = r#"
+id: op_01
+name: crm_create_lead
+display_name: Create Lead
+category: sales
+protocol: rest
+security_level: standard
+status: draft
+version: 1
+target:
+  kind: rest
+  base_url: https://api.example.com
+  method: POST
+  path_template: /v1/leads
+  static_headers: {}
+input_schema:
+  type: object
+output_schema:
+  type: object
+input_mapping:
+  rules: []
+output_mapping:
+  rules: []
+execution_config:
+  timeout_ms: 10000
+  headers: {}
+tool_description:
+  title: Create CRM lead
+  description: Creates a new lead.
+  tags: []
+  examples: []
+created_at: 2026-03-25T08:00:00Z
+updated_at: 2026-03-25T08:10:00Z
+"#;
+
+        let restored: Operation<serde_json::Value, serde_json::Value> =
+            serde_yaml::from_str(yaml).unwrap();
+
+        assert_eq!(restored.security_level, OperationSecurityLevel::Standard);
+        assert_eq!(restored.published_at, None);
+    }
+}