@rivi-software/radiotools-sdk-generator 0.2.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

package/dist/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+#!/usr/bin/env bun
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { generateSdks, listTargets } from "./engine";
+function repoRootFromImportMeta(metaUrl) {
+    const here = dirname(fileURLToPath(metaUrl));
+    return join(here, "..", "..", "..");
+}
+function parseArgs(argv) {
+    const [command = "help", ...rest] = argv;
+    let target = "all";
+    let dryRun = false;
+    for (let i = 0; i < rest.length; i += 1) {
+        const arg = rest[i];
+        if (arg === "--target" && rest[i + 1]) {
+            target = rest[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--dry-run")
+            dryRun = true;
+    }
+    return { command, target, dryRun };
+}
+const { command, target, dryRun } = parseArgs(process.argv.slice(2));
+const repoRoot = repoRootFromImportMeta(import.meta.url);
+switch (command) {
+    case "generate":
+        generateSdks({ repoRoot, target, dryRun });
+        break;
+    case "list":
+        for (const entry of listTargets()) {
+            console.log(`${entry.id}\t${entry.description}`);
+        }
+        break;
+    default:
+        console.log(`Usage:
+  bun src/cli.ts generate [--target <id>|all] [--dry-run]
+  bun src/cli.ts list
+
+Targets: ${listTargets().map((t) => t.id).join(", ")}, all`);
+        break;
+}

package/dist/engine.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateOptions, SdkTarget } from "./types";
+export declare function listTargets(): SdkTarget[];
+export declare function generateSdks(options: GenerateOptions): void;

package/dist/engine.js

@@ -0,0 +1,60 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { csharpTarget } from "./targets/csharp";
+import { goTarget } from "./targets/go";
+import { kotlinTarget } from "./targets/kotlin";
+import { nextTarget } from "./targets/next";
+import { openapiTarget } from "./targets/openapi";
+import { phpTarget } from "./targets/php";
+import { pythonTarget } from "./targets/python";
+import { reactTarget } from "./targets/react";
+import { rubyTarget } from "./targets/ruby";
+import { svelteTarget } from "./targets/svelte";
+import { swiftTarget } from "./targets/swift";
+import { vueTarget } from "./targets/vue";
+const targets = [
+    pythonTarget,
+    reactTarget,
+    vueTarget,
+    svelteTarget,
+    goTarget,
+    csharpTarget,
+    rubyTarget,
+    phpTarget,
+    openapiTarget,
+    kotlinTarget,
+    swiftTarget,
+    nextTarget,
+];
+export function listTargets() {
+    return targets;
+}
+function resolveTargets(target) {
+    if (target === "all")
+        return targets;
+    const match = targets.find((entry) => entry.id === target);
+    if (!match) {
+        throw new Error(`Unknown target "${target}". Available: ${targets.map((t) => t.id).join(", ")}, all`);
+    }
+    return [match];
+}
+function writeGeneratedFile(baseDir, file, dryRun) {
+    const fullPath = isAbsolute(file.path) ? file.path : join(baseDir, file.path);
+    if (dryRun) {
+        console.log(`[dry-run] would write ${fullPath} (${file.contents.length} bytes)`);
+        return;
+    }
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeFileSync(fullPath, file.contents, "utf8");
+    console.log(`wrote ${fullPath}`);
+}
+export function generateSdks(options) {
+    const selected = resolveTargets(options.target);
+    for (const target of selected) {
+        const outDir = target.outputDir(options.repoRoot);
+        const files = target.generate(options.repoRoot);
+        for (const file of files) {
+            writeGeneratedFile(outDir, file, options.dryRun ?? false);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { generateSdks, listTargets } from "./engine";
+export type { GenerateOptions, GeneratedFile, GeneratorTarget, SdkTarget } from "./types";

package/dist/index.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { generateSdks, listTargets } from "./engine";

package/dist/openapi/zod-components.d.ts

@@ -0,0 +1,13 @@
+export type OpenApiComponents = {
+    schemas: Record<string, Record<string, unknown>>;
+};
+/** JSON Schema components generated from `@rivi-software/radiotools-sdk` Zod types (`sdkSchemas`). */
+export declare function buildZodOpenApiComponents(): OpenApiComponents;
+export declare const operationResponseSchemas: Record<string, {
+    schema: string;
+    nullable?: boolean;
+    description: string;
+}>;
+export declare function jsonSchemaRef(componentName: string): {
+    $ref: string;
+};

package/dist/openapi/zod-components.js

@@ -0,0 +1,47 @@
+import { sdkSchemas } from "@rivi-software/radiotools-sdk";
+import { z } from "zod";
+function stripMeta(schema) {
+    const { $schema: _, ...rest } = schema;
+    return rest;
+}
+/** JSON Schema components generated from `@rivi-software/radiotools-sdk` Zod types (`sdkSchemas`). */
+export function buildZodOpenApiComponents() {
+    const schemas = {};
+    for (const [name, zodSchema] of Object.entries(sdkSchemas)) {
+        const json = z.toJSONSchema(zodSchema, {
+            io: "output",
+            reused: "inline",
+            unrepresentable: "any",
+        });
+        schemas[name] = stripMeta(json);
+    }
+    return { schemas };
+}
+export const operationResponseSchemas = {
+    getStation: { schema: "PublicStation", description: "Published station metadata" },
+    getSchemas: { schema: "PublicSchemaList", description: "Content type schemas" },
+    getContent: { schema: "PublishedCollection", description: "Published content page" },
+    getContentRecord: { schema: "PublishedRecord", description: "One published record" },
+    getSchedule: { schema: "PublicSchedule", description: "Broadcast schedule" },
+    getPrograms: { schema: "PublicPrograms", description: "Program summaries" },
+    getCurrentBroadcast: { schema: "PublicCurrentBroadcast", description: "Current broadcast" },
+    getNowPlaying: { schema: "PublicNowPlaying", description: "Now playing" },
+    getTrackHistory: { schema: "PublicTrackHistory", description: "Track history page" },
+    getWeather: {
+        schema: "WeatherPublic",
+        nullable: true,
+        description: "Weather snapshot when enabled",
+    },
+    getTraffic: {
+        schema: "TrafficPublic",
+        nullable: true,
+        description: "Traffic snapshot when enabled",
+    },
+    reportPlayback: {
+        schema: "PlaybackObservationResult",
+        description: "Playback ingest acknowledgement",
+    },
+};
+export function jsonSchemaRef(componentName) {
+    return { $ref: `#/components/schemas/${componentName}` };
+}

package/dist/shared/naming.d.ts

@@ -0,0 +1,2 @@
+export declare function snakeCase(name: string): string;
+export declare function pascalCase(name: string): string;

package/dist/shared/naming.js

@@ -0,0 +1,6 @@
+export function snakeCase(name) {
+    return name.replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
+}
+export function pascalCase(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}

package/dist/shared/reads.d.ts

@@ -0,0 +1,5 @@
+/** Client reads with no required parameters — safe for simple hooks/composables/stores. */
+export declare const ZERO_ARG_READ_METHODS: readonly ["getStation", "getCurrentBroadcast", "getNowPlaying", "getWeather", "getTraffic"];
+export type ZeroArgReadMethod = (typeof ZERO_ARG_READ_METHODS)[number];
+export declare function isZeroArgReadMethod(name: string): name is ZeroArgReadMethod;
+export declare function hookNameFromMethod(method: ZeroArgReadMethod): string;

package/dist/shared/reads.js

@@ -0,0 +1,14 @@
+/** Client reads with no required parameters — safe for simple hooks/composables/stores. */
+export const ZERO_ARG_READ_METHODS = [
+    "getStation",
+    "getCurrentBroadcast",
+    "getNowPlaying",
+    "getWeather",
+    "getTraffic",
+];
+export function isZeroArgReadMethod(name) {
+    return ZERO_ARG_READ_METHODS.includes(name);
+}
+export function hookNameFromMethod(method) {
+    return `use${method.charAt(0).toUpperCase()}${method.slice(1)}`;
+}

package/dist/targets/csharp.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const csharpTarget: SdkTarget;

package/dist/targets/csharp.js

@@ -0,0 +1,137 @@
+import { listenerSdkManifest } from "@rivi-software/radiotools-contract";
+function renderCsharpClient() {
+    const playbackPath = listenerSdkManifest.integrations.playback.path;
+    return `// Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand.
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Text.Json;
+
+namespace RadioTools.Sdk;
+
+public sealed class StationClient : IDisposable
+{
+    private readonly HttpClient _http;
+    private readonly string _baseUrl;
+    private readonly string _stationSlug;
+    private readonly string? _apiToken;
+    private readonly string? _ingestToken;
+
+    public StationClient(string baseUrl, string stationSlug, string? apiToken = null, string? ingestToken = null, HttpClient? http = null)
+    {
+        if (string.IsNullOrWhiteSpace(apiToken) && string.IsNullOrWhiteSpace(ingestToken))
+            throw new ArgumentException("apiToken or ingestToken is required");
+        _baseUrl = baseUrl.TrimEnd('/');
+        _stationSlug = stationSlug;
+        _apiToken = apiToken;
+        _ingestToken = ingestToken;
+        _http = http ?? new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
+    }
+
+    public static StationClient FromEnvironment()
+    {
+        var baseUrl = Environment.GetEnvironmentVariable("RADIOTOOLS_BASE_URL") ?? "";
+        var slug = Environment.GetEnvironmentVariable("RADIOTOOLS_STATION_SLUG") ?? "";
+        var api = Environment.GetEnvironmentVariable("RADIOTOOLS_API_TOKEN");
+        var ingest = Environment.GetEnvironmentVariable("RADIOTOOLS_INGEST_TOKEN");
+        if (string.IsNullOrWhiteSpace(baseUrl) || string.IsNullOrWhiteSpace(slug))
+            throw new InvalidOperationException("Set RADIOTOOLS_BASE_URL and RADIOTOOLS_STATION_SLUG");
+        return new StationClient(baseUrl, slug, api, ingest);
+    }
+
+    public async Task<JsonElement> GetStationAsync(CancellationToken cancellationToken = default)
+    {
+        var path = $"/api/v1/stations/{Uri.EscapeDataString(_stationSlug)}";
+        return await GetJsonAsync(path, ingest: false, cancellationToken);
+    }
+
+    public async Task<JsonElement?> GetWeatherAsync(CancellationToken cancellationToken = default)
+    {
+        var station = await GetStationAsync(cancellationToken);
+        if (!station.TryGetProperty("resources", out var resources)) return null;
+        if (!resources.TryGetProperty("weather", out var hrefProp)) return null;
+        var href = hrefProp.GetString();
+        if (string.IsNullOrEmpty(href)) return null;
+        return await GetJsonAsync(href, ingest: false, cancellationToken);
+    }
+
+    public async Task<JsonElement?> GetTrafficAsync(CancellationToken cancellationToken = default)
+    {
+        var station = await GetStationAsync(cancellationToken);
+        if (!station.TryGetProperty("resources", out var resources)) return null;
+        if (!resources.TryGetProperty("traffic", out var hrefProp)) return null;
+        var href = hrefProp.GetString();
+        if (string.IsNullOrEmpty(href)) return null;
+        return await GetJsonAsync(href, ingest: false, cancellationToken);
+    }
+
+    public async Task<JsonElement> ReportPlaybackAsync(object observation, string? stationId = null, CancellationToken cancellationToken = default)
+    {
+        var query = stationId is not null
+            ? $"?stationId={Uri.EscapeDataString(stationId)}"
+            : $"?stationSlug={Uri.EscapeDataString(_stationSlug)}";
+        var url = $"{_baseUrl}${playbackPath}{query}";
+        using var request = new HttpRequestMessage(HttpMethod.Post, url)
+        {
+            Content = JsonContent.Create(observation),
+        };
+        ApplyAuth(request, ingest: true);
+        using var response = await _http.SendAsync(request, cancellationToken);
+        response.EnsureSuccessStatusCode();
+        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+        return await JsonSerializer.DeserializeAsync<JsonElement>(stream, cancellationToken: cancellationToken)
+            ?? throw new InvalidOperationException("empty playback response");
+    }
+
+    private async Task<JsonElement> GetJsonAsync(string path, bool ingest, CancellationToken cancellationToken)
+    {
+        var url = path.StartsWith("http", StringComparison.OrdinalIgnoreCase) ? path : $"{_baseUrl}{path}";
+        using var request = new HttpRequestMessage(HttpMethod.Get, url);
+        ApplyAuth(request, ingest);
+        using var response = await _http.SendAsync(request, cancellationToken);
+        response.EnsureSuccessStatusCode();
+        await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+        return await JsonSerializer.DeserializeAsync<JsonElement>(stream, cancellationToken: cancellationToken)
+            ?? throw new InvalidOperationException("empty JSON response");
+    }
+
+    private void ApplyAuth(HttpRequestMessage request, bool ingest)
+    {
+        var token = ingest ? _ingestToken : _apiToken;
+        if (string.IsNullOrWhiteSpace(token))
+            throw new InvalidOperationException("Missing bearer token");
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
+    }
+
+    public void Dispose() => _http.Dispose();
+}
+`;
+}
+export const csharpTarget = {
+    id: "csharp",
+    description: ".NET HttpClient stubs (packages/sdk-dotnet)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-dotnet/src`,
+    generate: () => [
+        { path: "StationClient.cs", contents: renderCsharpClient() },
+        {
+            path: "../RadioTools.Sdk.csproj",
+            contents: `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <RootNamespace>RadioTools.Sdk</RootNamespace>
+    <AssemblyName>RadioTools.Sdk</AssemblyName>
+    <Version>0.2.0</Version>
+  </PropertyGroup>
+</Project>
+`,
+        },
+        {
+            path: "../README.md",
+            contents: `# RadioTools.Sdk (.NET)
+
+Generated listener REST stubs. Regenerate with \`bun run --filter @rivi-software/radiotools-sdk-generator generate --target csharp\`.
+`,
+        },
+    ],
+};

package/dist/targets/go.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const goTarget: SdkTarget;

package/dist/targets/go.js

@@ -0,0 +1,185 @@
+import { listenerSdkManifest } from "@rivi-software/radiotools-contract";
+function renderGoClient() {
+    const manifest = listenerSdkManifest;
+    return `// Generated by @rivi-software/radiotools-sdk-generator — do not edit by hand.
+package radiotools
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+)
+
+type StationClient struct {
+	BaseURL     string
+	StationSlug string
+	APIToken    string
+	IngestToken string
+	HTTPClient  *http.Client
+}
+
+func NewStationClient(baseURL, stationSlug, apiToken, ingestToken string) (*StationClient, error) {
+	if apiToken == "" && ingestToken == "" {
+		return nil, fmt.Errorf("apiToken or ingestToken is required")
+	}
+	return &StationClient{
+		BaseURL:     strings.TrimRight(baseURL, "/"),
+		StationSlug: stationSlug,
+		APIToken:    apiToken,
+		IngestToken: ingestToken,
+		HTTPClient:  &http.Client{Timeout: 30 * time.Second},
+	}, nil
+}
+
+func StationClientFromEnv() (*StationClient, error) {
+	baseURL := strings.TrimSpace(os.Getenv("RADIOTOOLS_BASE_URL"))
+	slug := strings.TrimSpace(os.Getenv("RADIOTOOLS_STATION_SLUG"))
+	apiToken := strings.TrimSpace(os.Getenv("RADIOTOOLS_API_TOKEN"))
+	ingestToken := strings.TrimSpace(os.Getenv("RADIOTOOLS_INGEST_TOKEN"))
+	if baseURL == "" || slug == "" {
+		return nil, fmt.Errorf("set RADIOTOOLS_BASE_URL and RADIOTOOLS_STATION_SLUG")
+	}
+	return NewStationClient(baseURL, slug, apiToken, ingestToken)
+}
+
+func (c *StationClient) getJSON(ctx context.Context, path string, ingest bool) (map[string]any, error) {
+	target := path
+	if !strings.HasPrefix(path, "http") {
+		target = c.BaseURL + path
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, target, nil)
+	if err != nil {
+		return nil, err
+	}
+	token := c.APIToken
+	if ingest {
+		token = c.IngestToken
+	}
+	if token == "" {
+		return nil, fmt.Errorf("missing bearer token")
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	res, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode >= 400 {
+		body, _ := io.ReadAll(res.Body)
+		return nil, fmt.Errorf("GET %s: %s (%s)", target, res.Status, strings.TrimSpace(string(body)))
+	}
+	var payload map[string]any
+	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {
+		return nil, err
+	}
+	return payload, nil
+}
+
+func (c *StationClient) GetStation(ctx context.Context) (map[string]any, error) {
+	path := fmt.Sprintf("/api/v1/stations/%s", url.PathEscape(c.StationSlug))
+	return c.getJSON(ctx, path, false)
+}
+
+func (c *StationClient) GetWeather(ctx context.Context) (map[string]any, error) {
+	station, err := c.GetStation(ctx)
+	if err != nil {
+		return nil, err
+	}
+	resources, _ := station["resources"].(map[string]any)
+	if resources == nil {
+		return nil, nil
+	}
+	href, _ := resources["weather"].(string)
+	if href == "" {
+		return nil, nil
+	}
+	return c.getJSON(ctx, href, false)
+}
+
+func (c *StationClient) GetTraffic(ctx context.Context) (map[string]any, error) {
+	station, err := c.GetStation(ctx)
+	if err != nil {
+		return nil, err
+	}
+	resources, _ := station["resources"].(map[string]any)
+	if resources == nil {
+		return nil, nil
+	}
+	href, _ := resources["traffic"].(string)
+	if href == "" {
+		return nil, nil
+	}
+	return c.getJSON(ctx, href, false)
+}
+
+func (c *StationClient) ReportPlayback(ctx context.Context, observation map[string]any, stationID string) (map[string]any, error) {
+	q := url.Values{}
+	if stationID != "" {
+		q.Set("stationId", stationID)
+	} else {
+		q.Set("stationSlug", c.StationSlug)
+	}
+	target := c.BaseURL + "${manifest.integrations.playback.path}?" + q.Encode()
+	body, err := json.Marshal(observation)
+	if err != nil {
+		return nil, err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, target, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+	if c.IngestToken == "" {
+		return nil, fmt.Errorf("ingest token required")
+	}
+	req.Header.Set("Authorization", "Bearer "+c.IngestToken)
+	req.Header.Set("Content-Type", "application/json")
+	res, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode >= 400 {
+		raw, _ := io.ReadAll(res.Body)
+		return nil, fmt.Errorf("POST playback: %s (%s)", res.Status, strings.TrimSpace(string(raw)))
+	}
+	var payload map[string]any
+	if err := json.NewDecoder(res.Body).Decode(&payload); err != nil {
+		return nil, err
+	}
+	return payload, nil
+}
+`;
+}
+export const goTarget = {
+    id: "go",
+    description: "Go net/http client stubs (packages/sdk-go)",
+    outputDir: (repoRoot) => `${repoRoot}/packages/sdk-go/radiotools`,
+    generate: () => [
+        { path: "client.go", contents: renderGoClient() },
+        {
+            path: "../go.mod",
+            contents: `module github.com/radiotools/radiotools-sdk-go
+
+go 1.22
+`,
+        },
+        {
+            path: "../README.md",
+            contents: `# radiotools-sdk-go
+
+Generated Go client stubs for RadioTools listener contract v${listenerSdkManifest.contractVersion}.
+
+Regenerate: \`bun run --filter @rivi-software/radiotools-sdk-generator generate --target go\`
+
+For GraphQL, WebSocket, and ETag behavior use \`@rivi-software/radiotools-sdk\` (TypeScript).
+`,
+        },
+    ],
+};

package/dist/targets/kotlin.d.ts

@@ -0,0 +1,2 @@
+import type { SdkTarget } from "../types";
+export declare const kotlinTarget: SdkTarget;