@apollo-deploy/tesseract 0.9.1 → 1.2.0

package/templates/ruby/types.hbs

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module {{pascalCase meta.clientName}}
+{{#each schemas}}
+{{#if isEnum}}
+  # {{#if description}}{{description}}{{else}}Enum for {{name}} values.{{/if}}
+  module {{pascalCase name}}
+    {{#each enumValues}}
+    {{#if (isString this)}}
+    {{upperCase (snakeCase this)}} = "{{this}}"
+    {{else}}
+    {{upperCase name}}_{{this}} = {{this}}
+    {{/if}}
+    {{/each}}
+
+    # All valid enum values.
+    # @return [Array]
+    ALL = [
+      {{#each enumValues}}
+      {{#if (isString this)}}
+      {{upperCase (snakeCase this)}},
+      {{else}}
+      {{upperCase ../name}}_{{this}},
+      {{/if}}
+      {{/each}}
+    ].freeze
+
+    # Check if a value is valid for this enum.
+    # @param value [String, Integer]
+    # @return [Boolean]
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+  end
+
+{{else if isTypeAlias}}
+  {{#if unionMembers}}
+  # {{pascalCase name}} — type alias for: {{#each unionMembers}}{{this}}{{#unless @last}} | {{/unless}}{{/each}}
+  {{pascalCase name}} = Class.new
+  {{else}}
+  # {{pascalCase name}} — schema type alias
+  {{pascalCase name}} = Class.new
+  {{/if}}
+
+{{else if isUnionType}}
+  # {{pascalCase name}} — union type: {{#each unionMembers}}{{this}}{{#unless @last}} | {{/unless}}{{/each}}
+  module {{pascalCase name}}
+    # Union members are typed schemas. Use `is_a?` or pattern matching at runtime.
+    {{#each unionMembers}}
+    # @see {{this}}
+    {{/each}}
+  end
+
+{{else}}
+  {{#if (and properties.length (not isUnionType))}}
+  # {{#if description}}{{description}}{{else}}Schema type: {{name}}{{/if}}
+  class {{pascalCase name}}
+    {{#each properties}}
+    # @return [{{type}}{{#if nullable}}, nil{{/if}}]{{#if description}} {{description}}{{/if}}
+    attr_accessor :{{snakeCase name}}
+    {{/each}}
+
+    # @param {{#each properties}}{{snakeCase name}} [{{type}}{{#if nullable}}, nil{{/if}}]{{#unless @last}}, {{/unless}}{{/each}}
+    def initialize({{#each properties}}{{snakeCase name}}: {{^required}}nil{{/required}}{{#unless @last}}, {{/unless}}{{/each}})
+      {{#each properties}}
+      @{{snakeCase name}} = {{snakeCase name}}
+      {{/each}}
+    end
+
+    # @return [Hash] a hash representation of this object
+    def to_h
+      {
+        {{#each properties}}
+        {{#if (eq type "DateTime")}}
+        {{snakeCase name}}: @{{snakeCase name}}&.iso8601,
+        {{else}}
+        {{snakeCase name}}: @{{snakeCase name}},
+        {{/if}}
+        {{/each}}
+      }.compact
+    end
+
+    # Create an instance from a parsed JSON hash.
+    # @param attributes [Hash]
+    # @return [{{pascalCase name}}]
+    def self.from_json(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      new(
+        {{#each properties}}
+        {{snakeCase name}}: attributes["{{snakeCase name}}"] || attributes["{{originalName}}"] || attributes[:{{snakeCase name}}],
+        {{/each}}
+      )
+    end
+  end
+
+  {{else}}
+  # {{#if description}}{{description}}{{else}}Schema type without properties: {{name}}{{/if}}
+  class {{pascalCase name}}
+    # @return [Hash] raw attributes
+    attr_reader :attributes
+
+    # @param attributes [Hash]
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
+    # @return [Hash]
+    def to_h
+      @attributes.dup
+    end
+
+    # Create an instance from a parsed JSON hash.
+    # @param attributes [Hash]
+    # @return [{{pascalCase name}}]
+    def self.from_json(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      new(attributes)
+    end
+  end
+
+  {{/if}}
+{{/if}}
+{{/each}}
+end

package/templates/ruby/version.hbs

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module {{pascalCase snakeModule}}
+  VERSION = "{{#if meta.packageVersion}}{{meta.packageVersion}}{{else}}{{meta.version}}{{/if}}"
+end

package/templates/rust/api-mod.hbs

@@ -0,0 +1,3 @@
+{{#each groups}}
+pub mod {{snakeCase fileName}};
+{{/each}}

package/templates/rust/cargo.hbs

@@ -0,0 +1,22 @@
+[package]
+name = "{{crateName}}"
+version = "{{#if packageVersion}}{{packageVersion}}{{else}}0.1.0{{/if}}"
+edition = "2021"
+description = "{{#if description}}{{description}}{{else}}Rust SDK for {{title}}{{/if}}"
+license = "MIT"
+repository = "https://github.com/{{#if packageName}}{{packageName}}{{else}}example/{{crateName}}{{/if}}"
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
+tokio = { version = "1", features = ["full"] }
+thiserror = "2"
+url = "2"
+{{#if hasSSE}}
+futures-core = "0.3"
+tokio-stream = "0.1"
+{{/if}}
+
+[dev-dependencies]
+tokio-test = "0.4"

package/templates/rust/client.hbs

@@ -0,0 +1,114 @@
+use crate::transport::{Transport, TransportConfig};
+{{#each groups}}
+use crate::api::{{snakeCase fileName}}::{{interfaceName}};
+{{/each}}
+use std::time::Duration;
+
+/// Configuration for the {{title}} API client.
+#[derive(Debug, Clone)]
+pub struct ClientConfig {
+    /// Base URL for the API.
+    pub base_url: String,
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+    /// API key for the `{{name}}` security scheme.
+    pub {{snakeCase configKey}}: Option<String>,
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+    /// Bearer token for the `{{name}}` security scheme.
+    pub {{snakeCase configKey}}: Option<String>,
+{{/if}}
+{{#if (eq type "oauth2")}}
+    /// OAuth2 access token for the `{{name}}` security scheme.
+    pub {{snakeCase configKey}}: Option<String>,
+{{/if}}
+{{#if (eq type "openIdConnect")}}
+    /// OpenID Connect access token for the `{{name}}` security scheme.
+    pub {{snakeCase configKey}}: Option<String>,
+{{/if}}
+{{/each}}
+    /// Request timeout.
+    pub timeout: Duration,
+    /// Maximum number of retry attempts.
+    pub max_retries: u32,
+}
+
+impl Default for ClientConfig {
+    fn default() -> Self {
+        Self {
+            base_url: "{{baseUrl}}".to_string(),
+{{#each securitySchemes}}
+            {{snakeCase configKey}}: None,
+{{/each}}
+            timeout: Duration::from_secs(15),
+            max_retries: 3,
+        }
+    }
+}
+
+/// Primary API client for {{title}}.
+///
+/// Provides access to all domain-specific API groups.
+pub struct Client {
+    transport: Transport,
+{{#each groups}}
+    /// {{#if description}}{{description}}{{else}}{{interfaceName}} operations.{{/if}}
+    pub {{snakeCase name}}: {{interfaceName}},
+{{/each}}
+}
+
+impl Client {
+    /// Create a new {{title}} API client with the given configuration.
+    ///
+    /// # Example
+    ///
+    /// ```rust,no_run
+    /// use {{crateName}}::Client;
+    /// use {{crateName}}::ClientConfig;
+    ///
+    /// let config = ClientConfig {
+{{#each securitySchemes}}
+{{#if (or (eq type "apiKey") (and (eq type "http") (eq scheme "bearer")))}}
+    ///     {{snakeCase configKey}}: Some("your-key".to_string()),
+{{/if}}
+{{/each}}
+    ///     ..Default::default()
+    /// };
+    /// let client = Client::new(config);
+    /// ```
+    pub fn new(config: ClientConfig) -> Self {
+        let mut transport_config = TransportConfig {
+            base_url: config.base_url,
+{{#each securitySchemes}}
+            {{snakeCase configKey}}: config.{{snakeCase configKey}},
+{{/each}}
+            timeout: config.timeout,
+            max_retries: config.max_retries,
+        };
+
+        let transport = Transport::new(transport_config);
+
+        Self {
+{{#each groups}}
+            {{snakeCase name}}: {{interfaceName}}::new(transport.clone()),
+{{/each}}
+            transport,
+        }
+    }
+
+    /// Return a reference to the underlying transport layer.
+    pub fn transport(&self) -> &Transport {
+        &self.transport
+    }
+}
+
+impl std::fmt::Debug for Client {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Client")
+            .field("transport", &"<Transport>")
+{{#each groups}}
+            .field("{{snakeCase name}}", &"<{{interfaceName}}>")
+{{/each}}
+            .finish()
+    }
+}

package/templates/rust/domain.hbs

@@ -0,0 +1,94 @@
+use crate::transport::Transport;
+use crate::error::SdkError;
+use reqwest::Method;
+{{#if imports.length}}
+use crate::types::{ {{join imports ", "}} };
+{{/if}}
+
+/// {{#if description}}{{description}}{{else}}{{interfaceName}} API operations.{{/if}}
+pub struct {{interfaceName}} {
+    transport: Transport,
+}
+
+impl {{interfaceName}} {
+    pub(crate) fn new(transport: Transport) -> Self {
+        Self { transport }
+    }
+
+{{#each operations}}
+    {{#if summary}}
+    /// {{summary}}{{#if description}}
+    ///
+    /// {{description}}{{/if}}
+    {{/if}}
+    {{#if deprecated}}
+    #[deprecated{{#if deprecationMessage}}(note = "{{deprecationMessage}}"){{/if}}]
+    {{/if}}
+    pub async fn {{snakeCase name}}(
+        &self,
+{{#each pathParams}}
+        {{snakeCase name}}: {{{rustParamType type}}},
+{{/each}}
+{{#if requestBody}}
+        body: &{{{requestBody.rustType}}},
+{{/if}}
+{{#if queryType}}
+        query: Option<&{{{rustQueryType queryType}}}>,
+{{/if}}
+    ) -> Result<{{#if isEventStream}}Vec<{{#if eventSchema}}{{{rustType eventSchema}}}{{else}}serde_json::Value{{/if}}>{{else}}{{{rustResponseType}}}{{/if}}, SdkError> {
+        let path = format!("{{path}}"{{#each pathParams}}, {{snakeCase name}} = {{#if (isRustCopyType type)}}{{snakeCase name}}{{else}}{{snakeCase name}}{{/if}}{{/each}});
+{{#if (hasQueryParams this)}}
+        let mut query_params: Vec<(String, String)> = Vec::new();
+        if let Some(q) = query {
+{{#each _queryParams}}
+            if let Some(ref v) = q.{{snakeCase name}} {
+                query_params.push(("{{originalName}}".to_string(), v.to_string()));
+            }
+{{/each}}
+        }
+        let query_slice: Option<&[(String, String)]> = if query_params.is_empty() { None } else { Some(&query_params) };
+{{else if queryType}}
+        // Query params from typed query object
+        let query_slice: Option<&[(String, String)]> = None; // TODO: serialize query type
+{{else}}
+        let query_slice: Option<&[(String, String)]> = None;
+{{/if}}
+
+{{#if (or (hasRequestBody this) (needsRequestHeaders this))}}
+        let mut headers: Vec<(String, String)> = Vec::new();
+{{#if (hasRequestBody this)}}
+{{#if (and (neq requestBody.contentType "application/json") (neq requestBody.contentType "multipart/form-data"))}}
+        headers.push(("Content-Type".to_string(), "{{requestBody.contentType}}".to_string()));
+{{/if}}
+{{/if}}
+{{#if (and headerParams.length headerType)}}
+        // Header params injected from header options
+{{/if}}
+{{#each headerParams}}
+        if let Some(ref h) = header_options.{{snakeCase name}} {
+            headers.push(("{{originalName}}".to_string(), h.to_string()));
+        }
+{{/each}}
+{{#if cookieParams}}
+        // Cookie params
+{{/if}}
+        let headers_slice: Option<&[(String, String)]> = if headers.is_empty() { None } else { Some(&headers) };
+{{else}}
+        let headers_slice: Option<&[(String, String)]> = None;
+{{/if}}
+
+        self.transport.execute::<{{#if isEventStream}}Vec<{{#if eventSchema}}{{{rustType eventSchema}}}{{else}}serde_json::Value{{/if}}>{{else}}{{{rustResponseType}}}{{/if}}>(
+            Method::{{httpMethod}},
+            &path,
+            query_slice,
+{{#if requestBody}}
+            Some(body),
+{{else}}
+            None::<&serde_json::Value>,
+{{/if}}
+            headers_slice,
+        ).await
+    }
+
+{{/each}}
+}

package/templates/rust/error.hbs

@@ -0,0 +1,74 @@
+use thiserror::Error;
+
+/// Primary error type for the {{crateName}} SDK.
+///
+/// All API methods return `Result<T, SdkError>`.
+#[derive(Error, Debug)]
+pub enum SdkError {
+    /// The API returned an error response (4xx/5xx).
+    #[error("API error (status {status}): {message}")]
+    ApiError {
+        /// HTTP status code.
+        status: u16,
+        /// Machine-readable error code (if available).
+        code: Option<String>,
+        /// Human-readable error message.
+        message: String,
+        /// Raw response body for debugging.
+        body: String,
+    },
+
+    /// A network-level error occurred (DNS, TLS, connection refused, timeout).
+    #[error("network error: {0}")]
+    NetworkError(String),
+
+    /// Failed to deserialize the response body.
+    #[error("deserialization error: {0}")]
+    DeserializationError(String),
+
+    /// The request parameters failed client-side validation.
+    #[error("validation error: {0}")]
+    ValidationError(String),
+}
+
+impl SdkError {
+    /// Returns the HTTP status code, if this is an `ApiError`.
+    pub fn status(&self) -> Option<u16> {
+        match self {
+            Self::ApiError { status, .. } => Some(*status),
+            _ => None,
+        }
+    }
+
+    /// Returns `true` if this error was caused by the server (5xx).
+    pub fn is_server_error(&self) -> bool {
+        matches!(self, Self::ApiError { status, .. } if *status >= 500)
+    }
+
+    /// Returns `true` if this error was caused by the client (4xx).
+    pub fn is_client_error(&self) -> bool {
+        matches!(self, Self::ApiError { status, .. } if *status >= 400 && *status < 500)
+    }
+
+    /// Returns `true` if this is a network error (should be retried safely).
+    pub fn is_retryable(&self) -> bool {
+        matches!(
+            self,
+            Self::NetworkError(_)
+                | Self::ApiError {
+                    status: 429 | 502 | 503 | 504,
+                    ..
+                }
+        )
+    }
+
+    /// Returns the error message as a string.
+    pub fn message(&self) -> &str {
+        match self {
+            Self::ApiError { message, .. } => message.as_str(),
+            Self::NetworkError(msg) => msg.as_str(),
+            Self::DeserializationError(msg) => msg.as_str(),
+            Self::ValidationError(msg) => msg.as_str(),
+        }
+    }
+}

package/templates/rust/lib.hbs

@@ -0,0 +1,85 @@
+//! {{title}}
+//!
+//! {{#if description}}{{description}}{{else}}Auto-generated Rust SDK for the {{title}} API.{{/if}}
+//!
+//! # Quick Start
+//!
+//! Add to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! {{crateName}} = "{{#if packageVersion}}{{packageVersion}}{{else}}0.1.0{{/if}}"
+//! ```
+//!
+//! Then use it:
+//!
+//! ```rust,no_run
+//! use {{crateName}}::Client;
+//! use {{crateName}}::ClientConfig;
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     let mut config = ClientConfig::default();
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+//!     config.{{snakeCase configKey}} = Some("your-api-key".to_string());
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+//!     config.{{snakeCase configKey}} = Some("your-bearer-token".to_string());
+{{/if}}
+{{/each}}
+//!
+//!     let client = Client::new(config);
+//!
+//!     // Use domain clients
+//!     // let result = client.{{#each groups}}{{#if @first}}{{snakeCase name}}{{/if}}{{/each}}.some_method().await?;
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ## API Reference
+//!
+{{#each groups}}
+//! ### `{{interfaceName}}`
+//! {{#if description}}{{description}}{{/if}}
+//!
+{{#each operations}}
+//! - `{{snakeCase name}}()` — {{#if summary}}{{summary}}{{else}}No summary{{/if}}
+{{/each}}
+//!
+{{/each}}
+//!
+//! ## Error Handling
+//!
+//! All API methods return `Result<T, SdkError>`. The `SdkError` enum covers:
+//!
+//! - **ApiError** — server returned an error response (4xx/5xx)
+//! - **NetworkError** — request failed due to network issues
+//! - **DeserializationError** — response body could not be parsed
+//! - **ValidationError** — invalid request parameters
+//!
+//! ```rust
+//! match client.some_domain.some_method().await {
+//!     Ok(response) => println!("Success: {:?}", response),
+//!     Err(SdkError::ApiError { status, .. }) => eprintln!("API error ({}): {}", status, error),
+//!     Err(SdkError::NetworkError(e)) => eprintln!("Network error: {}", e),
+//!     Err(e) => eprintln!("Other error: {}", e),
+//! }
+//! ```
+
+pub mod client;
+pub mod transport;
+pub mod error;
+pub mod types;
+pub mod api;
+
+pub use client::*;
+pub use error::SdkError;
+
+/// Re-export API resource modules
+pub mod resources {
+{{#each groups}}
+    pub use super::api::{{snakeCase fileName}}::*;
+{{/each}}
+}

package/templates/rust/readme.hbs

@@ -0,0 +1,77 @@
+# {{title}}
+
+{{#if description}}{{description}}{{/if}}
+
+{{#unless description}}An auto-generated Rust SDK for the {{title}} API.{{/unless}}
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+{{crateName}} = "{{#if packageVersion}}{{packageVersion}}{{else}}0.1.0{{/if}}"
+```
+
+## Quick Start
+
+```rust
+use {{crateName}}::Client;
+use {{crateName}}::ClientConfig;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let mut config = ClientConfig::default();
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+    config.{{snakeCase configKey}} = Some("your-api-key".to_string());
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+    config.{{snakeCase configKey}} = Some("your-bearer-token".to_string());
+{{/if}}
+{{/each}}
+
+    let client = Client::new(config);
+
+    // Use domain clients
+{{#each groups}}
+{{#if @first}}
+    // let result = client.{{snakeCase name}}.some_operation().await?;
+{{/if}}
+{{/each}}
+
+    Ok(())
+}
+```
+
+## API Reference
+
+{{#each groups}}
+### {{interfaceName}}
+
+{{#if description}}
+{{description}}
+{{/if}}
+
+| Method | HTTP | Description |
+|--------|------|-------------|
+{{#each operations}}
+| `{{snakeCase name}}()` | `{{httpMethod}}` | {{#if summary}}{{summary}}{{else}}—{{/if}} |
+{{/each}}
+
+{{/each}}
+
+## Error Handling
+
+All API methods return `Result<T, SdkError>`. The `SdkError` enum has these variants:
+
+| Variant | Description |
+|---------|-------------|
+| `ApiError` | Server returned an error (4xx/5xx) |
+| `NetworkError` | Request failed due to connectivity issues |
+| `DeserializationError` | Response body could not be parsed |
+| `ValidationError` | Invalid request parameters |
+
+## License
+
+MIT