@schmock/cli 1.1.0 → 1.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/cli",
   "description": "CLI for running Schmock mock servers from OpenAPI specs",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -9,8 +9,7 @@
     "schmock": "./dist/index.js"
   },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "exports": {
     ".": {
@@ -28,12 +27,13 @@
     "test:watch": "vitest --watch",
     "test:bdd": "vitest run --config vitest.config.bdd.ts",
     "lint": "biome check src/*.ts",
-    "lint:fix": "biome check --write --unsafe src/*.ts"
+    "lint:fix": "biome check --write --unsafe src/*.ts",
+    "check:publish": "publint && attw --pack --ignore-rules cjs-resolves-to-esm"
   },
   "license": "MIT",
   "dependencies": {
-    "@schmock/core": "workspace:*",
-    "@schmock/openapi": "workspace:*"
+    "@schmock/core": "^1.4.0",
+    "@schmock/openapi": "^1.4.0"
   },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^6.2.0",

package/src/cli.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseCliArgs } from "./cli";
-
-describe("parseCliArgs", () => {
-  it("parses --spec flag", () => {
-    const result = parseCliArgs(["--spec", "petstore.yaml"]);
-    expect(result.spec).toBe("petstore.yaml");
-  });
-
-  it("parses --port flag", () => {
-    const result = parseCliArgs(["--spec", "x.yaml", "--port", "8080"]);
-    expect(result.port).toBe(8080);
-  });
-
-  it("parses --hostname flag", () => {
-    const result = parseCliArgs(["--spec", "x.yaml", "--hostname", "0.0.0.0"]);
-    expect(result.hostname).toBe("0.0.0.0");
-  });
-
-  it("parses --seed flag", () => {
-    const result = parseCliArgs(["--spec", "x.yaml", "--seed", "seed.json"]);
-    expect(result.seed).toBe("seed.json");
-  });
-
-  it("parses --cors flag", () => {
-    const result = parseCliArgs(["--spec", "x.yaml", "--cors"]);
-    expect(result.cors).toBe(true);
-  });
-
-  it("parses --debug flag", () => {
-    const result = parseCliArgs(["--spec", "x.yaml", "--debug"]);
-    expect(result.debug).toBe(true);
-  });
-
-  it("parses -h / --help flag", () => {
-    const result = parseCliArgs(["-h"]);
-    expect(result.help).toBe(true);
-  });
-
-  it("defaults port to undefined when not provided", () => {
-    const result = parseCliArgs(["--spec", "x.yaml"]);
-    expect(result.port).toBeUndefined();
-  });
-
-  it("defaults cors to false", () => {
-    const result = parseCliArgs(["--spec", "x.yaml"]);
-    expect(result.cors).toBe(false);
-  });
-
-  it("defaults spec to empty string when not provided", () => {
-    const result = parseCliArgs([]);
-    expect(result.spec).toBe("");
-  });
-
-  it("parses positional spec argument", () => {
-    const result = parseCliArgs(["petstore.yaml"]);
-    expect(result.spec).toBe("petstore.yaml");
-  });
-
-  it("positional spec works with other flags", () => {
-    const result = parseCliArgs(["petstore.yaml", "--port", "8080", "--cors"]);
-    expect(result.spec).toBe("petstore.yaml");
-    expect(result.port).toBe(8080);
-    expect(result.cors).toBe(true);
-  });
-
-  it("--spec flag takes precedence over positional", () => {
-    const result = parseCliArgs(["positional.yaml", "--spec", "flag.yaml"]);
-    expect(result.spec).toBe("flag.yaml");
-  });
-});

package/src/cli.ts

@@ -1,241 +0,0 @@
-/// <reference path="../../../types/schmock.d.ts" />
-
-import { readFileSync } from "node:fs";
-import type { Server } from "node:http";
-import { createServer } from "node:http";
-import { parseArgs } from "node:util";
-import { schmock, toHttpMethod } from "@schmock/core";
-import type { SeedConfig } from "@schmock/openapi";
-import { openapi } from "@schmock/openapi";
-
-export interface CliOptions {
-  spec: string;
-  port?: number;
-  hostname?: string;
-  seed?: string;
-  cors?: boolean;
-  debug?: boolean;
-}
-
-export interface CliServer {
-  server: Server;
-  port: number;
-  hostname: string;
-  close(): void;
-}
-
-const CORS_HEADERS: Record<string, string> = {
-  "access-control-allow-origin": "*",
-  "access-control-allow-methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-  "access-control-allow-headers": "Content-Type, Authorization",
-};
-
-function isSeedSource(value: unknown): value is SeedConfig[string] {
-  return (
-    Array.isArray(value) ||
-    typeof value === "string" ||
-    (typeof value === "object" && value !== null && "count" in value)
-  );
-}
-
-function loadSeedFile(seedPath: string): SeedConfig {
-  const raw = readFileSync(seedPath, "utf-8");
-  const parsed: unknown = JSON.parse(raw);
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(
-      `Seed file must contain a JSON object, got: ${typeof parsed}`,
-    );
-  }
-  const result: SeedConfig = {};
-  for (const [key, value] of Object.entries(parsed)) {
-    if (isSeedSource(value)) {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-export async function createCliServer(options: CliOptions): Promise<CliServer> {
-  const mock = schmock({ debug: options.debug });
-
-  const openapiOptions: Parameters<typeof openapi>[0] = {
-    spec: options.spec,
-  };
-
-  if (options.seed) {
-    openapiOptions.seed = loadSeedFile(options.seed);
-  }
-
-  const plugin = await openapi(openapiOptions);
-  mock.pipe(plugin);
-
-  const hostname = options.hostname ?? "127.0.0.1";
-  const port = options.port ?? 3000;
-  const cors = options.cors ?? false;
-
-  const httpServer = createServer((req, res) => {
-    // Handle CORS preflight
-    if (cors && req.method === "OPTIONS") {
-      res.writeHead(204, CORS_HEADERS);
-      res.end();
-      return;
-    }
-
-    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
-    const method = toHttpMethod(req.method ?? "GET");
-    const path = url.pathname;
-
-    const headers: Record<string, string> = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-      if (typeof value === "string") {
-        headers[key] = value;
-      }
-    }
-
-    const query: Record<string, string> = {};
-    url.searchParams.forEach((value, key) => {
-      query[key] = value;
-    });
-
-    const chunks: Buffer[] = [];
-    req.on("data", (chunk: Buffer) => chunks.push(chunk));
-    req.on("end", () => {
-      const raw = Buffer.concat(chunks).toString();
-      let body: unknown;
-      const contentType = headers["content-type"] ?? "";
-      if (raw && contentType.includes("json")) {
-        try {
-          body = JSON.parse(raw);
-        } catch {
-          body = raw;
-        }
-      } else if (raw) {
-        body = raw;
-      }
-
-      void mock
-        .handle(method, path, { headers, body, query })
-        .then((schmockResponse) => {
-          const responseHeaders: Record<string, string> = {
-            ...schmockResponse.headers,
-          };
-
-          if (cors) {
-            Object.assign(responseHeaders, CORS_HEADERS);
-          }
-
-          if (
-            !responseHeaders["content-type"] &&
-            schmockResponse.body !== undefined &&
-            typeof schmockResponse.body !== "string"
-          ) {
-            responseHeaders["content-type"] = "application/json";
-          }
-
-          const responseBody =
-            schmockResponse.body === undefined
-              ? undefined
-              : typeof schmockResponse.body === "string"
-                ? schmockResponse.body
-                : JSON.stringify(schmockResponse.body);
-
-          res.writeHead(schmockResponse.status, responseHeaders);
-          res.end(responseBody);
-        });
-    });
-  });
-
-  return new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, hostname, () => {
-      const addr = httpServer.address();
-      const actualPort =
-        addr !== null && typeof addr === "object" ? addr.port : port;
-
-      resolve({
-        server: httpServer,
-        port: actualPort,
-        hostname,
-        close() {
-          httpServer.close();
-        },
-      });
-    });
-  });
-}
-
-export function parseCliArgs(args: string[]): CliOptions & { help: boolean } {
-  const { values, positionals } = parseArgs({
-    args,
-    options: {
-      spec: { type: "string" },
-      port: { type: "string" },
-      hostname: { type: "string" },
-      seed: { type: "string" },
-      cors: { type: "boolean", default: false },
-      debug: { type: "boolean", default: false },
-      help: { type: "boolean", short: "h", default: false },
-    },
-    strict: true,
-    allowPositionals: true,
-  });
-
-  const spec = values.spec ?? positionals[0] ?? "";
-
-  return {
-    spec,
-    port: values.port ? Number(values.port) : undefined,
-    hostname: values.hostname,
-    seed: values.seed,
-    cors: values.cors,
-    debug: values.debug,
-    help: values.help ?? false,
-  };
-}
-
-const USAGE = `Usage: schmock <spec> [options]
-       schmock --spec <path> [options]
-
-Options:
-  --spec <path>       OpenAPI/Swagger spec file (or pass as first argument)
-  --port <number>     Port to listen on (default: 3000)
-  --hostname <host>   Hostname to bind to (default: 127.0.0.1)
-  --seed <path>       JSON file with seed data
-  --cors              Enable CORS for all responses
-  --debug             Enable debug logging
-  -h, --help          Show this help message
-`;
-
-export async function run(args: string[]): Promise<void> {
-  const options = parseCliArgs(args);
-
-  if (options.help) {
-    process.stderr.write(USAGE);
-    return;
-  }
-
-  if (!options.spec) {
-    process.stderr.write("Error: --spec is required\n\n");
-    process.stderr.write(USAGE);
-    process.exitCode = 1;
-    return;
-  }
-
-  const cliServer = await createCliServer(options);
-
-  process.stderr.write(
-    `Schmock server running on http://${cliServer.hostname}:${cliServer.port}\n`,
-  );
-  process.stderr.write(`Spec: ${options.spec}\n`);
-  if (options.cors) {
-    process.stderr.write("CORS: enabled\n");
-  }
-
-  const shutdown = () => {
-    process.stderr.write("\nShutting down...\n");
-    cliServer.close();
-  };
-
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-}

package/src/index.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env bun
-
-/// <reference path="../../../types/schmock.d.ts" />
-
-export type { CliOptions, CliServer } from "./cli.js";
-export { createCliServer, parseCliArgs, run } from "./cli.js";
-
-// Run CLI when invoked directly
-import { run } from "./cli.js";
-
-void run(process.argv.slice(2));

package/src/steps/cli-standalone.steps.ts

@@ -1,222 +0,0 @@
-import { resolve } from "node:path";
-import { writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import type { CliServer } from "../cli";
-import { createCliServer } from "../cli";
-
-const feature = await loadFeature("../../features/cli-standalone.feature");
-const fixturesDir = resolve(
-  import.meta.dirname,
-  "../../../openapi/src/__fixtures__",
-);
-
-describeFeature(feature, ({ Scenario }) => {
-  let cliServer: CliServer;
-  let httpResponse: Response;
-  let specPath: string;
-  let seedPath: string;
-  let thrownError: Error | undefined;
-
-  function baseUrl(): string {
-    return `http://${cliServer.hostname}:${cliServer.port}`;
-  }
-
-  Scenario(
-    "Start server from a spec file",
-    ({ Given, When, Then, And }) => {
-      Given("I have a petstore spec file", () => {
-        specPath = resolve(fixturesDir, "petstore-openapi3.json");
-      });
-
-      When("I create a CLI server from the spec", async () => {
-        cliServer = await createCliServer({ spec: specPath, port: 0 });
-      });
-
-      Then("the CLI server should be running", () => {
-        expect(cliServer.port).toBeGreaterThan(0);
-      });
-
-      When("I fetch {string} from the CLI server", async (_, route: string) => {
-        const [, path] = route.split(" ");
-        httpResponse = await fetch(`${baseUrl()}${path}`);
-      });
-
-      Then("the CLI response status should be {int}", (_, status: number) => {
-        expect(httpResponse.status).toBe(status);
-      });
-
-      And("the CLI response body should be an array", async () => {
-        const body = await httpResponse.json();
-        expect(Array.isArray(body)).toBe(true);
-      });
-
-      When("I stop the CLI server", () => {
-        cliServer.close();
-      });
-    },
-  );
-
-  Scenario("Serve with seed data", ({ Given, When, And, Then }) => {
-    Given("I have a petstore spec file", () => {
-      specPath = resolve(fixturesDir, "petstore-openapi3.json");
-    });
-
-    And("I have a seed data file with pets", () => {
-      seedPath = resolve(tmpdir(), `schmock-test-seed-${Date.now()}.json`);
-      const seedData = {
-        pets: [{ id: 1, name: "Buddy", tag: "dog" }],
-      };
-      writeFileSync(seedPath, JSON.stringify(seedData));
-    });
-
-    When("I create a CLI server with seed data", async () => {
-      cliServer = await createCliServer({
-        spec: specPath,
-        port: 0,
-        seed: seedPath,
-      });
-    });
-
-    And("I fetch {string} from the CLI server", async (_, route: string) => {
-      const [, path] = route.split(" ");
-      httpResponse = await fetch(`${baseUrl()}${path}`);
-    });
-
-    Then("the CLI response status should be {int}", (_, status: number) => {
-      expect(httpResponse.status).toBe(status);
-    });
-
-    And("the CLI response body should contain the seeded pet", async () => {
-      const body = await httpResponse.json();
-      expect(Array.isArray(body)).toBe(true);
-      const pets = body as Array<{ name: string }>;
-      expect(pets.some((p) => p.name === "Buddy")).toBe(true);
-    });
-
-    When("I stop the CLI server", () => {
-      cliServer.close();
-    });
-  });
-
-  Scenario("Custom port", ({ Given, When, Then }) => {
-    Given("I have a petstore spec file", () => {
-      specPath = resolve(fixturesDir, "petstore-openapi3.json");
-    });
-
-    When("I create a CLI server on port {int}", async (_, port: number) => {
-      cliServer = await createCliServer({ spec: specPath, port });
-    });
-
-    Then(
-      "the CLI server should be running on port {int}",
-      (_, port: number) => {
-        expect(cliServer.port).toBe(port);
-        cliServer.close();
-      },
-    );
-
-    When("I stop the CLI server", () => {
-      cliServer.close();
-    });
-  });
-
-  Scenario("CORS headers on responses", ({ Given, When, Then, And }) => {
-    Given("I have a petstore spec file", () => {
-      specPath = resolve(fixturesDir, "petstore-openapi3.json");
-    });
-
-    When("I create a CLI server with CORS enabled", async () => {
-      cliServer = await createCliServer({
-        spec: specPath,
-        port: 0,
-        cors: true,
-      });
-    });
-
-    And("I fetch {string} from the CLI server", async (_, route: string) => {
-      const [, path] = route.split(" ");
-      httpResponse = await fetch(`${baseUrl()}${path}`);
-    });
-
-    Then("the CLI response should have CORS headers", () => {
-      expect(httpResponse.headers.get("access-control-allow-origin")).toBe(
-        "*",
-      );
-    });
-
-    When("I stop the CLI server", () => {
-      cliServer.close();
-    });
-  });
-
-  Scenario("CORS preflight OPTIONS request", ({ Given, When, Then, And }) => {
-    Given("I have a petstore spec file", () => {
-      specPath = resolve(fixturesDir, "petstore-openapi3.json");
-    });
-
-    When("I create a CLI server with CORS enabled", async () => {
-      cliServer = await createCliServer({
-        spec: specPath,
-        port: 0,
-        cors: true,
-      });
-    });
-
-    And("I send an OPTIONS preflight to the CLI server", async () => {
-      httpResponse = await fetch(`${baseUrl()}/pets`, {
-        method: "OPTIONS",
-      });
-    });
-
-    Then("the CLI response status should be {int}", (_, status: number) => {
-      expect(httpResponse.status).toBe(status);
-    });
-
-    And("the CLI response should have CORS headers", () => {
-      expect(httpResponse.headers.get("access-control-allow-origin")).toBe(
-        "*",
-      );
-    });
-
-    When("I stop the CLI server", () => {
-      cliServer.close();
-    });
-  });
-
-  Scenario("Missing spec shows usage error", ({ When, Then }) => {
-    When("I create a CLI server without a spec", async () => {
-      try {
-        await createCliServer({ spec: "" });
-        thrownError = undefined;
-      } catch (error) {
-        thrownError = error instanceof Error ? error : new Error(String(error));
-      }
-    });
-
-    Then("the CLI should throw a missing spec error", () => {
-      expect(thrownError).toBeDefined();
-    });
-  });
-
-  Scenario("Invalid spec shows error", ({ Given, When, Then }) => {
-    Given("I have an invalid spec file", () => {
-      specPath = resolve(tmpdir(), `schmock-invalid-${Date.now()}.json`);
-      writeFileSync(specPath, '{ "not": "a spec" }');
-    });
-
-    When("I create a CLI server from the invalid spec", async () => {
-      try {
-        await createCliServer({ spec: specPath });
-        thrownError = undefined;
-      } catch (error) {
-        thrownError = error instanceof Error ? error : new Error(String(error));
-      }
-    });
-
-    Then("the CLI should throw a parse error", () => {
-      expect(thrownError).toBeDefined();
-    });
-  });
-});