@apollo-deploy/tesseract 0.9.1 → 1.0.0

package/templates/go/client.hbs

@@ -0,0 +1,158 @@
+package {{pkgName}}
+
+import (
+	"context"
+	"time"
+)
+
+// ── Client Configuration ──────────────────────────────────────────────────
+
+// ClientConfig holds all configuration for the API client.
+type ClientConfig struct {
+	BaseURL        string
+	Timeout        time.Duration
+	MaxRetries     int
+	DefaultHeaders map[string]string
+}
+
+// ClientOption is a functional option for configuring the client.
+type ClientOption func(*ClientConfig)
+
+// WithBaseURL sets the base URL for all API requests.
+func WithBaseURL(url string) ClientOption {
+	return func(c *ClientConfig) { c.BaseURL = url }
+}
+
+// WithTimeout sets the request timeout.
+func WithTimeout(d time.Duration) ClientOption {
+	return func(c *ClientConfig) { c.Timeout = d }
+}
+
+// WithMaxRetries sets the maximum number of retry attempts.
+func WithMaxRetries(n int) ClientOption {
+	return func(c *ClientConfig) { c.MaxRetries = n }
+}
+
+// WithDefaultHeader adds a default header sent with every request.
+func WithDefaultHeader(key, value string) ClientOption {
+	return func(c *ClientConfig) {
+		if c.DefaultHeaders == nil {
+			c.DefaultHeaders = make(map[string]string)
+		}
+		c.DefaultHeaders[key] = value
+	}
+}
+
+// DefaultConfig returns a ClientConfig populated with sensible defaults.
+func DefaultConfig() ClientConfig {
+	return ClientConfig{
+		BaseURL:    "{{baseUrl}}",
+		Timeout:    15 * time.Second,
+		MaxRetries: 3,
+	}
+}
+
+// ── Client ────────────────────────────────────────────────────────────────
+
+// Client is the primary API client for {{title}}.
+// It is safe for concurrent use by multiple goroutines.
+type Client struct {
+	config    ClientConfig
+	transport *Transport
+{{#each groups}}
+	{{pascalCase name}} *{{interfaceName}}
+{{/each}}
+}
+
+// NewClient creates a new {{title}} API client with the given options.
+//
+// Example:
+//
+//	client := petshop.NewClient(
+//	    petshop.WithBaseURL("https://api.example.com"),
+//	    petshop.WithTimeout(30*time.Second),
+//	)
+//	pets, err := client.Pets.List(ctx, nil)
+func NewClient(opts ...ClientOption) *Client {
+	cfg := DefaultConfig()
+	for _, opt := range opts {
+		opt(&cfg)
+	}
+
+	t := NewTransport(TransportConfig{
+		BaseURL:    cfg.BaseURL,
+		Timeout:    cfg.Timeout,
+		MaxRetries: cfg.MaxRetries,
+		Headers:    cfg.DefaultHeaders,
+	})
+
+	return &Client{
+		config:    cfg,
+		transport: t,
+{{#each groups}}
+		{{pascalCase name}}: &{{interfaceName}}{transport: t},
+{{/each}}
+	}
+}
+
+// Transport returns the underlying HTTP transport for advanced use cases.
+func (c *Client) Transport() *Transport {
+	return c.transport
+}
+
+// ── Request / Response types ──────────────────────────────────────────────
+
+// RequestOptions holds per-request overrides.
+type RequestOptions struct {
+	// Timeout overrides the client-level timeout for this request.
+	Timeout time.Duration
+	// Headers are additional headers merged into the request.
+	Headers map[string]string
+}
+
+// ListParams is embedded by list operation parameter types to provide
+// common pagination and filtering fields.
+type ListParams struct {
+	Page  *int    `json:"page,omitempty"`
+	Limit *int    `json:"limit,omitempty"`
+}
+
+// Int returns a pointer to the given int value. Useful for optional
+// parameters in request structs.
+func Int(v int) *int { return &v }
+
+// String returns a pointer to the given string value.
+func String(v string) *string { return &v }
+
+// Bool returns a pointer to the given bool value.
+func Bool(v bool) *bool { return &v }
+
+{{#if hasSSE}}
+// ── SSE Types ─────────────────────────────────────────────────────────────
+
+// SSEEvent represents a parsed Server-Sent Event.
+type SSEEvent struct {
+	Event string
+	Data  string
+	ID    string
+	Retry int
+}
+
+// SSEOption configures an SSE stream subscription.
+type SSEOption func(*sseConfig)
+
+type sseConfig struct {
+	signal    context.Context
+	eventTypes []string
+}
+
+// WithSSESignal sets a context for cancellation of the SSE stream.
+func WithSSESignal(ctx context.Context) SSEOption {
+	return func(c *sseConfig) { c.signal = ctx }
+}
+
+// WithSSEEventTypes filters the stream to specific event types.
+func WithSSEEventTypes(types ...string) SSEOption {
+	return func(c *sseConfig) { c.eventTypes = types }
+}
+{{/if}}

package/templates/go/domain.hbs

@@ -0,0 +1,89 @@
+package {{pkgName}}
+
+import (
+{{#if hasSSE}}
+	"bufio"
+	"strings"
+{{/if}}
+	"context"
+)
+
+// {{interfaceName}} provides access to {{name}} API operations.
+type {{interfaceName}} struct {
+	transport *Transport
+}
+
+{{#each operations}}
+{{#if isEventStream}}
+func (api *{{../interfaceName}}) {{pascalCase name}}Stream(
+	ctx context.Context,
+{{#each pathParams}}
+	{{name}} string,
+{{/each}}
+{{#if queryType}}
+	params {{goQueryType queryType}},
+{{/if}}
+) (<-chan SSEEvent, <-chan error) {
+	eventCh := make(chan SSEEvent)
+	errCh := make(chan error, 1)
+	go func() {
+		defer close(eventCh)
+		defer close(errCh)
+		reqPath := buildPath("{{path}}"{{#each pathParams}}, "{{originalName}}", {{name}}{{/each}})
+		resp, err := api.transport.Stream(ctx, request{Method: "{{httpMethod}}", Path: reqPath})
+		if err != nil { errCh <- err; return }
+		defer resp.Body.Close()
+		scanner := bufio.NewScanner(resp.Body)
+		var current SSEEvent
+		for scanner.Scan() {
+			select {
+			case <-ctx.Done(): errCh <- ctx.Err(); return
+			default:
+			}
+			line := scanner.Text()
+			if line == "" {
+				if current.Data != "" { eventCh <- current; current = SSEEvent{} }
+				continue
+			}
+			if strings.HasPrefix(line, "event:") { current.Event = strings.TrimSpace(line[6:]) }
+			if strings.HasPrefix(line, "data:") { if current.Data != "" { current.Data += "\n" }; current.Data += strings.TrimSpace(line[5:]) }
+			if strings.HasPrefix(line, "id:") { current.ID = strings.TrimSpace(line[3:]) }
+		}
+	}()
+	return eventCh, errCh
+}
+
+{{else}}
+func (api *{{../interfaceName}}) {{pascalCase name}}(
+	ctx context.Context,
+{{#each pathParams}}
+	{{name}} string,
+{{/each}}
+{{#if requestBody}}
+	body *{{requestBody.type}},
+{{/if}}
+{{#if queryType}}
+	params {{goQueryType queryType}},
+{{/if}}
+) {{#if (eq responseType "void")}}error{{else}}(*{{responseType}}, error){{/if}} {
+	reqPath := buildPath("{{path}}"{{#each pathParams}}, "{{originalName}}", {{name}}{{/each}})
+	{{#if queryType}}q := buildQuery(params){{/if}}
+{{#if (eq responseType "void")}}
+	return api.transport.Execute(ctx, request{
+		Method: "{{httpMethod}}", Path: reqPath,
+{{#if queryType}}		Query: q,{{/if}}
+{{#if requestBody}}		Body: body,{{/if}}
+	}, nil)
+{{else}}
+	var result {{responseType}}
+	err := api.transport.Execute(ctx, request{
+		Method: "{{httpMethod}}", Path: reqPath,
+{{#if queryType}}		Query: q,{{/if}}
+{{#if requestBody}}		Body: body,{{/if}}
+	}, &result)
+	if err != nil { return nil, err }
+	return &result, nil
+{{/if}}
+}
+{{/if}}
+{{/each}}

package/templates/go/errors.hbs

@@ -0,0 +1,38 @@
+package {{pkgName}}
+
+import "fmt"
+
+// SDKError represents an error returned by the API.
+type SDKError struct {
+	// Status is the HTTP status code.
+	Status int
+	// Code is a machine-readable error code from the API.
+	Code string
+	// RequestID is the unique identifier for the request (for support).
+	RequestID string
+	// Message is a human-readable error description.
+	Message string
+}
+
+// Error implements the error interface.
+func (e *SDKError) Error() string {
+	if e.Code != "" {
+		return fmt.Sprintf("[%d] %s: %s", e.Status, e.Code, e.Message)
+	}
+	return fmt.Sprintf("[%d] %s", e.Status, e.Message)
+}
+
+// Unwrap returns nil since SDKError is the root cause.
+func (e *SDKError) Unwrap() error {
+	return nil
+}
+
+// NewSDKError creates a new SDKError.
+func NewSDKError(status int, code, message, requestID string) *SDKError {
+	return &SDKError{
+		Status:    status,
+		Code:      code,
+		Message:   message,
+		RequestID: requestID,
+	}
+}

package/templates/go/go-mod.hbs

@@ -0,0 +1,6 @@
+module {{packageName}}
+
+go 1.21
+
+require (
+)

package/templates/go/readme.hbs

@@ -0,0 +1,73 @@
+# {{title}} Go SDK
+
+[![Go Reference](https://pkg.go.dev/badge/{{packageName}}.svg)](https://pkg.go.dev/{{packageName}})
+
+The official Go SDK for {{#if description}}{{description}}{{else}}the {{title}} API{{/if}}.
+
+## Installation
+
+```bash
+go get {{packageName}}
+```
+
+## Quick Start
+
+```go
+package main
+
+import (
+    "context"
+    "fmt"
+    "log"
+
+    "{{packageName}}"
+)
+
+func main() {
+    client := {{pkgName}}.NewClient({{pkgName}}.DefaultClientConfig(){{#each securitySchemes}}{{#if (eq type "apiKey")}}
+        {{pascalCase configKey}}: "your-api-key",{{/if}}{{#if (and (eq type "http") (eq scheme "bearer"))}}
+        {{pascalCase configKey}}: "your-bearer-token",{{/if}}
+{{/each}}
+    )
+
+    ctx := context.Background()
+{{#each groups}}
+{{#with operations.[0]}}
+    // {{../interfaceName}}.{{name}} example
+    result, err := client.{{pascalCase ../name}}.{{pascalCase name}}(ctx{{#each ../pathParams}}, "{{this}}"{{/each}}{{#if requestBody}}, {{requestBody.type}}{}{{/if}})
+    if err != nil {
+        log.Fatal(err)
+    }
+    fmt.Printf("%+v\n", result)
+{{/with}}
+{{/each}}
+}
+```
+
+## API Reference
+
+| Domain | Description |
+|--------|-------------|
+{{#each groups}}
+| `{{interfaceName}}` | {{#if description}}{{description}}{{else}}{{name}} operations{{/if}} |
+{{/each}}
+
+## Error Handling
+
+All methods return an `error` as the second return value. Use `errors.As` to inspect SDK-specific errors:
+
+```go
+var sdkErr *SDKError
+if errors.As(err, &sdkErr) {
+    fmt.Printf("Status: %d, Code: %s, RequestID: %s\n",
+        sdkErr.Status, sdkErr.Code, sdkErr.RequestID)
+}
+```
+
+## Requirements
+
+- Go 1.21 or later
+
+## License
+
+{{#if license}}{{license}}{{else}}MIT{{/if}}