@apollo-deploy/tesseract 0.9.1 → 1.0.0

package/templates/ruby/readme.hbs

@@ -0,0 +1,113 @@
+# {{meta.title}} Ruby SDK
+
+{{#if meta.description}}
+{{meta.description}}
+
+{{/if}}
+> This SDK was automatically generated by [Tesseract](https://www.npmjs.com/package/@apollo-deploy/tesseract).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem '{{gemName}}'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install {{gemName}}
+```
+
+## Quick Start
+
+```ruby
+require '{{gemName}}'
+
+client = {{pascalCase meta.clientName}}::Client.new(
+  base_url: '{{meta.baseUrl}}',
+{{#each securitySchemes}}
+  {{camelCase name}}: 'your-{{kebabCase name}}-credential',
+{{/each}}
+)
+
+# Make API calls
+result = client.{{groups.[0].name}}.{{groups.[0].operations.[0].name}}
+```
+
+## Configuration
+
+```ruby
+client = {{pascalCase meta.clientName}}::Client.new(
+  base_url: '{{meta.baseUrl}}',
+{{#each securitySchemes}}
+  {{camelCase name}}: ENV['{{upperCase (snakeCase name)}}'],
+{{/each}}
+  timeout: 30,               # seconds
+  retries: { attempts: 3, backoff: 0.4, jitter: true }
+)
+```
+
+## API Reference
+
+{{#each groups}}
+### {{pascalCase name}}
+
+{{#if description}}
+{{description}}
+
+{{/if}}
+| Method | HTTP | Path | Description |
+|--------|------|------|-------------|
+{{#each operations}}
+| `{{snakeCase name}}` | {{httpMethod}} | `{{path}}` | {{#if summary}}{{summary}}{{else}}-{{/if}} |
+{{/each}}
+
+{{/each}}
+
+## Types
+
+{{#each schemas}}
+{{#if isEnum}}
+- `{{pascalCase name}}` — module with constants: {{#each enumValues}}`{{this}}`{{#unless @last}}, {{/unless}}{{/each}}
+{{else if isTypeAlias}}
+- `{{pascalCase name}}` — type alias
+{{else}}
+- `{{pascalCase name}}`{{#if description}} — {{description}}{{/if}}
+{{/if}}
+{{/each}}
+
+## Error Handling
+
+```ruby
+begin
+  result = client.some_api.some_method
+rescue {{pascalCase meta.clientName}}::SDKError => e
+  puts "Error #{e.status}: #{e.message} (#{e.code})"
+  puts "Request ID: #{e.request_id}" if e.request_id
+
+  if e.rate_limited?
+    sleep 1
+    retry
+  end
+
+  raise
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake spec` to run the tests.
+You can also run `bin/console` for an interactive prompt.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

package/templates/ruby/transport.hbs

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require_relative "errors"
+
+module {{pascalCase meta.clientName}}
+  # HTTP transport layer built on Faraday.
+  class Transport
+    attr_reader :config
+    attr_reader :connection
+
+    def initialize(config)
+      @config = config
+      @connection = Faraday.new(url: config.base_url) do |f|
+        f.request :json
+        f.response :raise_error
+        f.options.timeout = config.timeout
+        f.options.open_timeout = [config.timeout / 3, 2].max
+        config.default_headers.each do |key, value|
+          f.headers[key] = value
+        end
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def request(method:, path:, path_params: {}, query: nil, body: nil, headers: {}, content_type: nil)
+      url = build_url(path, path_params)
+      attempts = 0
+      max_attempts = [(@config.retries[:attempts] || 3), 1].max
+      backoff = @config.retries[:backoff] || 0.4
+      jitter = @config.retries.fetch(:jitter, true)
+      max_backoff = @config.retries[:max_backoff] || 30.0
+      begin
+        attempts += 1
+        response = @connection.run_request(
+          method.to_sym, url, body, build_headers(headers, content_type)
+        ) do |req|
+          req.params.merge!(query) if query && !query.empty?
+        end
+        parse_response(response)
+      rescue Faraday::Error => e
+        raise map_error(e, method: method, path: path) unless should_retry?(e, attempts, max_attempts)
+        sleep(retry_delay(backoff, attempts, jitter, max_backoff))
+        retry
+      end
+    end
+
+    def get(path:, path_params: {}, query: nil, headers: {})
+      request(method: :get, path: path, path_params: path_params, query: query, headers: headers)
+    end
+
+    def post(path:, body: nil, path_params: {}, query: nil, headers: {}, content_type: nil)
+      request(method: :post, path: path, body: body, path_params: path_params,
+              query: query, headers: headers, content_type: content_type)
+    end
+
+    def put(path:, body: nil, path_params: {}, query: nil, headers: {}, content_type: nil)
+      request(method: :put, path: path, body: body, path_params: path_params,
+              query: query, headers: headers, content_type: content_type)
+    end
+
+    def patch(path:, body: nil, path_params: {}, query: nil, headers: {}, content_type: nil)
+      request(method: :patch, path: path, body: body, path_params: path_params,
+              query: query, headers: headers, content_type: content_type)
+    end
+
+    def delete(path:, path_params: {}, query: nil, headers: {})
+      request(method: :delete, path: path, path_params: path_params, query: query, headers: headers)
+    end
+
+    private
+
+    def build_url(path, path_params)
+      return path if path_params.empty?
+      path.gsub(/\{(\w+)\}/) do |_match|
+        key = ::Regexp.last_match(1)
+        value = path_params[key.to_sym] || path_params[key]
+        value.nil? ? _match : value.to_s
+      end
+    end
+
+    def build_headers(extra_headers = {}, content_type = nil)
+      headers = {}
+      if content_type
+        headers["Content-Type"] = content_type
+      end
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+{{#if (eq in "header")}}
+      headers["{{paramName}}"] = @config.{{camelCase name}} if @config.{{camelCase name}}
+{{/if}}
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+      headers["Authorization"] = "Bearer " + (@config.{{camelCase name}} || "") if @config.{{camelCase name}}
+{{/if}}
+{{#if (eq type "oauth2")}}
+      headers["Authorization"] = "Bearer " + (@config.{{camelCase name}} || "") if @config.{{camelCase name}}
+{{/if}}
+{{#if (eq type "openIdConnect")}}
+      headers["Authorization"] = "Bearer " + (@config.{{camelCase name}} || "") if @config.{{camelCase name}}
+{{/if}}
+{{/each}}
+      headers.merge!(extra_headers)
+      headers
+    end
+
+    def parse_response(response)
+      body = response.body
+      return nil if body.nil? || (body.is_a?(String) && body.strip.empty?)
+      if body.is_a?(String)
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          body
+        end
+      else
+        body
+      end
+    end
+
+    def map_error(error, method:, path:)
+      case error
+      when Faraday::TimeoutError
+        SDKError.new("Request timed out", 0, "network_error", method: method, path: path)
+      when Faraday::ConnectionFailed
+        SDKError.new("Connection failed: " + error.message, 0, "network_error", method: method, path: path)
+      when Faraday::ResourceNotFound
+        SDKError.new("Not found: " + error.message, 404, "not_found", method: method, path: path)
+      when Faraday::ClientError
+        status = error.response&.[](:status) || 400
+        begin
+          body = error.response&.[](:body)
+          envelope = body.is_a?(String) ? JSON.parse(body) : body
+          if envelope.is_a?(Hash)
+            SDKError.new(
+              envelope["message"] || envelope["error"] || "Request failed",
+              status,
+              envelope["error"] || envelope["code"] || "unknown_error",
+              request_id: envelope["request_id"],
+              method: method, path: path
+            )
+          else
+            SDKError.new("Request failed with status " + status.to_s, status, "unknown_error", method: method, path: path)
+          end
+        rescue
+          SDKError.new("Request failed with status " + status.to_s, status, "unknown_error", method: method, path: path)
+        end
+      when Faraday::ServerError
+        status = error.response&.[](:status) || 500
+        SDKError.new("Server error: " + error.message, status, "internal_server_error", method: method, path: path)
+      else
+        SDKError.new(error.message, 0, "unknown_error", method: method, path: path)
+      end
+    end
+
+    def should_retry?(_error, attempts, max_attempts)
+      return false if attempts >= max_attempts
+      case _error
+      when Faraday::TimeoutError, Faraday::ConnectionFailed, Faraday::ServerError
+        true
+      when Faraday::ClientError
+        status = _error.response&.[](:status)
+        status == 429
+      else
+        false
+      end
+    end
+
+    def retry_delay(base, attempt, jitter, max_backoff)
+      delay = base * (2**(attempt - 1))
+      delay = max_backoff if delay > max_backoff
+      delay *= (0.5 + rand * 0.5) if jitter
+      delay
+    end
+  end
+end

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}}
+}