@schmock/cli 2.3.0 → 2.3.1

package/package.json

@@ -1,8 +1,17 @@
 {
   "name": "@schmock/cli",
   "description": "CLI for running Schmock mock servers from OpenAPI specs",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/khalic-lab/schmock.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/khalic-lab/schmock/tree/main/packages/cli#readme",
+  "bugs": {
+    "url": "https://github.com/khalic-lab/schmock/issues"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
@@ -20,7 +29,8 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bun build:lib && bun build:types",
+    "clean": "rm -rf dist && rm -f tsconfig.tsbuildinfo",
+    "build": "bun run clean && bun run build:lib && bun run build:types",
     "build:lib": "bun build --target node --format esm --outdir=dist src/index.ts src/bin.ts --external @schmock/core --external @schmock/openapi",
     "build:types": "tsc -p tsconfig.json",
     "test": "vitest run",
@@ -31,9 +41,12 @@
     "check:publish": "publint && attw --pack --ignore-rules cjs-resolves-to-esm"
   },
   "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || ^23.5.0 || >=24.0.0"
+  },
   "dependencies": {
-    "@schmock/core": "^2.3.0",
-    "@schmock/openapi": "^2.3.0"
+    "@schmock/core": "^2.3.1",
+    "@schmock/openapi": "^2.3.1"
   },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^7.0.0",

package/dist/cli.js

@@ -1,351 +0,0 @@
-/// <reference path="../../core/schmock.d.ts" />
-import { readFileSync, watch } from "node:fs";
-import { createServer } from "node:http";
-import { parseArgs } from "node:util";
-import { collectBody, HTTP_METHODS, isHttpMethod, parseNodeHeaders, parseNodeQuery, schmock, writeSchmockResponse, } from "@schmock/core";
-import { openapi } from "@schmock/openapi";
-const MAX_REQUEST_BODY_SIZE = 10 * 1024 * 1024;
-const ALLOWED_METHODS = HTTP_METHODS.join(", ");
-const CORS_HEADERS = {
-    "access-control-allow-origin": "*",
-    "access-control-allow-methods": ALLOWED_METHODS,
-    "access-control-allow-headers": "Content-Type, Authorization",
-};
-class CliHttpError extends Error {
-    status;
-    code;
-    headers;
-    constructor(status, code, message, headers = {}) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.headers = headers;
-        this.name = "CliHttpError";
-    }
-}
-function isSeedSource(value) {
-    return (Array.isArray(value) ||
-        typeof value === "string" ||
-        (typeof value === "object" && value !== null && "count" in value));
-}
-function loadSeedFile(seedPath) {
-    const raw = readFileSync(seedPath, "utf-8");
-    const parsed = 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 = {};
-    for (const [key, value] of Object.entries(parsed)) {
-        if (isSeedSource(value)) {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function handleAdminRequest(method, path, mock, res, headers) {
-    const route = path.replace("/schmock-admin/", "");
-    if (method === "GET" && route === "routes") {
-        res.writeHead(200, headers);
-        res.end(JSON.stringify(mock.getRoutes()));
-        return;
-    }
-    if (method === "GET" && route === "state") {
-        res.writeHead(200, headers);
-        res.end(JSON.stringify(mock.getState()));
-        return;
-    }
-    if (method === "POST" && route === "reset") {
-        mock.resetHistory();
-        mock.resetState();
-        res.writeHead(204, headers);
-        res.end();
-        return;
-    }
-    if (method === "GET" && route === "history") {
-        res.writeHead(200, headers);
-        res.end(JSON.stringify(mock.history()));
-        return;
-    }
-    res.writeHead(404, headers);
-    res.end(JSON.stringify({ error: "Unknown admin endpoint", code: "NOT_FOUND" }));
-}
-function parseRequestUrl(req) {
-    const host = req.headers.host;
-    if (!host) {
-        throw new CliHttpError(400, "BAD_REQUEST", "Missing Host header");
-    }
-    try {
-        return new URL(req.url ?? "/", `http://${host}`);
-    }
-    catch {
-        throw new CliHttpError(400, "BAD_REQUEST", "Malformed request target");
-    }
-}
-function parseRequestMethod(req) {
-    const method = (req.method ?? "GET").toUpperCase();
-    if (!isHttpMethod(method)) {
-        throw new CliHttpError(405, "METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`, { allow: ALLOWED_METHODS });
-    }
-    return method;
-}
-function assertBodySize(headers) {
-    const contentLength = headers["content-length"];
-    if (contentLength === undefined)
-        return;
-    const declaredSize = Number(contentLength);
-    if (Number.isFinite(declaredSize) && declaredSize > MAX_REQUEST_BODY_SIZE) {
-        throw new CliHttpError(413, "PAYLOAD_TOO_LARGE", "Request body too large");
-    }
-}
-function toCliHttpError(error) {
-    if (error instanceof CliHttpError)
-        return error;
-    if (error !== null &&
-        typeof error === "object" &&
-        "status" in error &&
-        error.status === 413) {
-        return new CliHttpError(413, "PAYLOAD_TOO_LARGE", error instanceof Error ? error.message : "Request body too large");
-    }
-    return new CliHttpError(500, "SERVER_ERROR", error instanceof Error ? error.message : "Internal Server Error");
-}
-async function handleCliRequest(req, res, mock, options) {
-    try {
-        const url = parseRequestUrl(req);
-        const method = parseRequestMethod(req);
-        const path = url.pathname;
-        if (options.cors && method === "OPTIONS") {
-            res.writeHead(204, CORS_HEADERS);
-            res.end();
-            return;
-        }
-        if (options.admin && path.startsWith("/schmock-admin/")) {
-            const adminHeaders = {
-                "content-type": "application/json",
-                ...(options.cors ? CORS_HEADERS : {}),
-            };
-            handleAdminRequest(method, path, mock, res, adminHeaders);
-            return;
-        }
-        const headers = parseNodeHeaders(req);
-        assertBodySize(headers);
-        const query = parseNodeQuery(url);
-        const body = await collectBody(req, headers, MAX_REQUEST_BODY_SIZE);
-        const schmockResponse = await mock.handle(method, path, {
-            headers,
-            body,
-            query,
-        });
-        const extraHeaders = options.cors ? CORS_HEADERS : undefined;
-        writeSchmockResponse(res, schmockResponse, extraHeaders);
-    }
-    catch (error) {
-        const cliError = toCliHttpError(error);
-        try {
-            if (!res.headersSent) {
-                res.writeHead(cliError.status, {
-                    "content-type": "application/json",
-                    ...(options.cors ? CORS_HEADERS : {}),
-                    ...cliError.headers,
-                });
-            }
-            if (!res.writableEnded) {
-                res.end(JSON.stringify({ error: cliError.message, code: cliError.code }));
-            }
-        }
-        catch {
-            res.destroy();
-        }
-    }
-}
-async function createCliMock(options) {
-    const mock = schmock({ debug: options.debug, state: {} });
-    const openapiOptions = {
-        spec: options.spec,
-        fakerSeed: options.fakerSeed,
-        validateRequests: options.errors,
-    };
-    if (options.seed) {
-        openapiOptions.seed = loadSeedFile(options.seed);
-    }
-    const plugin = await openapi(openapiOptions);
-    mock.pipe(plugin);
-    return mock;
-}
-function listenWithMock(options, mock) {
-    const hostname = options.hostname ?? "127.0.0.1";
-    const port = options.port ?? 3000;
-    const cors = options.cors ?? false;
-    const admin = options.admin ?? false;
-    const httpServer = createServer((req, res) => {
-        void handleCliRequest(req, res, mock, { admin, cors });
-    });
-    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 async function createCliServer(options) {
-    const mock = await createCliMock(options);
-    return listenWithMock(options, mock);
-}
-function validatePort(value) {
-    const port = Number(value);
-    if (!Number.isInteger(port) || port < 0 || port > 65535) {
-        throw new Error(`Invalid port "${value}". Port must be an integer between 0 and 65535.`);
-    }
-    return port;
-}
-export function parseCliArgs(args) {
-    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 },
-            errors: { type: "boolean", default: false },
-            watch: { type: "boolean", default: false },
-            admin: { type: "boolean", default: false },
-            "seed-random": { type: "string" },
-            help: { type: "boolean", short: "h", default: false },
-        },
-        strict: true,
-        allowPositionals: true,
-    });
-    const spec = values.spec ?? positionals[0] ?? "";
-    return {
-        spec,
-        port: values.port ? validatePort(values.port) : undefined,
-        hostname: values.hostname,
-        seed: values.seed,
-        cors: values.cors,
-        debug: values.debug,
-        errors: values.errors,
-        watch: values.watch,
-        admin: values.admin,
-        fakerSeed: values["seed-random"]
-            ? Number(values["seed-random"])
-            : undefined,
-        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
-  --errors            Enable request body validation against spec
-  --watch             Watch spec file and hot-reload on changes
-  --admin             Enable /schmock-admin/* introspection endpoints
-  --seed-random <n>   Seed for deterministic random generation
-  -h, --help          Show this help message
-`;
-const WATCH_DEBOUNCE_MS = 500;
-/**
- * Prepare a replacement before closing the live server, then bind it to the
- * same port. Invalid spec changes therefore leave the current server online.
- */
-export async function reloadServer(current, options) {
-    const port = current.port;
-    const nextOptions = { ...options, port };
-    const replacementMock = await createCliMock(nextOptions);
-    // Close existing connections and wait for the server to fully close
-    current.server.closeAllConnections();
-    await new Promise((resolve) => {
-        current.server.close(() => resolve());
-    });
-    return listenWithMock(nextOptions, replacementMock);
-}
-/**
- * Watch a spec file and hot-reload the server on changes.
- */
-export function startWatch(specPath, options, getCurrentServer, onReload) {
-    let debounceTimer;
-    let closed = false;
-    let reloadQueue = Promise.resolve();
-    const watcher = watch(specPath, () => {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(() => {
-            reloadQueue = reloadQueue.then(async () => {
-                if (closed)
-                    return;
-                process.stderr.write("\nSpec changed, reloading...\n");
-                try {
-                    const newServer = await reloadServer(getCurrentServer(), options);
-                    if (closed) {
-                        newServer.close();
-                        return;
-                    }
-                    onReload(newServer);
-                    process.stderr.write(`Schmock server reloaded on http://${newServer.hostname}:${newServer.port}\n`);
-                }
-                catch (err) {
-                    process.stderr.write(`Reload failed: ${err instanceof Error ? err.message : String(err)}\n`);
-                }
-            });
-        }, WATCH_DEBOUNCE_MS);
-    });
-    return {
-        close() {
-            closed = true;
-            watcher.close();
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-        },
-    };
-}
-export async function run(args) {
-    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;
-    }
-    let 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");
-    }
-    if (options.admin) {
-        process.stderr.write("Admin: enabled (/schmock-admin/*)\n");
-    }
-    let watchHandle;
-    if (options.watch) {
-        watchHandle = startWatch(options.spec, options, () => cliServer, (newServer) => {
-            cliServer = newServer;
-        });
-        process.stderr.write("Watch: enabled\n");
-    }
-    const shutdown = () => {
-        process.stderr.write("\nShutting down...\n");
-        watchHandle?.close();
-        cliServer.close();
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-}