specli 0.0.21 → 0.0.23

package/dist/cli/parse/auth-schemes.test.js

@@ -1,56 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { listAuthSchemes } from "./auth-schemes.js";
-describe("listAuthSchemes", () => {
-    test("parses bearer + apiKey", () => {
-        const doc = {
-            openapi: "3.0.3",
-            components: {
-                securitySchemes: {
-                    bearerAuth: {
-                        type: "http",
-                        scheme: "bearer",
-                        bearerFormat: "JWT",
-                    },
-                    apiKeyAuth: {
-                        type: "apiKey",
-                        in: "header",
-                        name: "X-API-Key",
-                    },
-                },
-            },
-        };
-        const schemes = listAuthSchemes(doc);
-        expect(schemes).toHaveLength(2);
-        const bearer = schemes.find((s) => s.key === "bearerAuth");
-        expect(bearer?.kind).toBe("http-bearer");
-        const apiKey = schemes.find((s) => s.key === "apiKeyAuth");
-        expect(apiKey?.kind).toBe("api-key");
-        expect(apiKey?.in).toBe("header");
-        expect(apiKey?.name).toBe("X-API-Key");
-    });
-    test("parses oauth2 flows", () => {
-        const doc = {
-            openapi: "3.0.3",
-            components: {
-                securitySchemes: {
-                    oauth: {
-                        type: "oauth2",
-                        flows: {
-                            clientCredentials: {
-                                tokenUrl: "https://example.com/oauth/token",
-                                scopes: {
-                                    "read:ping": "read ping",
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        const schemes = listAuthSchemes(doc);
-        const oauth = schemes.find((s) => s.key === "oauth");
-        expect(oauth?.kind).toBe("oauth2");
-        expect(oauth?.oauthFlows?.clientCredentials?.tokenUrl).toBe("https://example.com/oauth/token");
-        expect(oauth?.oauthFlows?.clientCredentials?.scopes).toEqual(["read:ping"]);
-    });
-});

package/dist/cli/parse/operations.test.d.ts

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

package/dist/cli/parse/operations.test.js

@@ -1,51 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { indexOperations } from "./operations.js";
-describe("indexOperations", () => {
-    test("indexes basic operations", () => {
-        const doc = {
-            openapi: "3.0.3",
-            paths: {
-                "/contacts": {
-                    get: {
-                        operationId: "Contacts.List",
-                        tags: ["Contacts"],
-                        parameters: [
-                            {
-                                in: "query",
-                                name: "limit",
-                                schema: { type: "integer" },
-                            },
-                        ],
-                    },
-                },
-                "/contacts/{id}": {
-                    get: {
-                        operationId: "Contacts.Get",
-                        tags: ["Contacts"],
-                        parameters: [
-                            {
-                                in: "path",
-                                name: "id",
-                                required: true,
-                                schema: { type: "string" },
-                            },
-                        ],
-                    },
-                },
-            },
-        };
-        const ops = indexOperations(doc);
-        expect(ops).toHaveLength(2);
-        expect(ops[0]?.key).toBe("GET /contacts");
-        expect(ops[0]?.path).toBe("/contacts");
-        expect(ops[0]?.method).toBe("GET");
-        expect(ops[0]?.parameters).toHaveLength(1);
-        expect(ops[0]?.parameters[0]?.in).toBe("query");
-        expect(ops[1]?.key).toBe("GET /contacts/{id}");
-        expect(ops[1]?.path).toBe("/contacts/{id}");
-        expect(ops[1]?.method).toBe("GET");
-        expect(ops[1]?.parameters).toHaveLength(1);
-        expect(ops[1]?.parameters[0]?.in).toBe("path");
-        expect(ops[1]?.parameters[0]?.required).toBe(true);
-    });
-});

package/dist/cli/parse/params.test.d.ts

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

package/dist/cli/parse/params.test.js

@@ -1,62 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { deriveParamSpecs } from "./params.js";
-describe("deriveParamSpecs", () => {
-    test("derives basic types + flags", () => {
-        const op = {
-            key: "GET /contacts",
-            method: "GET",
-            path: "/contacts",
-            tags: [],
-            parameters: [
-                {
-                    in: "query",
-                    name: "limit",
-                    required: false,
-                    schema: {
-                        type: "integer",
-                        format: "int32",
-                        enum: ["1", "2"],
-                    },
-                },
-                {
-                    in: "header",
-                    name: "X-Request-Id",
-                    required: false,
-                    schema: { type: "string" },
-                },
-            ],
-        };
-        const specs = deriveParamSpecs(op);
-        expect(specs).toHaveLength(2);
-        const limit = specs.find((p) => p.name === "limit");
-        expect(limit?.kind).toBe("flag");
-        expect(limit?.flag).toBe("--limit");
-        expect(limit?.type).toBe("integer");
-        expect(limit?.format).toBe("int32");
-        expect(limit?.enum).toEqual(["1", "2"]);
-        const reqId = specs.find((p) => p.name === "X-Request-Id");
-        expect(reqId?.kind).toBe("flag");
-        expect(reqId?.flag).toBe("--x-request-id");
-        expect(reqId?.type).toBe("string");
-    });
-    test("derives array item types", () => {
-        const op = {
-            key: "GET /things",
-            method: "GET",
-            path: "/things",
-            tags: [],
-            parameters: [
-                {
-                    in: "query",
-                    name: "ids",
-                    required: false,
-                    schema: { type: "array", items: { type: "integer" } },
-                },
-            ],
-        };
-        const specs = deriveParamSpecs(op);
-        expect(specs).toHaveLength(1);
-        expect(specs[0]?.type).toBe("array");
-        expect(specs[0]?.itemType).toBe("integer");
-    });
-});

package/dist/cli/parse/positional.test.d.ts

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

package/dist/cli/parse/positional.test.js

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { deriveFlags, derivePositionals } from "./positional.js";
-describe("derivePositionals", () => {
-    test("returns ordered positionals from pathArgs", () => {
-        const action = {
-            pathArgs: ["id"],
-            params: [
-                {
-                    kind: "positional",
-                    in: "path",
-                    name: "id",
-                    flag: "--id",
-                    required: true,
-                    type: "string",
-                },
-            ],
-        };
-        const pos = derivePositionals(action);
-        expect(pos).toEqual([
-            {
-                name: "id",
-                required: true,
-                type: "string",
-                format: undefined,
-                enum: undefined,
-                description: undefined,
-            },
-        ]);
-    });
-});
-describe("deriveFlags", () => {
-    test("returns only flag params", () => {
-        const action = {
-            pathArgs: [],
-            params: [
-                {
-                    kind: "flag",
-                    in: "query",
-                    name: "limit",
-                    flag: "--limit",
-                    required: false,
-                    type: "integer",
-                },
-            ],
-        };
-        const flags = deriveFlags(action);
-        expect(flags.flags).toEqual([
-            {
-                in: "query",
-                name: "limit",
-                flag: "--limit",
-                required: false,
-                description: undefined,
-                type: "integer",
-                format: undefined,
-                enum: undefined,
-            },
-        ]);
-    });
-});

package/dist/cli/parse/request-body.test.d.ts

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

package/dist/cli/parse/request-body.test.js

@@ -1,31 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { deriveRequestBodyInfo } from "./request-body.js";
-describe("deriveRequestBodyInfo", () => {
-    test("summarizes content types and convenience flags", () => {
-        const op = {
-            key: "POST /contacts",
-            method: "POST",
-            path: "/contacts",
-            tags: [],
-            parameters: [],
-            requestBody: {
-                required: true,
-                contentTypes: ["application/x-www-form-urlencoded", "application/json"],
-                schemasByContentType: {
-                    "application/json": { type: "object" },
-                    "application/x-www-form-urlencoded": { type: "object" },
-                },
-            },
-        };
-        const info = deriveRequestBodyInfo(op);
-        expect(info?.required).toBe(true);
-        expect(info?.hasJson).toBe(true);
-        expect(info?.hasFormUrlEncoded).toBe(true);
-        expect(info?.hasMultipart).toBe(false);
-        expect(info?.content.map((c) => c.contentType)).toEqual([
-            "application/json",
-            "application/x-www-form-urlencoded",
-        ]);
-        expect(info?.preferredSchema).toEqual({ type: "object" });
-    });
-});

package/dist/cli/parse/servers.test.d.ts

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

package/dist/cli/parse/servers.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { listServers } from "./servers.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/cli/runtime/body-flags.test.d.ts

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

package/dist/cli/runtime/body-flags.test.js

@@ -1,192 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { findMissingRequired, generateBodyFlags, parseDotNotationFlags, } from "./body-flags.js";
-describe("generateBodyFlags", () => {
-    test("generates flags for simple properties", () => {
-        const flags = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                age: { type: "integer" },
-                active: { type: "boolean" },
-            },
-            required: ["name"],
-        }, new Set());
-        expect(flags).toHaveLength(3);
-        expect(flags.find((f) => f.flag === "--name")).toEqual({
-            flag: "--name",
-            path: ["name"],
-            type: "string",
-            description: "Body field 'name'",
-            required: true,
-        });
-        expect(flags.find((f) => f.flag === "--age")).toEqual({
-            flag: "--age",
-            path: ["age"],
-            type: "integer",
-            description: "Body field 'age'",
-            required: false,
-        });
-    });
-    test("generates dot-notation flags for nested objects", () => {
-        const flags = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                address: {
-                    type: "object",
-                    properties: {
-                        street: { type: "string" },
-                        city: { type: "string" },
-                        zip: { type: "string" },
-                    },
-                },
-            },
-        }, new Set());
-        expect(flags).toHaveLength(4);
-        expect(flags.find((f) => f.flag === "--name")).toBeDefined();
-        expect(flags.find((f) => f.flag === "--address.street")).toEqual({
-            flag: "--address.street",
-            path: ["address", "street"],
-            type: "string",
-            description: "Body field 'address.street'",
-            required: false,
-        });
-    });
-    test("handles deeply nested objects", () => {
-        const flags = generateBodyFlags({
-            type: "object",
-            properties: {
-                user: {
-                    type: "object",
-                    properties: {
-                        profile: {
-                            type: "object",
-                            properties: {
-                                bio: { type: "string" },
-                            },
-                        },
-                    },
-                },
-            },
-        }, new Set());
-        expect(flags.find((f) => f.flag === "--user.profile.bio")).toEqual({
-            flag: "--user.profile.bio",
-            path: ["user", "profile", "bio"],
-            type: "string",
-            description: "Body field 'user.profile.bio'",
-            required: false,
-        });
-    });
-    test("skips reserved flags", () => {
-        const flags = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                data: { type: "string" }, // --data is reserved
-            },
-        }, new Set(["--data"]));
-        expect(flags).toHaveLength(1);
-        expect(flags[0]?.flag).toBe("--name");
-    });
-    test("skips --curl builtin flag", () => {
-        const reservedFlags = new Set(["--curl"]);
-        const flags = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                curl: { type: "boolean" }, // conflicts with --curl builtin
-                email: { type: "string" }, // no conflict
-            },
-        }, reservedFlags);
-        expect(flags).toHaveLength(2);
-        expect(flags.map((f) => f.flag).sort()).toEqual(["--email", "--name"]);
-    });
-    test("uses description from schema", () => {
-        const flags = generateBodyFlags({
-            type: "object",
-            properties: {
-                email: { type: "string", description: "User email address" },
-            },
-        }, new Set());
-        expect(flags[0]?.description).toBe("User email address");
-    });
-});
-describe("parseDotNotationFlags", () => {
-    test("parses flat flags", () => {
-        const flagDefs = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                age: { type: "integer" },
-            },
-        }, new Set());
-        const result = parseDotNotationFlags({ name: "Ada", age: "30" }, flagDefs);
-        expect(result).toEqual({
-            name: "Ada",
-            age: 30,
-        });
-    });
-    test("parses nested flags into objects", () => {
-        const flagDefs = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                address: {
-                    type: "object",
-                    properties: {
-                        street: { type: "string" },
-                        city: { type: "string" },
-                    },
-                },
-            },
-        }, new Set());
-        // Commander keeps dots: --address.street -> "address.street"
-        const result = parseDotNotationFlags({
-            name: "Ada",
-            "address.street": "123 Main",
-            "address.city": "NYC",
-        }, flagDefs);
-        expect(result).toEqual({
-            name: "Ada",
-            address: {
-                street: "123 Main",
-                city: "NYC",
-            },
-        });
-    });
-    test("handles boolean flags", () => {
-        const flagDefs = generateBodyFlags({
-            type: "object",
-            properties: {
-                active: { type: "boolean" },
-            },
-        }, new Set());
-        const result = parseDotNotationFlags({ active: true }, flagDefs);
-        expect(result).toEqual({ active: true });
-    });
-});
-describe("findMissingRequired", () => {
-    test("finds missing required fields", () => {
-        const flagDefs = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-                email: { type: "string" },
-            },
-            required: ["name", "email"],
-        }, new Set());
-        const missing = findMissingRequired({ name: "Ada" }, flagDefs);
-        expect(missing).toEqual(["email"]);
-    });
-    test("returns empty when all required fields present", () => {
-        const flagDefs = generateBodyFlags({
-            type: "object",
-            properties: {
-                name: { type: "string" },
-            },
-            required: ["name"],
-        }, new Set());
-        const missing = findMissingRequired({ name: "Ada" }, flagDefs);
-        expect(missing).toEqual([]);
-    });
-});

package/dist/cli/runtime/request.test.d.ts

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