@apollo-deploy/tesseract 0.9.1 → 1.0.0

package/templates/csharp/domain.hbs

@@ -0,0 +1,183 @@
+namespace {{namespace}}.Api;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+/// <summary>
+/// Provides access to {{name}} API operations.
+/// </summary>
+public class {{interfaceName}}
+{
+    private readonly Transport _transport;
+
+    /// <summary>
+    /// Creates a new {{interfaceName}} instance.
+    /// </summary>
+    public {{interfaceName}}(Transport transport)
+    {
+        _transport = transport;
+    }
+
+{{#each operations}}
+{{#if isEventStream}}
+    /// <summary>
+    {{#if summary}}
+    /// {{summary}}
+    {{/if}}
+    {{#if description}}
+    /// {{description}}
+    {{/if}}
+    {{#if deprecated}}
+    /// [Obsolete] {{#if deprecationMessage}}{{deprecationMessage}}{{/if}}
+    {{/if}}
+    /// </summary>
+{{#if deprecated}}
+    [Obsolete({{#if deprecationMessage}}"{{deprecationMessage}}"{{/if}})]
+{{/if}}
+    public async IAsyncEnumerable<string> {{pascalCase name}}Async(
+{{#each pathParams}}
+        {{type}}{{#if (not required)}}?{{/if}} {{name}},
+{{/each}}
+{{#if requestBody}}
+        {{requestBody.type}}{{#if (not requestBody.required)}}?{{/if}} body,
+{{/if}}
+{{#if queryType}}
+        {{queryType}}? query = null,
+{{/if}}
+        CancellationToken cancellationToken = default)
+    {
+        var path = $"{{path}}"
+{{#each pathParams}}
+            .Replace("{{{originalName}}}", Uri.EscapeDataString({{name}}?.ToString() ?? ""))
+{{/each}}
+        ;
+
+        var queryParams = new Dictionary<string, string>();
+{{#if queryType}}
+        if (query != null)
+        {
+            var json = JsonSerializer.Serialize(query);
+            var dict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
+            if (dict != null)
+            {
+                foreach (var (key, value) in dict)
+                {
+                    if (value.ValueKind != JsonValueKind.Null)
+                        queryParams[key] = value.ToString();
+                }
+            }
+        }
+{{/if}}
+{{#if (hasQueryParams this)}}
+{{#each queryParams}}
+        if ({{name}} != null)
+            queryParams["{{originalName}}"] = {{name}}.ToString();
+{{/each}}
+{{/if}}
+
+        var response = await _transport.StreamAsync(
+            new Transport.Request
+            {
+                Method = HttpMethod.{{httpMethod}},
+                Path = path,
+                Query = queryParams.Count > 0 ? queryParams : null,
+{{#if requestBody}}
+                Body = body,
+                ContentType = "{{requestBody.contentType}}",
+{{/if}}
+            },
+            cancellationToken);
+
+        using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+        using var reader = new StreamReader(stream);
+
+        while (!reader.EndOfStream)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var line = await reader.ReadLineAsync(cancellationToken);
+            if (line == null) break;
+
+            // Forward raw SSE lines
+            yield return line;
+        }
+    }
+
+{{else}}
+    /// <summary>
+    {{#if summary}}
+    /// {{summary}}
+    {{/if}}
+    {{#if description}}
+    /// {{description}}
+    {{/if}}
+    {{#if deprecated}}
+    /// [Obsolete] {{#if deprecationMessage}}{{deprecationMessage}}{{/if}}
+    {{/if}}
+    /// </summary>
+{{#if deprecated}}
+    [Obsolete({{#if deprecationMessage}}"{{deprecationMessage}}"{{/if}})]
+{{/if}}
+    public async Task<{{#if responseType}}{{responseType}}{{else}}object{{/if}}> {{pascalCase name}}Async(
+{{#each pathParams}}
+        {{type}}{{#if (not required)}}?{{/if}} {{name}},
+{{/each}}
+{{#if requestBody}}
+        {{requestBody.type}}{{#if (not requestBody.required)}}?{{/if}} body,
+{{/if}}
+{{#if queryType}}
+        {{queryType}}? query = null,
+{{/if}}
+        CancellationToken cancellationToken = default)
+    {
+        var path = $"{{path}}"
+{{#each pathParams}}
+            .Replace("{{{originalName}}}", Uri.EscapeDataString({{name}}?.ToString() ?? ""))
+{{/each}}
+        ;
+
+        var queryParams = new Dictionary<string, string>();
+{{#if queryType}}
+        if (query != null)
+        {
+            var json = JsonSerializer.Serialize(query);
+            var dict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(json);
+            if (dict != null)
+            {
+                foreach (var (key, value) in dict)
+                {
+                    if (value.ValueKind != JsonValueKind.Null)
+                        queryParams[key] = value.ToString();
+                }
+            }
+        }
+{{/if}}
+{{#if (hasQueryParams this)}}
+{{#each queryParams}}
+        if ({{name}} != null)
+            queryParams["{{originalName}}"] = {{name}}.ToString();
+{{/each}}
+{{/if}}
+
+        return await _transport.ExecuteAsync<{{#if responseType}}{{responseType}}{{else}}object{{/if}}>(
+            new Transport.Request
+            {
+                Method = HttpMethod.{{httpMethod}},
+                Path = path,
+                Query = queryParams.Count > 0 ? queryParams : null,
+{{#if requestBody}}
+                Body = body,
+                ContentType = "{{requestBody.contentType}}",
+{{/if}}
+            },
+            cancellationToken);
+    }
+
+{{/if}}
+{{/each}}
+}

package/templates/csharp/errors.hbs

@@ -0,0 +1,45 @@
+namespace {{namespace}};
+
+using System;
+
+/// <summary>
+/// Represents an error returned by the API.
+/// </summary>
+public class SdkException : Exception
+{
+    /// <summary>
+    /// HTTP status code.
+    /// </summary>
+    public int Status { get; }
+
+    /// <summary>
+    /// Machine-readable error code from the API.
+    /// </summary>
+    public string? Code { get; }
+
+    /// <summary>
+    /// Unique request identifier for support.
+    /// </summary>
+    public string? RequestId { get; }
+
+    /// <summary>
+    /// Creates a new SdkException.
+    /// </summary>
+    public SdkException(int status, string? code, string message, string? requestId, Exception? innerException = null)
+        : base(message, innerException)
+    {
+        Status = status;
+        Code = code;
+        RequestId = requestId;
+    }
+
+    /// <summary>
+    /// Returns a string representation of the error.
+    /// </summary>
+    public override string ToString()
+    {
+        if (!string.IsNullOrEmpty(Code))
+            return $"[{Status}] {Code}: {Message}";
+        return $"[{Status}] {Message}";
+    }
+}

package/templates/csharp/readme.hbs

@@ -0,0 +1,76 @@
+# {{title}} .NET SDK
+
+[![NuGet](https://img.shields.io/nuget/v/{{packageName}}.svg)](https://www.nuget.org/packages/{{packageName}}/)
+
+The official .NET SDK for {{#if description}}{{description}}{{else}}the {{title}} API{{/if}}.
+
+## Installation
+
+```bash
+dotnet add package {{packageName}}
+```
+
+## Quick Start
+
+```csharp
+using {{namespace}};
+
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+var config = new {{../clientName}}ClientConfig
+{
+    {{pascalCase configKey}} = "your-api-key"{{#if (and (eq type "apiKey") (eq in "header"))}}{{/if}}
+};
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+var config = new {{../clientName}}ClientConfig
+{
+    {{pascalCase configKey}} = "your-bearer-token"
+};
+{{/if}}
+{{/each}}
+{{#unless securitySchemes.length}}
+var config = new {{clientName}}ClientConfig();
+{{/unless}}
+
+var client = new {{clientName}}Client(config);
+
+{{#each groups}}
+{{#with operations.[0]}}
+// {{../interfaceName}}.{{pascalCase name}} example
+var result = await client.{{pascalCase ../name}}.{{pascalCase name}}Async({{#each ../pathParams}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}{{#if requestBody}}{{#if ../pathParams.length}}, {{/if}}new {{requestBody.type}}(){}{{/if}});
+Console.WriteLine(result);
+{{/with}}
+{{/each}}
+```
+
+## API Reference
+
+| Domain | Description |
+|--------|-------------|
+{{#each groups}}
+| `{{interfaceName}}` | {{#if description}}{{description}}{{else}}{{name}} operations{{/if}} |
+{{/each}}
+
+## Error Handling
+
+All async methods throw `SdkException` on API errors. Use try-catch to handle errors:
+
+```csharp
+try
+{
+    var result = await client.{{#each groups}}{{#if @first}}{{pascalCase name}}{{/if}}{{/each}}.{{#each groups}}{{#if @first}}{{#with operations.[0]}}{{pascalCase name}}Async(){{/with}}{{/if}}{{/each}};
+}
+catch (SdkException ex)
+{
+    Console.WriteLine($"Status: {ex.Status}, Code: {ex.Code}, RequestId: {ex.RequestId}");
+}
+```
+
+## Requirements
+
+- .NET 8.0 or later
+
+## License
+
+{{#if license}}{{license}}{{else}}MIT{{/if}}

package/templates/csharp/transport.hbs

@@ -0,0 +1,291 @@
+namespace {{namespace}};
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+/// <summary>
+/// Configuration for the HTTP transport layer.
+/// </summary>
+public class TransportConfig
+{
+    public string BaseUrl { get; set; } = "";
+{{#each securitySchemes}}
+    public string? {{pascalCase configKey}} { get; set; }
+{{/each}}
+    public int TimeoutMs { get; set; } = 15000;
+    public int MaxRetries { get; set; } = 3;
+    public Dictionary<string, string>? DefaultHeaders { get; set; }
+}
+
+/// <summary>
+/// Low-level HTTP transport handling authentication, serialization, retries, and error normalization.
+/// </summary>
+public class Transport
+{
+    private readonly TransportConfig _config;
+    private readonly HttpClient _httpClient;
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,
+    };
+
+    public Transport(TransportConfig config)
+    {
+        _config = config;
+        _httpClient = new HttpClient
+        {
+            Timeout = TimeSpan.FromMilliseconds(config.TimeoutMs),
+        };
+    }
+
+    public class Request
+    {
+        public HttpMethod Method { get; set; } = HttpMethod.Get;
+        public string Path { get; set; } = "";
+        public Dictionary<string, string>? Query { get; set; }
+        public object? Body { get; set; }
+        public string? ContentType { get; set; }
+        public Dictionary<string, string>? Headers { get; set; }
+    }
+
+    public async Task<T> ExecuteAsync<T>(Request request, CancellationToken cancellationToken = default)
+    {
+        return await ExecuteWithRetriesAsync<T>(request, _config.MaxRetries, cancellationToken);
+    }
+
+    public async Task<byte[]> ExecuteRawAsync(Request request, CancellationToken cancellationToken = default)
+    {
+        return await ExecuteRawWithRetriesAsync(request, _config.MaxRetries, cancellationToken);
+    }
+
+    public async Task<HttpResponseMessage> StreamAsync(Request request, CancellationToken cancellationToken = default)
+    {
+        using var httpRequest = BuildRequest(request);
+        var response = await _httpClient.SendAsync(
+            httpRequest,
+            HttpCompletionOption.ResponseHeadersRead,
+            cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            var errorBody = await response.Content.ReadAsStringAsync(cancellationToken);
+            throw ParseErrorResponse(response, errorBody);
+        }
+        return response;
+    }
+
+    private async Task<T> ExecuteWithRetriesAsync<T>(
+        Request request, int maxRetries, CancellationToken cancellationToken)
+    {
+        Exception? lastException = null;
+        for (int attempt = 0; attempt <= maxRetries; attempt++)
+        {
+            if (attempt > 0)
+            {
+                var backoff = (int)Math.Pow(2, attempt - 1) * 200;
+                var jitter = Random.Shared.Next(backoff / 2);
+                await Task.Delay(backoff + jitter, cancellationToken);
+            }
+            try
+            {
+                using var httpRequest = BuildRequest(request);
+                using var response = await _httpClient.SendAsync(httpRequest, cancellationToken);
+                var body = await response.Content.ReadAsStringAsync(cancellationToken);
+                if (response.IsSuccessStatusCode)
+                {
+                    if (string.IsNullOrEmpty(body)) return default!;
+                    var result = JsonSerializer.Deserialize<T>(body, _jsonOptions);
+                    if (result == null)
+                        throw new SdkException((int)response.StatusCode, "DESERIALIZE_ERROR",
+                            "Failed to deserialize response body", GetRequestId(response));
+                    return result;
+                }
+                if ((int)response.StatusCode >= 500 && attempt < maxRetries)
+                {
+                    lastException = ParseErrorResponse(response, body);
+                    continue;
+                }
+                throw ParseErrorResponse(response, body);
+            }
+            catch (SdkException) { throw; }
+            catch (TaskCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+            catch (Exception ex) when (IsRetryable(ex) && attempt < maxRetries) { lastException = ex; }
+            catch (Exception ex)
+            {
+                throw new SdkException(0, "REQUEST_ERROR", ex.Message, null, ex);
+            }
+        }
+        throw new SdkException(0, "MAX_RETRIES_EXCEEDED",
+            "Request failed after " + (maxRetries + 1) + " attempts", null, lastException);
+    }
+
+    private async Task<byte[]> ExecuteRawWithRetriesAsync(
+        Request request, int maxRetries, CancellationToken cancellationToken)
+    {
+        Exception? lastException = null;
+        for (int attempt = 0; attempt <= maxRetries; attempt++)
+        {
+            if (attempt > 0)
+            {
+                var backoff = (int)Math.Pow(2, attempt - 1) * 200;
+                var jitter = Random.Shared.Next(backoff / 2);
+                await Task.Delay(backoff + jitter, cancellationToken);
+            }
+            try
+            {
+                using var httpRequest = BuildRequest(request);
+                using var response = await _httpClient.SendAsync(httpRequest, cancellationToken);
+                var body = await response.Content.ReadAsByteArrayAsync(cancellationToken);
+                if (response.IsSuccessStatusCode) return body;
+                var bodyString = Encoding.UTF8.GetString(body);
+                if ((int)response.StatusCode >= 500 && attempt < maxRetries)
+                {
+                    lastException = ParseErrorResponse(response, bodyString);
+                    continue;
+                }
+                throw ParseErrorResponse(response, bodyString);
+            }
+            catch (SdkException) { throw; }
+            catch (TaskCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested) { throw; }
+            catch (Exception ex) when (IsRetryable(ex) && attempt < maxRetries) { lastException = ex; }
+            catch (Exception ex)
+            {
+                throw new SdkException(0, "REQUEST_ERROR", ex.Message, null, ex);
+            }
+        }
+        throw new SdkException(0, "MAX_RETRIES_EXCEEDED",
+            "Request failed after " + (maxRetries + 1) + " attempts", null, lastException);
+    }
+
+    private HttpRequestMessage BuildRequest(Request request)
+    {
+        var baseUri = new Uri(_config.BaseUrl.TrimEnd('/') + "/");
+        var fullUri = new Uri(baseUri, request.Path.TrimStart('/'));
+
+        if (request.Query?.Count > 0)
+        {
+            var queryString = string.Join("&",
+                request.Query.Select(kv =>
+                    Uri.EscapeDataString(kv.Key) + "=" + Uri.EscapeDataString(kv.Value)));
+            var separator = fullUri.Query.Length > 0 ? "&" : "";
+            fullUri = new Uri(fullUri, fullUri.PathAndQuery + separator + queryString);
+        }
+
+        var httpRequest = new HttpRequestMessage(request.Method, fullUri);
+
+        if (_config.DefaultHeaders != null)
+        {
+            foreach (var (key, value) in _config.DefaultHeaders)
+            {
+                httpRequest.Headers.TryAddWithoutValidation(key, value);
+            }
+        }
+
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+{{#if (eq in "header")}}
+        if (!string.IsNullOrEmpty(_config.{{pascalCase configKey}}))
+            httpRequest.Headers.TryAddWithoutValidation("{{paramName}}", _config.{{pascalCase configKey}});
+{{/if}}
+{{#if (eq in "query")}}
+        if (!string.IsNullOrEmpty(_config.{{pascalCase configKey}}))
+        {
+            var sep = fullUri.Query.Length > 0 ? "&" : "";
+            fullUri = new Uri(fullUri, fullUri.PathAndQuery + sep + "{{paramName}}=" + Uri.EscapeDataString(_config.{{pascalCase configKey}}));
+            httpRequest.RequestUri = fullUri;
+        }
+{{/if}}
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+        if (!string.IsNullOrEmpty(_config.{{pascalCase configKey}}))
+            httpRequest.Headers.TryAddWithoutValidation("Authorization", "Bearer " + _config.{{pascalCase configKey}});
+{{/if}}
+{{#if (eq type "oauth2")}}
+        if (!string.IsNullOrEmpty(_config.{{pascalCase configKey}}))
+            httpRequest.Headers.TryAddWithoutValidation("Authorization", "Bearer " + _config.{{pascalCase configKey}});
+{{/if}}
+{{#if (eq type "openIdConnect")}}
+        if (!string.IsNullOrEmpty(_config.{{pascalCase configKey}}))
+            httpRequest.Headers.TryAddWithoutValidation("Authorization", "Bearer " + _config.{{pascalCase configKey}});
+{{/if}}
+{{/each}}
+
+        if (request.Body != null)
+        {
+            var contentType = request.ContentType ?? "application/json";
+            var json = JsonSerializer.Serialize(request.Body, _jsonOptions);
+            httpRequest.Content = new StringContent(json, Encoding.UTF8, contentType);
+        }
+
+        if (request.Headers != null)
+        {
+            foreach (var (key, value) in request.Headers)
+            {
+                if (key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase) && httpRequest.Content != null)
+                {
+                    httpRequest.Content.Headers.ContentType =
+                        new System.Net.Http.Headers.MediaTypeHeaderValue(value);
+                }
+                else
+                {
+                    httpRequest.Headers.TryAddWithoutValidation(key, value);
+                }
+            }
+        }
+
+        return httpRequest;
+    }
+
+    private static bool IsRetryable(Exception ex)
+    {
+        return ex is HttpRequestException ||
+               ex is TaskCanceledException ||
+               ex is IOException ||
+               ex.Message.Contains("connection") ||
+               ex.Message.Contains("timeout") ||
+               ex.Message.Contains("reset");
+    }
+
+    private static SdkException ParseErrorResponse(HttpResponseMessage response, string body)
+    {
+        var requestId = GetRequestId(response);
+        try
+        {
+            using var doc = JsonDocument.Parse(body);
+            var root = doc.RootElement;
+            var code = "";
+            var message = "";
+            if (root.TryGetProperty("code", out var codeEl)) code = codeEl.GetString() ?? "";
+            if (root.TryGetProperty("message", out var msgEl)) message = msgEl.GetString() ?? "";
+            else if (root.TryGetProperty("error", out var errEl)) message = errEl.GetString() ?? "";
+            if (string.IsNullOrEmpty(message)) message = body.Trim();
+            return new SdkException((int)response.StatusCode, code, message, requestId);
+        }
+        catch (JsonException)
+        {
+            return new SdkException((int)response.StatusCode, "",
+                string.IsNullOrWhiteSpace(body)
+                    ? "HTTP " + (int)response.StatusCode + ": " + response.ReasonPhrase
+                    : body.Trim(), requestId);
+        }
+    }
+
+    private static string? GetRequestId(HttpResponseMessage response)
+    {
+        if (response.Headers.TryGetValues("X-Request-ID", out var values))
+            return values.FirstOrDefault();
+        if (response.Headers.TryGetValues("x-request-id", out values))
+            return values.FirstOrDefault();
+        return null;
+    }
+}

package/templates/csharp/types.hbs

@@ -0,0 +1,104 @@
+namespace {{namespace}};
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+{{#each schemas}}
+{{#if (neq ownership.kind "external")}}
+{{#if isEnum}}
+/// <summary>
+{{#if description}}
+/// {{description}}
+{{else}}
+/// {{name}} enumeration.
+{{/if}}
+/// </summary>
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum {{name}}
+{
+{{#each enumValues}}
+    /// <summary>
+    /// {{this}} value.
+    /// </summary>
+    [JsonStringEnumMemberName("{{this}}")]
+    {{pascalCase ../name}}{{pascalCase this}},
+{{/each}}
+}
+
+{{else if isUnionType}}
+/// <summary>
+{{#if description}}
+/// {{description}}
+{{else}}
+/// {{name}} union type.
+{{/if}}
+/// </summary>
+public class {{name}}
+{
+    private readonly object _value;
+    private readonly Type _type;
+
+{{#each unionMembers}}
+    /// <summary>
+    /// Creates a {{../name}} from a {{this}} value.
+    /// </summary>
+    public {{../name}}({{this}} value)
+    {
+        _value = value!;
+        _type = typeof({{this}});
+    }
+
+{{/each}}
+
+    /// <summary>
+    /// Gets the underlying value.
+    /// </summary>
+    public object Value => _value;
+
+    /// <summary>
+    /// Attempts to get the value as the specified type.
+    /// </summary>
+    public bool TryGet<T>(out T? value)
+    {
+        if (_value is T v)
+        {
+            value = v;
+            return true;
+        }
+        value = default;
+        return false;
+    }
+}
+
+{{else}}
+/// <summary>
+{{#if description}}
+/// {{description}}
+{{else}}
+/// {{name}} schema type.
+{{/if}}
+/// </summary>
+public class {{name}}
+{
+{{#each properties}}
+    /// <summary>
+    {{#if description}}
+    /// {{description}}
+    {{/if}}
+    /// </summary>
+    [JsonPropertyName("{{name}}")]
+    {{#if (or nullable (not required))}}
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    {{/if}}
+    {{#if deprecated}}
+    [Obsolete]
+    {{/if}}
+    public {{#if (eq type "string")}}{{#if (eq format "date-time")}}DateTime{{else}}string{{/if}}{{else if (eq type "integer")}}int{{else if (eq type "number")}}double{{else if (eq type "boolean")}}bool{{else if (eq type "array")}}List<object>?{{else}}{{type}}{{/if}}{{#if (or nullable (not required))}}?{{/if}} {{pascalCase name}} { get; set; }
+{{/each}}
+}
+{{/if}}
+
+{{/if}}
+{{/each}}