@apollo-deploy/tesseract 0.9.1 → 1.0.0

package/templates/go/transport.hbs

@@ -0,0 +1,379 @@
+package {{pkgName}}
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// TransportConfig holds configuration for the HTTP transport layer.
+type TransportConfig struct {
+	BaseURL    string
+{{#each securitySchemes}}
+	{{pascalCase configKey}} string
+{{/each}}
+	Timeout    time.Duration
+	MaxRetries int
+	Headers    map[string]string
+}
+
+// Transport is the low-level HTTP client that handles authentication,
+// serialization, retries, and error normalization.
+type Transport struct {
+	config     TransportConfig
+	httpClient *http.Client
+}
+
+// NewTransport creates a new Transport with the given configuration.
+func NewTransport(cfg TransportConfig) *Transport {
+	return &Transport{
+		config: cfg,
+		httpClient: &http.Client{
+			Timeout: cfg.Timeout,
+		},
+	}
+}
+
+// request holds all the parameters for a single HTTP call.
+type request struct {
+	Method      string
+	Path        string
+	Query       url.Values
+	Body        interface{}
+	ContentType string
+	Headers     map[string]string
+}
+
+// Execute performs an HTTP request and unmarshals the response body into result.
+// result must be a non-nil pointer.
+func (t *Transport) Execute(ctx context.Context, req request, result interface{}) error {
+	return t.executeWithRetries(ctx, req, result, t.config.MaxRetries)
+}
+
+// ExecuteRaw performs an HTTP request and returns the raw response body bytes.
+func (t *Transport) ExecuteRaw(ctx context.Context, req request) ([]byte, error) {
+	return t.executeRawWithRetries(ctx, req, t.config.MaxRetries)
+}
+
+// executeWithRetries performs the request with exponential backoff retry logic.
+func (t *Transport) executeWithRetries(ctx context.Context, req request, result interface{}, maxRetries int) error {
+	var lastErr error
+
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		if attempt > 0 {
+			backoff := time.Duration(math.Pow(2, float64(attempt-1))) * 200 * time.Millisecond
+			jitter := time.Duration(rand.Int63n(int64(backoff / 2)))
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			case <-time.After(backoff + jitter):
+			}
+		}
+
+		resp, body, err := t.doRequest(ctx, req)
+		if err != nil {
+			lastErr = err
+			if !isRetryable(err) {
+				return err
+			}
+			continue
+		}
+
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			if result != nil && len(body) > 0 {
+				if err := json.Unmarshal(body, result); err != nil {
+					return fmt.Errorf("failed to unmarshal response: %w", err)
+				}
+			}
+			return nil
+		}
+
+		if resp.StatusCode >= 500 && attempt < maxRetries {
+			lastErr = parseErrorResponse(resp, body)
+			continue
+		}
+
+		return parseErrorResponse(resp, body)
+	}
+
+	return lastErr
+}
+
+// executeRawWithRetries performs a raw request with retries.
+func (t *Transport) executeRawWithRetries(ctx context.Context, req request, maxRetries int) ([]byte, error) {
+	var lastErr error
+
+	for attempt := 0; attempt <= maxRetries; attempt++ {
+		if attempt > 0 {
+			backoff := time.Duration(math.Pow(2, float64(attempt-1))) * 200 * time.Millisecond
+			jitter := time.Duration(rand.Int63n(int64(backoff / 2)))
+			select {
+			case <-ctx.Done():
+				return nil, ctx.Err()
+			case <-time.After(backoff + jitter):
+			}
+		}
+
+		resp, body, err := t.doRequest(ctx, req)
+		if err != nil {
+			lastErr = err
+			if !isRetryable(err) {
+				return nil, err
+			}
+			continue
+		}
+
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			return body, nil
+		}
+
+		if resp.StatusCode >= 500 && attempt < maxRetries {
+			lastErr = parseErrorResponse(resp, body)
+			continue
+		}
+
+		return nil, parseErrorResponse(resp, body)
+	}
+
+	return nil, lastErr
+}
+
+// doRequest builds and executes a single HTTP request.
+func (t *Transport) doRequest(ctx context.Context, req request) (*http.Response, []byte, error) {
+	// Build URL
+	base, err := url.Parse(t.config.BaseURL)
+	if err != nil {
+		return nil, nil, fmt.Errorf("invalid base URL: %w", err)
+	}
+
+	rel, err := url.Parse(req.Path)
+	if err != nil {
+		return nil, nil, fmt.Errorf("invalid request path: %w", err)
+	}
+
+	fullURL := base.ResolveReference(rel)
+
+	if len(req.Query) > 0 {
+		fullURL.RawQuery = req.Query.Encode()
+	}
+
+	// Build body
+	var bodyReader io.Reader
+	if req.Body != nil {
+		bodyBytes, err := json.Marshal(req.Body)
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		bodyReader = bytes.NewReader(bodyBytes)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, fullURL.String(), bodyReader)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Set default headers
+	for k, v := range t.config.Headers {
+		httpReq.Header.Set(k, v)
+	}
+
+	// Set auth headers
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+{{#if (eq in "header")}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("{{paramName}}", t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{#if (eq in "query")}}
+	if t.config.{{pascalCase configKey}} != "" {
+		q := httpReq.URL.Query()
+		q.Set("{{paramName}}", t.config.{{pascalCase configKey}})
+		httpReq.URL.RawQuery = q.Encode()
+	}
+{{/if}}
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{#if (eq type "oauth2")}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{#if (eq type "openIdConnect")}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{/each}}
+
+	// Set content type
+	if req.ContentType != "" {
+		httpReq.Header.Set("Content-Type", req.ContentType)
+	} else if req.Body != nil {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+
+	// Set custom headers
+	for k, v := range req.Headers {
+		httpReq.Header.Set(k, v)
+	}
+
+	resp, err := t.httpClient.Do(httpReq)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return resp, nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	return resp, body, nil
+}
+
+// Stream executes an HTTP request and returns the response body for streaming.
+func (t *Transport) Stream(ctx context.Context, req request) (*http.Response, error) {
+	base, err := url.Parse(t.config.BaseURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid base URL: %w", err)
+	}
+
+	rel, err := url.Parse(req.Path)
+	if err != nil {
+		return nil, fmt.Errorf("invalid request path: %w", err)
+	}
+
+	fullURL := base.ResolveReference(rel)
+
+	if len(req.Query) > 0 {
+		fullURL.RawQuery = req.Query.Encode()
+	}
+
+	var bodyReader io.Reader
+	if req.Body != nil {
+		bodyBytes, err := json.Marshal(req.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		bodyReader = bytes.NewReader(bodyBytes)
+	}
+
+	httpReq, err := http.NewRequestWithContext(ctx, req.Method, fullURL.String(), bodyReader)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	for k, v := range t.config.Headers {
+		httpReq.Header.Set(k, v)
+	}
+
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+{{#if (eq in "header")}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("{{paramName}}", t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{#if (eq type "oauth2")}}
+	if t.config.{{pascalCase configKey}} != "" {
+		httpReq.Header.Set("Authorization", "Bearer "+t.config.{{pascalCase configKey}})
+	}
+{{/if}}
+{{/each}}
+
+	if req.ContentType != "" {
+		httpReq.Header.Set("Content-Type", req.ContentType)
+	} else if req.Body != nil {
+		httpReq.Header.Set("Content-Type", "application/json")
+	}
+
+	for k, v := range req.Headers {
+		httpReq.Header.Set(k, v)
+	}
+
+	resp, err := t.httpClient.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode >= 400 {
+		body, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		return nil, parseErrorResponse(resp, body)
+	}
+
+	return resp, nil
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+// isRetryable returns true if the error indicates a transient failure.
+func isRetryable(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := err.Error()
+	return strings.Contains(msg, "connection refused") ||
+		strings.Contains(msg, "connection reset") ||
+		strings.Contains(msg, "timeout") ||
+		strings.Contains(msg, "temporary failure") ||
+		strings.Contains(msg, "EOF")
+}
+
+// parseErrorResponse builds an SDKError from an HTTP response.
+func parseErrorResponse(resp *http.Response, body []byte) error {
+	var requestID string
+	if rid := resp.Header.Get("X-Request-ID"); rid != "" {
+		requestID = rid
+	} else if rid := resp.Header.Get("x-request-id"); rid != "" {
+		requestID = rid
+	}
+
+	sdkErr := &SDKError{
+		Status:    resp.StatusCode,
+		RequestID: requestID,
+		Message:   strings.TrimSpace(string(body)),
+	}
+
+	// Try to extract a structured error code from the response body
+	var envelope struct {
+		Code    string `json:"code"`
+		Message string `json:"message"`
+		Error   string `json:"error"`
+	}
+	if err := json.Unmarshal(body, &envelope); err == nil {
+		if envelope.Code != "" {
+			sdkErr.Code = envelope.Code
+		}
+		if envelope.Message != "" {
+			sdkErr.Message = envelope.Message
+		} else if envelope.Error != "" {
+			sdkErr.Message = envelope.Error
+		}
+	}
+
+	if sdkErr.Message == "" {
+		sdkErr.Message = fmt.Sprintf("HTTP %d: %s", resp.StatusCode, resp.Status)
+	}
+
+	return sdkErr
+}

package/templates/go/types.hbs

@@ -0,0 +1,80 @@
+package {{pkgName}}
+
+{{#if schemas}}
+import (
+	"time"
+)
+{{/if}}
+
+{{#each schemas}}
+{{#if (neq ownership.kind "external")}}
+{{#if isEnum}}
+// {{name}} {{#if description}}{{description}}{{/if}}
+type {{name}} string
+
+const (
+{{#each enumValues}}
+	{{pascalCase ../name}}{{pascalCase this}} {{../name}} = "{{this}}"
+{{/each}}
+)
+
+{{else if isUnionType}}
+// {{name}} {{#if description}}{{description}}{{/if}}
+type {{name}} struct {
+	value interface{}
+}
+
+{{#each unionMembers}}
+// New{{../name}}From{{this}} creates a {{../name}} from a {{this}} value.
+func New{{../name}}From{{this}}(v {{this}}) {{../name}} {
+	return {{../name}}{value: v}
+}
+{{/each}}
+
+// Value returns the underlying value.
+func (u {{name}}) Value() interface{} {
+	return u.value
+}
+
+// UnmarshalJSON implements json.Unmarshaler for {{name}}.
+func (u *{{name}}) UnmarshalJSON(data []byte) error {
+{{#each unionMembers}}
+	var v{{@index}} {{this}}
+	if err := json.Unmarshal(data, &v{{@index}}); err == nil {
+		u.value = v{{@index}}
+		return nil
+	}
+{{/each}}
+	return fmt.Errorf("unable to unmarshal {{name}} from %s", string(data))
+}
+
+// MarshalJSON implements json.Marshaler for {{name}}.
+func (u {{name}}) MarshalJSON() ([]byte, error) {
+	return json.Marshal(u.value)
+}
+
+{{else if isIntersectionType}}
+// {{name}} {{#if description}}{{description}}{{/if}}
+type {{name}} struct {
+{{#each intersectionMembers}}
+	{{this}}
+{{/each}}
+}
+
+{{else if isTypeAlias}}
+// {{name}} {{#if description}}{{description}}{{/if}}
+type {{name}} = {{additionalPropertiesType}}
+
+{{else}}
+{{#if description}}
+// {{name}} {{description}}
+{{/if}}
+type {{name}} struct {
+{{#each properties}}
+	{{pascalCase name}} {{#if (or nullable (not required))}}*{{/if}}{{#if (eq type "string")}}{{#if (eq format "date-time")}}time.Time{{else}}string{{/if}}{{else if (eq type "integer")}}int{{else if (eq type "number")}}float64{{else if (eq type "boolean")}}bool{{else}}{{goPropertyType type}}{{/if}} `json:"{{name}}{{#if (or nullable (not required))}},omitempty{{/if}}"`{{#if description}} // {{description}}{{/if}}
+{{/each}}
+}
+{{/if}}
+
+{{/if}}
+{{/each}}

package/templates/go/utils.hbs

@@ -0,0 +1,45 @@
+package {{pkgName}}
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+// buildPath substitutes path parameters into a URL template.
+// replacements is pairs of (placeholder, value).
+func buildPath(template string, replacements ...string) string {
+	for i := 0; i < len(replacements); i += 2 {
+		placeholder := ":" + replacements[i]
+		value := url.PathEscape(replacements[i+1])
+		template = strings.Replace(template, placeholder, value, 1)
+	}
+	return template
+}
+
+// buildQuery converts a params struct into url.Values.
+func buildQuery(params interface{}) url.Values {
+	if params == nil {
+		return nil
+	}
+	data, err := json.Marshal(params)
+	if err != nil {
+		return nil
+	}
+	var m map[string]interface{}
+	if err := json.Unmarshal(data, &m); err != nil {
+		return nil
+	}
+	q := url.Values{}
+	for k, v := range m {
+		if v == nil {
+			continue
+		}
+		q.Set(k, fmt.Sprintf("%v", v))
+	}
+	if len(q) == 0 {
+		return nil
+	}
+	return q
+}

package/templates/kotlin/build-gradle.hbs

@@ -0,0 +1,41 @@
+plugins {
+    kotlin("jvm") version "1.9.25"
+    kotlin("plugin.serialization") version "1.9.25"
+    `maven-publish`
+}
+
+group = "{{groupId}}"
+version = "{{#if packageVersion}}{{packageVersion}}{{else}}0.1.0{{/if}}"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1")
+    implementation("io.ktor:ktor-client-core:2.3.12")
+    implementation("io.ktor:ktor-client-cio:2.3.12")
+    implementation("io.ktor:ktor-client-content-negotiation:2.3.12")
+    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+
+    testImplementation(kotlin("test"))
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.1")
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            from(components["java"])
+        }
+    }
+}

package/templates/kotlin/client.hbs

@@ -0,0 +1,57 @@
+package {{packageName}}
+
+import kotlinx.coroutines.*
+
+/**
+ * Configuration for the {{title}} API client.
+ */
+data class ClientConfig(
+    val baseUrl: String = "{{baseUrl}}",
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+    /** API key for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+    /** Bearer token for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{#if (eq type "oauth2")}}
+    /** OAuth2 access token for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{#if (eq type "openIdConnect")}}
+    /** OpenID Connect access token for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{/each}}
+    /** Request timeout in milliseconds. */
+    val timeoutMs: Long = 15000,
+    /** Maximum number of retry attempts. */
+    val maxRetries: Int = 3,
+)
+
+/**
+ * Primary API client for {{title}}.
+ *
+ * Provides access to all domain-specific API groups.
+ */
+class {{clientName}}Client(
+    config: ClientConfig = ClientConfig()
+) {
+    private val transport: Transport = Transport(
+        TransportConfig(
+            baseUrl = config.baseUrl,
+{{#each securitySchemes}}
+            {{configKey}} = config.{{configKey}},
+{{/each}}
+            timeoutMs = config.timeoutMs,
+            maxRetries = config.maxRetries,
+        )
+    )
+
+{{#each groups}}
+    /** {{#if description}}{{description}}{{else}}{{interfaceName}} operations.{{/if}} */
+    val {{name}}: {{interfaceName}} = {{interfaceName}}(transport)
+{{/each}}
+}

package/templates/kotlin/domain.hbs

@@ -0,0 +1,73 @@
+package {{packageName}}
+
+import io.ktor.http.*
+import kotlinx.coroutines.*
+
+/**
+ * {{#if description}}{{description}}{{else}}{{interfaceName}} API operations.{{/if}}
+ */
+class {{interfaceName}}(
+    private val transport: Transport
+) {
+{{#each operations}}
+    {{#if summary}}
+    /**
+     * {{summary}}{{#if description}}
+     *
+     * {{description}}{{/if}}
+     */
+    {{/if}}
+    {{#if deprecated}}
+    @Deprecated(
+        message = "{{#if deprecationMessage}}{{deprecationMessage}}{{else}}This operation is deprecated.{{/if}}",
+    )
+    {{/if}}
+    suspend fun {{name}}(
+{{#each pathParams}}
+        {{name}}: {{{kotlinType type}}},
+{{/each}}
+{{#if requestBody}}
+        body: {{{requestBody.kotlinType}}},
+{{/if}}
+{{#if queryType}}
+        query: {{{kotlinType queryType}}}? = null,
+{{/if}}
+    ): {{{kotlinResponseType}}} {
+        val path = "{{path}}"{{#each pathParams}}.replace("{" + "{{name}}" + "}", {{name}}.toString()){{/each}}
+
+        {{#if (hasQueryParams this)}}
+        val queryMap = mutableMapOf<String, String?>()
+        {{#each _queryParams}}
+        queryMap["{{originalName}}"] = null // TODO: extract from typed query if available
+        {{/each}}
+        {{else if queryType}}
+        val queryMap: Map<String, String?>? = null // TODO: serialize query type
+        {{else}}
+        val queryMap: Map<String, String?>? = null
+        {{/if}}
+
+        {{#if (or (hasRequestBody this) (needsRequestHeaders this))}}
+        val headers = mutableMapOf<String, String>()
+        {{#if (hasRequestBody this)}}
+        {{#if (and (neq requestBody.contentType "application/json") (neq requestBody.contentType "multipart/form-data"))}}
+        headers["Content-Type"] = "{{requestBody.contentType}}"
+        {{/if}}
+        {{/if}}
+        {{#each headerParams}}
+        // TODO: inject header param '{{originalName}}' from header options
+        {{/each}}
+        {{else}}
+        val headers: Map<String, String>? = null
+        {{/if}}
+
+        return transport.execute<{{{kotlinResponseType}}}>(
+            method = HttpMethod.{{httpMethod}},
+            path = path,
+            query = queryMap,
+            body = {{#if requestBody}}body{{else}}null{{/if}},
+            headers = headers{{#unless (or (hasRequestBody this) (needsRequestHeaders this))}}{{/unless}},
+        )
+    }
+
+{{/each}}
+}