specli 0.0.20 → 0.0.22

package/dist/cli/runtime/request.test.js

@@ -1,332 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { tmpdir } from "node:os";
-import { generateBodyFlags } from "./body-flags.js";
-import { buildRequest } from "./request.js";
-import { createAjv, formatAjvErrors } from "./validate/index.js";
-function makeAction(partial) {
-    return {
-        id: "test",
-        key: "POST /contacts",
-        action: "create",
-        pathArgs: [],
-        method: "POST",
-        path: "/contacts",
-        tags: [],
-        style: "rest",
-        positionals: [],
-        flags: [],
-        params: [],
-        auth: { alternatives: [] },
-        requestBody: {
-            required: true,
-            content: [
-                {
-                    contentType: "application/json",
-                    required: true,
-                    schemaType: "object",
-                },
-            ],
-            hasJson: true,
-            hasFormUrlEncoded: false,
-            hasMultipart: false,
-            bodyFlags: ["--data", "--file"],
-            preferredContentType: "application/json",
-            preferredSchema: undefined,
-        },
-        requestBodySchema: {
-            type: "object",
-            properties: {
-                name: { type: "string" },
-            },
-            required: ["name"],
-        },
-        ...partial,
-    };
-}
-describe("buildRequest (requestBody)", () => {
-    test("builds body from expanded body flags", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = makeAction();
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            const { request, curl } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { name: "A" }, // --name A
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            });
-            expect(request.headers.get("Content-Type")).toBe("application/json");
-            expect(await request.clone().text()).toBe('{"name":"A"}');
-            expect(curl).toContain("--data");
-            expect(curl).toContain('{"name":"A"}');
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("throws when requestBody is required but missing", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = makeAction();
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            await expect(() => buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: {},
-                globals: {},
-                servers: [
-                    {
-                        url: "https://api.example.com",
-                        variables: [],
-                        variableNames: [],
-                    },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            })).toThrow("Required: --name");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("throws friendly error for missing required expanded field", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            // Schema with two fields, one required
-            const action = makeAction({
-                requestBodySchema: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        email: { type: "string" },
-                    },
-                    required: ["name"],
-                },
-            });
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            // Provide email but not name (the required one)
-            await expect(() => buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { email: "test@example.com" }, // --email (but missing --name)
-                globals: {},
-                servers: [
-                    {
-                        url: "https://api.example.com",
-                        variables: [],
-                        variableNames: [],
-                    },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            })).toThrow("Missing required fields: --name");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("builds nested object from dot notation flags", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = makeAction({
-                requestBodySchema: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        address: {
-                            type: "object",
-                            properties: {
-                                street: { type: "string" },
-                                city: { type: "string" },
-                            },
-                        },
-                    },
-                    required: ["name"],
-                },
-            });
-            const bodyFlagDefs = generateBodyFlags(action.requestBodySchema, new Set());
-            // Dot notation: --address.street and --address.city should create nested object
-            const { request } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: {
-                    name: "Ada",
-                    "address.street": "123 Main St", // Commander keeps dots in keys
-                    "address.city": "NYC",
-                },
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-                bodyFlagDefs,
-            });
-            const body = JSON.parse(await request.clone().text());
-            expect(body).toEqual({
-                name: "Ada",
-                address: {
-                    street: "123 Main St",
-                    city: "NYC",
-                },
-            });
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-});
-describe("buildRequest (query parameters)", () => {
-    test("builds query string from flag values", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = {
-                id: "test",
-                key: "GET /contacts",
-                action: "list",
-                pathArgs: [],
-                method: "GET",
-                path: "/contacts",
-                tags: [],
-                style: "rest",
-                positionals: [],
-                flags: [
-                    {
-                        flag: "--limit",
-                        name: "limit",
-                        in: "query",
-                        type: "integer",
-                        required: false,
-                    },
-                    {
-                        flag: "--name",
-                        name: "name",
-                        in: "query",
-                        type: "string",
-                        required: false,
-                    },
-                ],
-                params: [
-                    {
-                        kind: "flag",
-                        flag: "--limit",
-                        name: "limit",
-                        in: "query",
-                        required: false,
-                        type: "integer",
-                    },
-                    {
-                        kind: "flag",
-                        flag: "--name",
-                        name: "name",
-                        in: "query",
-                        required: false,
-                        type: "string",
-                    },
-                ],
-                auth: { alternatives: [] },
-            };
-            const { request } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { limit: 10, name: "andrew" },
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-            });
-            expect(request.method).toBe("GET");
-            expect(request.url).toBe("https://api.example.com/contacts?limit=10&name=andrew");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-    test("handles array query parameters", async () => {
-        const prevHome = process.env.HOME;
-        const home = `${tmpdir()}/specli-test-${crypto.randomUUID()}`;
-        process.env.HOME = home;
-        try {
-            const action = {
-                id: "test",
-                key: "GET /contacts",
-                action: "list",
-                pathArgs: [],
-                method: "GET",
-                path: "/contacts",
-                tags: [],
-                style: "rest",
-                positionals: [],
-                flags: [
-                    {
-                        flag: "--tag",
-                        name: "tag",
-                        in: "query",
-                        type: "array",
-                        itemType: "string",
-                        required: false,
-                    },
-                ],
-                params: [
-                    {
-                        kind: "flag",
-                        flag: "--tag",
-                        name: "tag",
-                        in: "query",
-                        required: false,
-                        type: "array",
-                    },
-                ],
-                auth: { alternatives: [] },
-            };
-            const { request } = await buildRequest({
-                specId: "spec",
-                action,
-                positionalValues: [],
-                flagValues: { tag: ["vip", "active"] },
-                globals: {},
-                servers: [
-                    { url: "https://api.example.com", variables: [], variableNames: [] },
-                ],
-                authSchemes: [],
-            });
-            expect(request.url).toBe("https://api.example.com/contacts?tag=vip&tag=active");
-        }
-        finally {
-            process.env.HOME = prevHome;
-        }
-    });
-});
-describe("formatAjvErrors", () => {
-    test("pretty prints required errors", () => {
-        const ajv = createAjv();
-        const validate = ajv.compile({
-            type: "object",
-            properties: { name: { type: "string" } },
-            required: ["name"],
-        });
-        validate({});
-        const msg = formatAjvErrors(validate.errors);
-        expect(msg).toBe("/ missing required property 'name'");
-    });
-});

package/dist/cli/runtime/validate/coerce.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/runtime/validate/coerce.test.js

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { coerceArrayInput, coerceValue } from "./coerce.js";
-describe("coerceValue", () => {
-    test("returns string as-is for string type", () => {
-        expect(coerceValue("hello", "string")).toBe("hello");
-    });
-    test("returns string as-is for unknown type", () => {
-        expect(coerceValue("hello", "unknown")).toBe("hello");
-    });
-    test("parses integer type", () => {
-        expect(coerceValue("42", "integer")).toBe(42);
-        expect(coerceValue("-10", "integer")).toBe(-10);
-        expect(coerceValue("0", "integer")).toBe(0);
-    });
-    test("throws for invalid integer", () => {
-        expect(() => coerceValue("abc", "integer")).toThrow("Expected integer");
-    });
-    test("truncates decimal for integer type (parseInt behavior)", () => {
-        // parseInt("12.5", 10) returns 12 - this is expected JS behavior
-        expect(coerceValue("12.5", "integer")).toBe(12);
-    });
-    test("parses number type", () => {
-        expect(coerceValue("42", "number")).toBe(42);
-        expect(coerceValue("3.14", "number")).toBe(3.14);
-        expect(coerceValue("-0.5", "number")).toBe(-0.5);
-    });
-    test("throws for invalid number", () => {
-        expect(() => coerceValue("abc", "number")).toThrow("Expected number");
-    });
-    test("parses boolean type", () => {
-        expect(coerceValue("true", "boolean")).toBe(true);
-        expect(coerceValue("false", "boolean")).toBe(false);
-    });
-    test("throws for invalid boolean", () => {
-        expect(() => coerceValue("yes", "boolean")).toThrow("Expected boolean");
-        expect(() => coerceValue("1", "boolean")).toThrow("Expected boolean");
-    });
-    test("parses object type as JSON", () => {
-        expect(coerceValue('{"a":1}', "object")).toEqual({ a: 1 });
-    });
-    test("throws for invalid object JSON", () => {
-        expect(() => coerceValue("not json", "object")).toThrow("Expected JSON object");
-    });
-});
-describe("coerceArrayInput", () => {
-    test("parses comma-separated values", () => {
-        expect(coerceArrayInput("a,b,c", "string")).toEqual(["a", "b", "c"]);
-    });
-    test("trims whitespace in comma-separated values", () => {
-        expect(coerceArrayInput("a, b, c", "string")).toEqual(["a", "b", "c"]);
-    });
-    test("parses JSON array", () => {
-        expect(coerceArrayInput('["a","b","c"]', "string")).toEqual([
-            "a",
-            "b",
-            "c",
-        ]);
-    });
-    test("coerces array items to specified type", () => {
-        expect(coerceArrayInput("1,2,3", "integer")).toEqual([1, 2, 3]);
-        expect(coerceArrayInput('["1","2","3"]', "integer")).toEqual([1, 2, 3]);
-    });
-    test("returns empty array for empty string", () => {
-        expect(coerceArrayInput("", "string")).toEqual([]);
-        expect(coerceArrayInput("   ", "string")).toEqual([]);
-    });
-    test("throws for invalid JSON array", () => {
-        expect(() => coerceArrayInput("[invalid", "string")).toThrow("Expected JSON array");
-    });
-    test("treats non-array JSON as comma-separated string", () => {
-        // If it doesn't start with '[', it's treated as comma-separated
-        // '{"a":1}' doesn't start with '[', so it's treated as a single value
-        expect(coerceArrayInput('{"a":1}', "string")).toEqual(['{"a":1}']);
-    });
-});

package/dist/cli/server.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/server.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { listServers } from "./server.js";
-describe("listServers", () => {
-    test("extracts server variables from template", () => {
-        const doc = {
-            openapi: "3.0.3",
-            servers: [
-                {
-                    url: "https://{region}.api.example.com/{basePath}",
-                    variables: {
-                        region: {
-                            default: "us",
-                            enum: ["us", "eu"],
-                        },
-                        basePath: {
-                            default: "v1",
-                        },
-                    },
-                },
-            ],
-        };
-        const servers = listServers(doc);
-        expect(servers).toHaveLength(1);
-        expect(servers[0]?.variableNames).toEqual(["region", "basePath"]);
-        expect(servers[0]?.variables.map((v) => v.name)).toEqual([
-            "region",
-            "basePath",
-        ]);
-        expect(servers[0]?.variables[0]?.enum).toEqual(["us", "eu"]);
-    });
-    test("includes servers defined on paths and operations", () => {
-        const doc = {
-            openapi: "3.0.3",
-            paths: {
-                "/v1/forecast": {
-                    servers: [{ url: "https://api.a.example.com" }],
-                    get: {
-                        servers: [{ url: "https://api.b.example.com" }],
-                    },
-                },
-            },
-        };
-        const servers = listServers(doc);
-        expect(servers.map((s) => s.url)).toEqual([
-            "https://api.a.example.com",
-            "https://api.b.example.com",
-        ]);
-    });
-});

package/dist/compiled.d.ts

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

package/dist/compiled.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env bun
-import { main } from "./cli/main.js";
-import { env, envRequired } from "./macros/env.js" with { type: "macro" };
-import { loadSpec } from "./macros/spec.js" with { type: "macro" };
-import { version } from "./macros/version.js" with { type: "macro" };
-// This entrypoint is intended to be compiled.
-// All values are embedded via Bun macros at bundle-time.
-const embeddedSpecText = await loadSpec(envRequired("SPECLI_SPEC"));
-const cliName = env("SPECLI_NAME");
-const server = env("SPECLI_SERVER");
-const serverVars = env("SPECLI_SERVER_VARS");
-const auth = env("SPECLI_AUTH");
-const embeddedVersion = version();
-await main(process.argv, {
-    embeddedSpecText,
-    cliName,
-    server,
-    serverVars: serverVars ? serverVars.split(",") : undefined,
-    auth,
-    version: embeddedVersion,
-});

package/dist/macros/env.d.ts

@@ -1,10 +0,0 @@
-/**
- * Bun macro: reads an environment variable at bundle-time.
- * Returns undefined if the env var is not set.
- */
-export declare function env(name: string): string | undefined;
-/**
- * Bun macro: reads a required environment variable at bundle-time.
- * Throws if the env var is not set.
- */
-export declare function envRequired(name: string): string;

package/dist/macros/env.js

@@ -1,22 +0,0 @@
-/**
- * Bun macro: reads an environment variable at bundle-time.
- * Returns undefined if the env var is not set.
- */
-export function env(name) {
-    if (!name)
-        throw new Error("env macro: missing variable name");
-    return process.env[name];
-}
-/**
- * Bun macro: reads a required environment variable at bundle-time.
- * Throws if the env var is not set.
- */
-export function envRequired(name) {
-    if (!name)
-        throw new Error("envRequired macro: missing variable name");
-    const value = process.env[name];
-    if (value === undefined) {
-        throw new Error(`Missing required env var: ${name}`);
-    }
-    return value;
-}

package/dist/macros/spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * Bun macro: loads an OpenAPI spec from a URL or file path at bundle-time.
- * The spec text is inlined into the bundle.
- */
-export declare function loadSpec(spec: string): Promise<string>;

package/dist/macros/spec.js

@@ -1,16 +0,0 @@
-/**
- * Bun macro: loads an OpenAPI spec from a URL or file path at bundle-time.
- * The spec text is inlined into the bundle.
- */
-export async function loadSpec(spec) {
-    if (!spec)
-        throw new Error("loadSpec macro: missing spec path/URL");
-    if (/^https?:\/\//i.test(spec)) {
-        const res = await fetch(spec);
-        if (!res.ok) {
-            throw new Error(`Failed to fetch spec: ${res.status} ${res.statusText}`);
-        }
-        return await res.text();
-    }
-    return await Bun.file(spec).text();
-}

package/dist/macros/version.d.ts

@@ -1,4 +0,0 @@
-/**
- * Bun macro: reads the version from package.json at bundle-time.
- */
-export declare function version(): string;

package/dist/macros/version.js

@@ -1,13 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * Bun macro: reads the version from package.json at bundle-time.
- */
-export function version() {
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-    const packageJsonPath = join(currentDir, "../../package.json");
-    const content = readFileSync(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(content);
-    return packageJson.version;
-}