@schmock/cli 2.2.3 → 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.2.3",
+  "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,10 +29,11 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bun build:lib && bun build:types",
-    "build:lib": "bun build --target node --outdir=dist src/index.ts src/bin.ts",
+    "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",
+    "test": "vitest run",
     "test:watch": "vitest --watch",
     "test:bdd": "vitest run --config vitest.config.bdd.ts",
     "lint": "biome check src/*.ts",
@@ -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.2.3",
-    "@schmock/openapi": "^2.2.3"
+    "@schmock/core": "^2.3.1",
+    "@schmock/openapi": "^2.3.1"
   },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^7.0.0",

package/dist/cli.js

@@ -1,263 +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, parseNodeHeaders, parseNodeQuery, schmock, toHttpMethod, writeSchmockResponse, } from "@schmock/core";
-import { openapi } from "@schmock/openapi";
-const CORS_HEADERS = {
-    "access-control-allow-origin": "*",
-    "access-control-allow-methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-    "access-control-allow-headers": "Content-Type, Authorization",
-};
-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" }));
-}
-export async function createCliServer(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);
-    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) => {
-        // 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 path = url.pathname;
-        // Admin API intercept
-        if (admin && path.startsWith("/schmock-admin/")) {
-            const adminHeaders = {
-                "content-type": "application/json",
-                ...(cors ? CORS_HEADERS : {}),
-            };
-            handleAdminRequest(req.method ?? "GET", path, mock, res, adminHeaders);
-            return;
-        }
-        const method = toHttpMethod(req.method ?? "GET");
-        const headers = parseNodeHeaders(req);
-        const query = parseNodeQuery(url);
-        void collectBody(req, headers)
-            .then((body) => mock
-            .handle(method, path, { headers, body, query })
-            .then((schmockResponse) => {
-            const extra = cors ? CORS_HEADERS : undefined;
-            writeSchmockResponse(res, schmockResponse, extra);
-        }))
-            .catch((error) => {
-            if (!res.headersSent) {
-                res.writeHead(500, { "content-type": "application/json" });
-            }
-            res.end(JSON.stringify({
-                error: error instanceof Error ? error.message : "Internal Server Error",
-                code: "SERVER_ERROR",
-            }));
-        });
-    });
-    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();
-                },
-            });
-        });
-    });
-}
-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;
-/**
- * Reload a CLI server: close the old one, create a new one on the same port.
- */
-export async function reloadServer(current, options) {
-    const port = current.port;
-    // Close existing connections and wait for the server to fully close
-    current.server.closeAllConnections();
-    await new Promise((resolve) => {
-        current.server.close(() => resolve());
-    });
-    return createCliServer({ ...options, port });
-}
-/**
- * Watch a spec file and hot-reload the server on changes.
- */
-export function startWatch(specPath, options, getCurrentServer, onReload) {
-    let debounceTimer;
-    const watcher = watch(specPath, () => {
-        if (debounceTimer)
-            clearTimeout(debounceTimer);
-        debounceTimer = setTimeout(async () => {
-            process.stderr.write("\nSpec changed, reloading...\n");
-            try {
-                const newServer = await reloadServer(getCurrentServer(), options);
-                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() {
-            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);
-}