feat: add websocket upstream adapter

crates/crank-core/src/lib.rs

@@ -30,7 +30,8 @@ pub use observability::{
 pub use operation::{
     ConfigExport, ExecutionConfig, GeneratedDraft, GeneratedDraftStatus, GraphqlTarget,
     GrpcProtocolOptions, GrpcTarget, Operation, OperationStatus, ProtocolOptions, RestTarget,
-    RetryPolicy, Samples, Target, ToolDescription, ToolExample,
+    RetryPolicy, Samples, Target, ToolDescription, ToolExample, WebsocketProtocolOptions,
+    WebsocketTarget,
 };
 pub use protocol::{AuthKind, ExportMode, GraphqlOperationType, HttpMethod, Protocol};
 pub use secret::{Secret, SecretKind, SecretStatus, SecretVersion};

crates/crank-core/src/operation.rs

@@ -50,12 +50,26 @@ pub struct GrpcTarget {
     pub descriptor_set_b64: String,
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[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, Serialize, Deserialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]
 pub enum Target {
     Rest(RestTarget),
     Graphql(GraphqlTarget),
     Grpc(GrpcTarget),
+    Websocket(WebsocketTarget),
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
@@ -68,10 +82,22 @@ 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 ProtocolOptions {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub grpc: Option<GrpcProtocolOptions>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub websocket: Option<WebsocketProtocolOptions>,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -209,6 +235,7 @@ mod tests {
         operation::{
             ConfigExport, ExecutionConfig, GraphqlTarget, Operation, OperationStatus,
             ProtocolOptions, RestTarget, Samples, Target, ToolDescription, ToolExample,
+            WebsocketProtocolOptions, WebsocketTarget,
         },
         protocol::{AuthKind, ExportMode, GraphqlOperationType, HttpMethod, Protocol},
     };
@@ -244,6 +271,23 @@ mod tests {
         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 operation_exposes_local_domain_helpers() {
         let operation = Operation {
@@ -269,7 +313,14 @@ mod tests {
                 retry_policy: None,
                 auth_profile_ref: Some(AuthProfileId::new("auth_01")),
                 headers: BTreeMap::new(),
-                protocol_options: Some(ProtocolOptions::default()),
+                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),
+                    }),
+                }),
                 streaming: None,
             },
             tool_description: ToolDescription {

crates/crank-core/src/protocol.rs

@@ -8,6 +8,7 @@ pub enum Protocol {
     Rest,
     Graphql,
     Grpc,
+    Websocket,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -49,6 +50,7 @@ impl Protocol {
             Self::Rest => true,
             Self::Graphql => matches!(mode, ExecutionMode::Unary),
             Self::Grpc => true,
+            Self::Websocket => !matches!(mode, ExecutionMode::Unary),
         }
     }
 
@@ -57,6 +59,7 @@ impl Protocol {
             Self::Rest => true,
             Self::Graphql => matches!(behavior, TransportBehavior::RequestResponse),
             Self::Grpc => !matches!(behavior, TransportBehavior::DeferredResult),
+            Self::Websocket => !matches!(behavior, TransportBehavior::RequestResponse),
         }
     }
 }
@@ -79,4 +82,20 @@ mod tests {
         assert!(Protocol::Grpc.supports_execution_mode(ExecutionMode::Session));
         assert!(!Protocol::Grpc.supports_transport_behavior(TransportBehavior::DeferredResult));
     }
+
+    #[test]
+    fn websocket_requires_streaming_modes() {
+        assert!(!Protocol::Websocket.supports_execution_mode(ExecutionMode::Unary));
+        assert!(Protocol::Websocket.supports_execution_mode(ExecutionMode::Window));
+        assert!(Protocol::Websocket.supports_execution_mode(ExecutionMode::Session));
+        assert!(Protocol::Websocket.supports_execution_mode(ExecutionMode::AsyncJob));
+        assert!(
+            !Protocol::Websocket.supports_transport_behavior(TransportBehavior::RequestResponse)
+        );
+        assert!(Protocol::Websocket.supports_transport_behavior(TransportBehavior::ServerStream));
+        assert!(
+            Protocol::Websocket.supports_transport_behavior(TransportBehavior::StatefulSession)
+        );
+        assert!(Protocol::Websocket.supports_transport_behavior(TransportBehavior::DeferredResult));
+    }
 }