specli 0.0.1 → 0.0.3

package/scripts/smoke-specs.ts

@@ -1,64 +0,0 @@
-#!/usr/bin/env bun
-
-const specs = [
-	{
-		name: "vercel",
-		url: "https://api.vercel.com/copper/_openapi.json",
-	},
-	{
-		name: "digitalocean",
-		url: "https://raw.githubusercontent.com/digitalocean/openapi/main/specification/DigitalOcean-public.v2.yaml",
-	},
-	// {
-	// 	name: "stripe",
-	// 	url: "https://raw.githubusercontent.com/stripe/openapi/master/openapi/spec3.yaml",
-	// },
-	// NOTE: OpenAI spec is not reliably fetchable via raw.githubusercontent.com
-	// in some environments (intermittent 404). Keep it out of the default smoke
-	// list to avoid flaky CI.
-	// {
-	// 	name: "openai",
-	// 	url: "https://raw.githubusercontent.com/openai/openai-openapi/master/openapi.yaml",
-	// },
-] as const;
-
-type Result = {
-	spec: string;
-	ok: boolean;
-	ms: number;
-	error?: string;
-};
-
-const results: Result[] = [];
-
-for (const spec of specs) {
-	const start = performance.now();
-	try {
-		console.log(spec.url);
-		await Bun.$`bun ./cli.ts exec ${spec.url} __schema --json --min > /dev/null`;
-		results.push({
-			spec: spec.name,
-			ok: true,
-			ms: Math.round(performance.now() - start),
-		});
-	} catch (err) {
-		const message = err instanceof Error ? err.message : String(err);
-		results.push({
-			spec: spec.name,
-			ok: false,
-			ms: Math.round(performance.now() - start),
-			error: message,
-		});
-	}
-}
-
-const allOk = results.every((r) => r.ok);
-for (const r of results) {
-	if (r.ok) {
-		process.stdout.write(`ok  ${r.spec} (${r.ms}ms)\n`);
-	} else {
-		process.stdout.write(`fail ${r.spec} (${r.ms}ms)\n${r.error}\n`);
-	}
-}
-
-process.exitCode = allOk ? 0 : 1;

package/src/cli/auth-requirements.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { summarizeAuth } from "./auth-requirements.ts";
-import type { AuthScheme } from "./auth-schemes.ts";
-
-describe("summarizeAuth", () => {
-	test("uses operation-level security when present", () => {
-		const schemes: AuthScheme[] = [{ key: "oauth", kind: "oauth2" }];
-
-		const summary = summarizeAuth(
-			[{ oauth: ["read:ping"] }],
-			[{ oauth: ["read:other"] }],
-			schemes,
-		);
-
-		expect(summary.alternatives).toEqual([
-			[{ key: "oauth", scopes: ["read:ping"] }],
-		]);
-	});
-
-	test("empty operation security disables auth", () => {
-		const schemes: AuthScheme[] = [{ key: "oauth", kind: "oauth2" }];
-
-		const summary = summarizeAuth([], [{ oauth: ["read:other"] }], schemes);
-		expect(summary.alternatives).toEqual([]);
-	});
-});

package/src/cli/auth-schemes.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { listAuthSchemes } from "./auth-schemes.ts";
-import type { OpenApiDoc } from "./types.ts";
-
-describe("listAuthSchemes", () => {
-	test("parses bearer + apiKey", () => {
-		const doc: OpenApiDoc = {
-			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",
-								},
-							},
-						},
-					},
-				},
-			},
-		} as const;
-
-		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/src/cli/capabilities.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { AuthScheme } from "./auth-schemes.ts";
-import { deriveCapabilities } from "./capabilities.ts";
-import type { CommandModel } from "./command-model.ts";
-import type { ServerInfo } from "./server.ts";
-import type { NormalizedOperation, OpenApiDoc } from "./types.ts";
-
-describe("deriveCapabilities", () => {
-	test("reports requestBody + server vars", () => {
-		const doc: OpenApiDoc = {
-			openapi: "3.0.3",
-			security: [{ bearerAuth: [] }],
-		};
-
-		const servers: ServerInfo[] = [
-			{
-				url: "https://{region}.api.example.com",
-				variables: [],
-				variableNames: ["region"],
-			},
-		];
-
-		const authSchemes: AuthScheme[] = [
-			{ key: "bearerAuth", kind: "http-bearer" },
-		];
-
-		const operations: NormalizedOperation[] = [
-			{
-				key: "POST /contacts",
-				method: "POST",
-				path: "/contacts",
-				tags: [],
-				parameters: [],
-				requestBody: {
-					required: true,
-					contentTypes: ["application/json"],
-					schemasByContentType: { "application/json": { type: "object" } },
-				},
-			},
-		];
-
-		const commands: CommandModel = {
-			resources: [
-				{
-					resource: "contacts",
-					actions: [
-						{
-							id: "x",
-							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",
-							},
-						},
-					],
-				},
-			],
-		};
-
-		const caps = deriveCapabilities({
-			doc,
-			servers,
-			authSchemes,
-			operations,
-			commands,
-		});
-		expect(caps.servers.hasVariables).toBe(true);
-		expect(caps.operations.hasRequestBodies).toBe(true);
-		expect(caps.commands.hasRequestBodies).toBe(true);
-		expect(caps.auth.hasSecurityRequirements).toBe(true);
-		expect(caps.auth.kinds).toEqual(["http-bearer"]);
-	});
-});

package/src/cli/command-id.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { buildCommandId } from "./command-id.ts";
-
-describe("buildCommandId", () => {
-	test("includes spec/resource/action/op", () => {
-		expect(
-			buildCommandId({
-				specId: "contacts-api",
-				resource: "contacts",
-				action: "get",
-				operationKey: "GET /contacts/{id}",
-			}),
-		).toBe("contacts-api:contacts:get:get-contacts-id");
-	});
-
-	test("disambiguates by operationKey", () => {
-		const a = buildCommandId({
-			specId: "x",
-			resource: "contacts",
-			action: "list",
-			operationKey: "GET /contacts",
-		});
-		const b = buildCommandId({
-			specId: "x",
-			resource: "contacts",
-			action: "list",
-			operationKey: "GET /contacts/search",
-		});
-		expect(a).not.toBe(b);
-	});
-});

package/src/cli/command-model.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { buildCommandModel } from "./command-model.ts";
-import type { PlannedOperation } from "./naming.ts";
-
-describe("buildCommandModel", () => {
-	test("groups operations by resource", () => {
-		const planned: PlannedOperation[] = [
-			{
-				key: "GET /contacts",
-				method: "GET",
-				path: "/contacts",
-				tags: ["Contacts"],
-				parameters: [],
-				resource: "contacts",
-				action: "list",
-				canonicalAction: "list",
-				pathArgs: [],
-				style: "rest",
-			},
-			{
-				key: "GET /contacts/{id}",
-				method: "GET",
-				path: "/contacts/{id}",
-				tags: ["Contacts"],
-				parameters: [],
-				resource: "contacts",
-				action: "get",
-				canonicalAction: "get",
-				pathArgs: ["id"],
-				style: "rest",
-			},
-		];
-
-		const model = buildCommandModel(planned, { specId: "contacts-api" });
-		expect(model.resources).toHaveLength(1);
-		expect(model.resources[0]?.resource).toBe("contacts");
-		expect(model.resources[0]?.actions).toHaveLength(2);
-		expect(model.resources[0]?.actions.map((a) => a.action)).toEqual([
-			"get",
-			"list",
-		]);
-	});
-});

package/src/cli/naming.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { planOperation } from "./naming.ts";
-import type { NormalizedOperation } from "./types.ts";
-
-describe("planOperation", () => {
-	test("REST: GET /contacts -> contacts list", () => {
-		const op: NormalizedOperation = {
-			key: "GET /contacts",
-			method: "GET",
-			path: "/contacts",
-			operationId: "Contacts.List",
-			tags: ["Contacts"],
-			parameters: [],
-		};
-
-		const planned = planOperation(op);
-		expect(planned.style).toBe("rest");
-		expect(planned.resource).toBe("contacts");
-		expect(planned.action).toBe("list");
-		expect(planned.pathArgs).toEqual([]);
-	});
-
-	test("REST: singleton /ping stays ping and prefers operationId action", () => {
-		const op: NormalizedOperation = {
-			key: "GET /ping",
-			method: "GET",
-			path: "/ping",
-			operationId: "Ping.Get",
-			tags: [],
-			parameters: [],
-		};
-
-		const planned = planOperation(op);
-		expect(planned.style).toBe("rest");
-		expect(planned.resource).toBe("ping");
-		expect(planned.action).toBe("get");
-	});
-
-	test("REST: singular path pluralizes to contacts", () => {
-		const op: NormalizedOperation = {
-			key: "GET /contact/{id}",
-			method: "GET",
-			path: "/contact/{id}",
-			tags: [],
-			parameters: [],
-		};
-
-		const planned = planOperation(op);
-		expect(planned.style).toBe("rest");
-		expect(planned.resource).toBe("contacts");
-		expect(planned.action).toBe("get");
-		expect(planned.pathArgs).toEqual(["id"]);
-	});
-
-	test("RPC: POST /Contacts.List -> contacts list", () => {
-		const op: NormalizedOperation = {
-			key: "POST /Contacts.List",
-			method: "POST",
-			path: "/Contacts.List",
-			operationId: "Contacts.List",
-			tags: [],
-			parameters: [],
-		};
-
-		const planned = planOperation(op);
-		expect(planned.style).toBe("rpc");
-		expect(planned.resource).toBe("contacts");
-		expect(planned.action).toBe("list");
-	});
-
-	test("RPC: Retrieve canonicalizes to get", () => {
-		const op: NormalizedOperation = {
-			key: "POST /Contacts.Retrieve",
-			method: "POST",
-			path: "/Contacts.Retrieve",
-			operationId: "Contacts.Retrieve",
-			tags: [],
-			parameters: [],
-		};
-
-		const planned = planOperation(op);
-		expect(planned.style).toBe("rpc");
-		expect(planned.resource).toBe("contacts");
-		expect(planned.action).toBe("get");
-	});
-});

package/src/cli/operations.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { indexOperations } from "./operations.ts";
-import type { OpenApiDoc } from "./types.ts";
-
-describe("indexOperations", () => {
-	test("indexes basic operations", () => {
-		const doc: OpenApiDoc = {
-			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/src/cli/params.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { deriveParamSpecs } from "./params.ts";
-import type { NormalizedOperation } from "./types.ts";
-
-describe("deriveParamSpecs", () => {
-	test("derives basic types + flags", () => {
-		const op: NormalizedOperation = {
-			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: NormalizedOperation = {
-			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/src/cli/positional.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ActionShapeForCli } from "./positional.ts";
-import { deriveFlags, derivePositionals } from "./positional.ts";
-
-describe("derivePositionals", () => {
-	test("returns ordered positionals from pathArgs", () => {
-		const action: ActionShapeForCli = {
-			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: ActionShapeForCli = {
-			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/src/cli/request-body.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { deriveRequestBodyInfo } from "./request-body.ts";
-import type { NormalizedOperation } from "./types.ts";
-
-describe("deriveRequestBodyInfo", () => {
-	test("summarizes content types and convenience flags", () => {
-		const op: NormalizedOperation = {
-			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" });
-	});
-});