@apollo-deploy/tesseract 1.9.0 → 2.0.0

package/templates/go/transport.hbs

@@ -6,43 +6,61 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math"
 	"math/rand"
+	"net"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 )
 
-// TransportConfig holds configuration for the HTTP transport layer.
+var retryableMethods = map[string]struct{}{
+	http.MethodGet: {}, http.MethodHead: {}, http.MethodOptions: {},
+	http.MethodPut: {}, http.MethodDelete: {},
+}
+
+var retryableStatuses = map[int]struct{}{
+	http.StatusRequestTimeout: {}, 425: {}, http.StatusTooManyRequests: {},
+	http.StatusInternalServerError: {}, http.StatusBadGateway: {},
+	http.StatusServiceUnavailable: {}, http.StatusGatewayTimeout: {},
+}
+
+// TransportConfig configures the HTTP transport.
 type TransportConfig struct {
-	BaseURL    string
+	BaseURL string
 {{#each securitySchemes}}
 	{{pascalCase configKey}} string
 {{/each}}
-	Timeout    time.Duration
-	MaxRetries int
-	Headers    map[string]string
+	Timeout             time.Duration
+	MaxRetries          int
+	RetryUnsafeRequests bool
+	Headers             map[string]string
+	UserAgent           string
 }
 
-// Transport is the low-level HTTP client that handles authentication,
-// serialization, retries, and error normalization.
+// Transport handles authentication, serialization, retries, and errors.
 type Transport struct {
 	config     TransportConfig
 	httpClient *http.Client
 }
 
-// NewTransport creates a new Transport with the given configuration.
 func NewTransport(cfg TransportConfig) *Transport {
+	if cfg.Timeout <= 0 {
+		cfg.Timeout = 15 * time.Second
+	}
+	if cfg.MaxRetries < 0 {
+		cfg.MaxRetries = 0
+	}
+	if cfg.UserAgent == "" {
+		cfg.UserAgent = "{{pkgName}}-go-sdk/{{packageVersion}}"
+	}
 	return &Transport{
 		config: cfg,
-		httpClient: &http.Client{
-			Timeout: cfg.Timeout,
-		},
+		httpClient: &http.Client{Timeout: cfg.Timeout},
 	}
 }
 
-// request holds all the parameters for a single HTTP call.
 type request struct {
 	Method      string
 	Path        string
@@ -52,125 +70,107 @@ type request struct {
 	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)
+	body, err := t.executeWithRetries(ctx, req)
+	if err != nil {
+		return err
+	}
+	if result == nil || len(body) == 0 {
+		return nil
+	}
+	if err := json.Unmarshal(body, result); err != nil {
+		return fmt.Errorf("failed to unmarshal response: %w", err)
+	}
+	return nil
 }
 
-// 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)
+	return t.executeWithRetries(ctx, req)
 }
 
-// executeWithRetries performs the request with exponential backoff retry logic.
-func (t *Transport) executeWithRetries(ctx context.Context, req request, result interface{}, maxRetries int) error {
+func (t *Transport) executeWithRetries(ctx context.Context, req request) ([]byte, error) {
+	canRetry := t.canRetry(req)
 	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):
-			}
+	for attempt := 0; attempt <= t.config.MaxRetries; attempt++ {
+		resp, body, err := t.doRequest(ctx, req)
+		if err == nil && resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			return body, nil
 		}
 
-		resp, body, err := t.doRequest(ctx, req)
+		var retryAfter time.Duration
 		if err != nil {
 			lastErr = err
-			if !isRetryable(err) {
-				return err
+			if !canRetry || !isRetryableNetworkError(err) || attempt >= t.config.MaxRetries {
+				return nil, normalizeNetworkError(err)
+			}
+		} else {
+			lastErr = parseErrorResponse(resp, body)
+			if !canRetry || !isRetryableStatus(resp.StatusCode) || attempt >= t.config.MaxRetries {
+				return nil, lastErr
 			}
-			continue
+			retryAfter = parseRetryAfter(resp.Header.Get("Retry-After"))
 		}
 
-		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)
-				}
+		delay := retryAfter
+		if delay <= 0 {
+			capDelay := 400 * time.Millisecond * time.Duration(1<<attempt)
+			if capDelay > 30*time.Second {
+				capDelay = 30 * time.Second
+			}
+			if capDelay > 0 {
+				delay = time.Duration(rand.Int63n(int64(capDelay) + 1))
 			}
-			return nil
 		}
-
-		if resp.StatusCode >= 500 && attempt < maxRetries {
-			lastErr = parseErrorResponse(resp, body)
-			continue
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		case <-time.After(delay):
 		}
-
-		return parseErrorResponse(resp, body)
 	}
 
-	return lastErr
+	return nil, 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
+func (t *Transport) canRetry(req request) bool {
+	if t.config.RetryUnsafeRequests {
+		return true
+	}
+	if _, ok := retryableMethods[strings.ToUpper(req.Method)]; ok {
+		return true
+	}
+	for name, value := range t.config.Headers {
+		if strings.EqualFold(name, "X-Idempotency-Key") && value != "" {
+			return true
 		}
-
-		if resp.StatusCode >= 500 && attempt < maxRetries {
-			lastErr = parseErrorResponse(resp, body)
-			continue
+	}
+	for name, value := range req.Headers {
+		if strings.EqualFold(name, "X-Idempotency-Key") && value != "" {
+			return true
 		}
-
-		return nil, parseErrorResponse(resp, body)
 	}
-
-	return nil, lastErr
+	return false
 }
 
-// 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)
+		bodyBytes, marshalErr := json.Marshal(req.Body)
+		if marshalErr != nil {
+			return nil, nil, fmt.Errorf("failed to marshal request body: %w", marshalErr)
 		}
 		bodyReader = bytes.NewReader(bodyBytes)
 	}
@@ -180,12 +180,13 @@ func (t *Transport) doRequest(ctx context.Context, req request) (*http.Response,
 		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)
+	for key, value := range t.config.Headers {
+		httpReq.Header.Set(key, value)
+	}
+	httpReq.Header.Set("Accept", "application/json")
+	if httpReq.Header.Get("User-Agent") == "" {
+		httpReq.Header.Set("User-Agent", t.config.UserAgent)
 	}
-
-	// Set auth headers
 {{#each securitySchemes}}
 {{#if (eq type "apiKey")}}
 {{#if (eq in "header")}}
@@ -195,9 +196,9 @@ func (t *Transport) doRequest(ctx context.Context, req request) (*http.Response,
 {{/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()
+		query := httpReq.URL.Query()
+		query.Set("{{paramName}}", t.config.{{pascalCase configKey}})
+		httpReq.URL.RawQuery = query.Encode()
 	}
 {{/if}}
 {{/if}}
@@ -218,16 +219,13 @@ func (t *Transport) doRequest(ctx context.Context, req request) (*http.Response,
 {{/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)
+	for key, value := range req.Headers {
+		httpReq.Header.Set(key, value)
 	}
 
 	resp, err := t.httpClient.Do(httpReq)
@@ -235,38 +233,34 @@ func (t *Transport) doRequest(ctx context.Context, req request) (*http.Response,
 		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.
+// Stream opens a streaming response. Reconnection is left to the caller because
+// replaying a partially consumed stream can duplicate events.
 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)
+		bodyBytes, marshalErr := json.Marshal(req.Body)
+		if marshalErr != nil {
+			return nil, fmt.Errorf("failed to marshal request body: %w", marshalErr)
 		}
 		bodyReader = bytes.NewReader(bodyBytes)
 	}
@@ -275,105 +269,112 @@ func (t *Transport) Stream(ctx context.Context, req request) (*http.Response, er
 	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)
+	for key, value := range t.config.Headers {
+		httpReq.Header.Set(key, value)
 	}
-
+	httpReq.Header.Set("Accept", "text/event-stream")
+	httpReq.Header.Set("User-Agent", t.config.UserAgent)
 {{#each securitySchemes}}
 {{#if (eq type "apiKey")}}
 {{#if (eq in "header")}}
-	if t.config.{{pascalCase configKey}} != "" {
-		httpReq.Header.Set("{{paramName}}", t.config.{{pascalCase configKey}})
-	}
+	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 (or (and (eq type "http") (eq scheme "bearer")) (eq type "oauth2") (eq type "openIdConnect"))}}
+	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)
+	for key, value := range req.Headers {
+		httpReq.Header.Set(key, value)
 	}
 
 	resp, err := t.httpClient.Do(httpReq)
 	if err != nil {
-		return nil, err
+		return nil, normalizeNetworkError(err)
 	}
-
 	if resp.StatusCode >= 400 {
 		body, _ := io.ReadAll(resp.Body)
 		resp.Body.Close()
 		return nil, parseErrorResponse(resp, body)
 	}
-
 	return resp, nil
 }
 
-// ── Helpers ────────────────────────────────────────────────────────────────
+func (t *Transport) CloseIdleConnections() {
+	t.httpClient.CloseIdleConnections()
+}
 
-// isRetryable returns true if the error indicates a transient failure.
-func isRetryable(err error) bool {
+func isRetryableStatus(status int) bool {
+	_, ok := retryableStatuses[status]
+	return ok
+}
+
+func isRetryableNetworkError(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")
+	if netErr, ok := err.(net.Error); ok {
+		return netErr.Timeout() || netErr.Temporary()
+	}
+	message := strings.ToLower(err.Error())
+	return strings.Contains(message, "connection reset") ||
+		strings.Contains(message, "connection refused") ||
+		strings.Contains(message, "unexpected eof") ||
+		strings.Contains(message, "temporary failure")
 }
 
-// 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
+func normalizeNetworkError(err error) error {
+	if err == nil {
+		return nil
 	}
+	return &SDKError{Status: 0, Code: "network_error", Message: err.Error()}
+}
 
-	sdkErr := &SDKError{
-		Status:    resp.StatusCode,
-		RequestID: requestID,
-		Message:   strings.TrimSpace(string(body)),
+func parseRetryAfter(value string) time.Duration {
+	if value == "" {
+		return 0
 	}
-
-	// 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 seconds, err := strconv.ParseFloat(value, 64); err == nil && seconds >= 0 {
+		delay := time.Duration(seconds * float64(time.Second))
+		if delay > 30*time.Second {
+			return 30 * time.Second
+		}
+		return delay
 	}
-	if err := json.Unmarshal(body, &envelope); err == nil {
-		if envelope.Code != "" {
-			sdkErr.Code = envelope.Code
+	if when, err := http.ParseTime(value); err == nil {
+		delay := time.Until(when)
+		if delay > 30*time.Second {
+			return 30 * time.Second
 		}
-		if envelope.Message != "" {
-			sdkErr.Message = envelope.Message
-		} else if envelope.Error != "" {
-			sdkErr.Message = envelope.Error
+		if delay > 0 {
+			return delay
 		}
 	}
+	return 0
+}
 
+func parseErrorResponse(resp *http.Response, body []byte) error {
+	requestID := resp.Header.Get("X-Request-ID")
+	if requestID == "" {
+		requestID = resp.Header.Get("Request-ID")
+	}
+	sdkErr := &SDKError{
+		Status: resp.StatusCode, RequestID: requestID,
+		Code: "http_error", Message: strings.TrimSpace(string(body)),
+	}
+	var envelope struct {
+		Code      string `json:"code"`
+		Message   string `json:"message"`
+		Error     string `json:"error"`
+		RequestID string `json:"request_id"`
+	}
+	if err := json.Unmarshal(body, &envelope); err == nil {
+		if envelope.Code != "" { sdkErr.Code = envelope.Code } else if envelope.Error != "" { sdkErr.Code = envelope.Error }
+		if envelope.Message != "" { sdkErr.Message = envelope.Message }
+		if envelope.RequestID != "" { sdkErr.RequestID = envelope.RequestID }
+	}
 	if sdkErr.Message == "" {
 		sdkErr.Message = fmt.Sprintf("HTTP %d: %s", resp.StatusCode, resp.Status)
 	}
-
 	return sdkErr
 }

package/templates/go/types.hbs

@@ -1,69 +1,35 @@
 package {{pkgName}}
 
-{{#if schemas}}
-import (
-	"time"
-)
+{{#if needsTime}}
+import "time"
 {{/if}}
 
 {{#each schemas}}
-{{#if (neq ownership.kind "external")}}
-{{#if isEnum}}
-// {{name}} {{#if description}}{{description}}{{/if}}
-type {{name}} string
+{{#if external}}
+// {{name}} is supplied by an external schema package in the source manifest.
+type {{name}} = interface{}
+
+{{else if isEnum}}
+// {{name}}{{#if description}} {{description}}{{/if}}
+type {{name}} {{enumType}}
 
 const (
 {{#each enumValues}}
-	{{pascalCase ../name}}{{pascalCase this}} {{../name}} = "{{this}}"
+	{{pascalCase ../name}}{{pascalCase name}} {{../name}} = {{{value}}}
 {{/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)
-}
+// {{name}}{{#if description}} {{description}}{{/if}}
+type {{name}} interface{}
 
 {{else if isIntersectionType}}
-// {{name}} {{#if description}}{{description}}{{/if}}
-type {{name}} struct {
-{{#each intersectionMembers}}
-	{{this}}
-{{/each}}
-}
+// {{name}}{{#if description}} {{description}}{{/if}}
+type {{name}} map[string]interface{}
 
 {{else if isTypeAlias}}
-// {{name}} {{#if description}}{{description}}{{/if}}
-type {{name}} = {{additionalPropertiesType}}
+// {{name}}{{#if description}} {{description}}{{/if}}
+type {{name}} = {{aliasType}}
 
 {{else}}
 {{#if description}}
@@ -71,10 +37,8 @@ type {{name}} = {{additionalPropertiesType}}
 {{/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}}
+	{{pascalCase name}} {{#if optional}}*{{/if}}{{targetType}} `json:"{{name}}{{#if optional}},omitempty{{/if}}"`{{#if description}} // {{description}}{{/if}}
 {{/each}}
 }
-{{/if}}
-
 {{/if}}
 {{/each}}

package/templates/go/utils.hbs

@@ -11,9 +11,10 @@ import (
 // replacements is pairs of (placeholder, value).
 func buildPath(template string, replacements ...string) string {
 	for i := 0; i < len(replacements); i += 2 {
-		placeholder := ":" + replacements[i]
+		name := replacements[i]
 		value := url.PathEscape(replacements[i+1])
-		template = strings.Replace(template, placeholder, value, 1)
+		template = strings.Replace(template, ":"+name, value, 1)
+		template = strings.Replace(template, "${"+name+"}", value, 1)
 	}
 	return template
 }

package/templates/kotlin/build-gradle.hbs

@@ -37,7 +37,7 @@ dependencies {
 }
 
 kotlin {
-    jvmToolchain(25)
+    jvmToolchain(17)
 }
 
 tasks.test {