counterfact 1.4.9 → 1.6.0

package/dist/repl/RawHttpClient.js

@@ -0,0 +1,164 @@
+import net from "net";
+const colors = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    bold: "\x1b[1m",
+    magenta: "\x1b[35m",
+    blue: "\x1b[34m",
+};
+function isLikelyJson(headersBlock, body) {
+    const m = headersBlock.match(/^content-type:\s*([^\r\n;]+)/im);
+    const ct = (m?.[1] ?? "").toLowerCase();
+    if (ct.includes("application/json") || ct.includes("+json"))
+        return true;
+    const s = body.trim();
+    if (!s)
+        return false;
+    return ((s.startsWith("{") && s.endsWith("}")) ||
+        (s.startsWith("[") && s.endsWith("]")));
+}
+function highlightJson(text) {
+    let obj;
+    try {
+        obj = JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+    const pretty = JSON.stringify(obj, null, 2);
+    return pretty.replace(/("(?:\\.|[^"\\])*")(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g, (match, str, colon, boolOrNull) => {
+        if (str) {
+            if (colon)
+                return `${colors.blue}${str}${colors.reset}${colon}`;
+            return `${colors.green}${str}${colors.reset}`;
+        }
+        if (boolOrNull) {
+            return `${colors.magenta}${match}${colors.reset}`;
+        }
+        return `${colors.yellow}${match}${colors.reset}`;
+    });
+}
+function stringifyBody(body) {
+    if (typeof body === "string") {
+        return body;
+    }
+    if (typeof body === "undefined") {
+        return body;
+    }
+    return JSON.stringify(body);
+}
+export class RawHttpClient {
+    host;
+    port;
+    requestNumber = 0;
+    constructor(host = "localhost", port = 80) {
+        this.host = host;
+        this.port = port;
+    }
+    get(path, headers = {}) {
+        this.#send("GET", path, "", headers);
+    }
+    head(path, headers = {}) {
+        this.#send("HEAD", path, "", headers);
+    }
+    post(path, body = "", headers = {}) {
+        this.#send("POST", path, body, headers);
+    }
+    put(path, body = "", headers = {}) {
+        this.#send("PUT", path, body, headers);
+    }
+    delete(path, headers = {}) {
+        this.#send("DELETE", path, "", headers);
+    }
+    connect(path, headers = {}) {
+        this.#send("CONNECT", path, "", headers);
+    }
+    options(path, headers = {}) {
+        this.#send("OPTIONS", path, "", headers);
+    }
+    trace(path, headers = {}) {
+        this.#send("TRACE", path, "", headers);
+    }
+    patch(path, body = "", headers = {}) {
+        this.#send("PATCH", path, body, headers);
+    }
+    #send(method, path, bodyAsStringOrObject, headers) {
+        const requestNumber = ++this.requestNumber;
+        const body = stringifyBody(bodyAsStringOrObject);
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection({ host: this.host, port: this.port }, () => {
+                let request = `${method} ${path} HTTP/1.1\r\n`;
+                request += `Host: ${this.host}\r\n`;
+                request += `Connection: close\r\n`;
+                if (body != null) {
+                    request += `Content-Length: ${Buffer.byteLength(body)}\r\n`;
+                }
+                for (const [key, value] of Object.entries(headers)) {
+                    request += `${key}: ${value}\r\n`;
+                }
+                request += `\r\n`;
+                if (body != null)
+                    request += body;
+                this.#printRequest(request, requestNumber);
+                socket.write(request);
+            });
+            const chunks = [];
+            socket.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            socket.on("end", () => {
+                const raw = Buffer.concat(chunks).toString("utf8");
+                this.#printResponse(raw, requestNumber);
+                process.stdout.write(`${colors.bold}⬣> ${colors.reset}`);
+                resolve(raw);
+            });
+            socket.on("error", reject);
+        });
+    }
+    #printRequest(raw, requestNumber) {
+        const [head = "", body = ""] = raw.split("\r\n\r\n");
+        const lines = head.split("\r\n");
+        process.stdout.write(`${colors.cyan}\n----- REQUEST #${requestNumber} -----${colors.reset}\n`);
+        process.stdout.write(`${colors.cyan}${lines[0]}${colors.reset}\n`);
+        for (const line of lines.slice(1)) {
+            process.stdout.write(`${colors.dim}${line}${colors.reset}\n`);
+        }
+        if (body) {
+            process.stdout.write("\n");
+            const outBody = isLikelyJson(head.toLowerCase(), body)
+                ? highlightJson(body)
+                : body;
+            process.stdout.write(outBody + "\n");
+        }
+    }
+    #printResponse(raw, requestNumber) {
+        const [head = "", body = ""] = raw.split("\r\n\r\n");
+        const lines = head.split("\r\n");
+        const statusLine = lines[0] ?? "";
+        let statusColor = colors.green;
+        const match = statusLine.match(/HTTP\/\d+\.\d+\s+(\d+)/);
+        if (match) {
+            const code = Number(match[1]);
+            if (code >= 400)
+                statusColor = colors.red;
+            else if (code >= 300)
+                statusColor = colors.yellow;
+        }
+        process.stdout.write(`\n${statusColor}----- RESPONSE #${requestNumber} -----${colors.reset}\n`);
+        process.stdout.write(`${statusColor}${statusLine}${colors.reset}\n`);
+        for (const line of lines.slice(1)) {
+            process.stdout.write(`${colors.dim}${line}${colors.reset}\n`);
+        }
+        if (body) {
+            process.stdout.write("\n");
+            const outBody = isLikelyJson(head.toLowerCase(), body)
+                ? highlightJson(body)
+                : body;
+            process.stdout.write(outBody + "\n");
+        }
+    }
+}

package/dist/repl/repl.js

@@ -1,4 +1,5 @@
 import repl from "node:repl";
+import { RawHttpClient } from "./RawHttpClient.js";
 function printToStdout(line) {
     process.stdout.write(`${line}\n`);
 }
@@ -80,5 +81,7 @@ export function startRepl(contextRegistry, config, print = printToStdout) {
     });
     replServer.context.loadContext = (path) => contextRegistry.find(path);
     replServer.context.context = replServer.context.loadContext("/");
+    replServer.context.client = new RawHttpClient("localhost", config.port);
+    replServer.context.RawHttpClient = RawHttpClient;
     return replServer;
 }

package/dist/server/counterfact-types/index.ts

@@ -20,6 +20,8 @@ type COUNTERFACT_RESPONSE = typeof counterfactResponseObject;
 
 type MediaType = `${string}/${string}`;
 
+type MaybePromise<T> = T | Promise<T>;
+
 type OmitAll<T, K extends readonly string[]> = {
   [P in keyof T as P extends `${string}${K[number]}${string}`
     ? never
@@ -273,6 +275,7 @@ export type { COUNTERFACT_RESPONSE };
 
 export type {
   HttpStatusCode,
+  MaybePromise,
   MediaType,
   OmitValueWhenNever,
   OpenApiOperation,

package/dist/server/dispatcher.js

@@ -121,10 +121,19 @@ export class Dispatcher {
         }
         const { matchedPath } = this.registry.handler(path, method);
         const operation = this.operationForPathAndMethod(matchedPath, method);
+        const continuousDistribution = (min, max) => {
+            return min + Math.random() * (max - min);
+        };
         const response = await this.registry.endpoint(method, path, this.parameterTypes(operation?.parameters))({
             auth,
             body,
             context: this.contextRegistry.find(matchedPath),
+            async delay(milliseconds = 0, maxMilliseconds = 0) {
+                const delayInMs = maxMilliseconds - milliseconds <= 0
+                    ? milliseconds
+                    : continuousDistribution(milliseconds, maxMilliseconds);
+                return new Promise((resolve) => setTimeout(resolve, delayInMs));
+            },
             headers,
             proxy: async (url) => {
                 if (body !== undefined && headers.contentType !== "application/json") {

package/dist/typescript-generator/operation-coder.js

@@ -1,7 +1,6 @@
 import nodePath from "node:path";
 import { Coder } from "./coder.js";
 import { OperationTypeCoder } from "./operation-type-coder.js";
-import path from "node:path";
 export class OperationCoder extends Coder {
     constructor(requirement, requestMethod, securitySchemes = {}) {
         super(requirement);
@@ -19,11 +18,11 @@ export class OperationCoder extends Coder {
         const [firstStatusCode] = responses.map((response, statusCode) => statusCode);
         const [firstResponse] = responses.map((response) => response.data);
         if (!("content" in firstResponse || "schema" in firstResponse)) {
-            return `($) => {
+            return `async ($) => {
         return $.response[${firstStatusCode === "default" ? 200 : firstStatusCode}];
       }`;
         }
-        return `($) => {
+        return `async ($) => {
       return $.response[${firstStatusCode === "default" ? 200 : firstStatusCode}].random();
     }`;
     }

package/dist/typescript-generator/operation-type-coder.js

@@ -5,6 +5,7 @@ import { READ_ONLY_COMMENTS } from "./read-only-comments.js";
 import { ResponsesTypeCoder } from "./responses-type-coder.js";
 import { SchemaTypeCoder } from "./schema-type-coder.js";
 import { TypeCoder } from "./type-coder.js";
+import { ParameterExportTypeCoder } from "./parameter-export-type-coder.js";
 export class OperationTypeCoder extends TypeCoder {
     constructor(requirement, requestMethod, securitySchemes = []) {
         super(requirement);
@@ -14,9 +15,23 @@ export class OperationTypeCoder extends TypeCoder {
         this.requestMethod = requestMethod;
         this.securitySchemes = securitySchemes;
     }
+    getOperationBaseName() {
+        const operationId = this.requirement.get("operationId")?.data;
+        return operationId || `HTTP_${this.requestMethod.toUpperCase()}`;
+    }
     names() {
         return super.names(`HTTP_${this.requestMethod.toUpperCase()}`);
     }
+    exportParameterType(script, parameterKind, inlineType, baseName, modulePath) {
+        if (inlineType === "never") {
+            return "never";
+        }
+        const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+        const typeName = `${baseName}_${capitalize(parameterKind)}`;
+        const coder = new ParameterExportTypeCoder(this.requirement, typeName, inlineType, parameterKind);
+        coder._modulePath = modulePath;
+        return script.export(coder, true);
+    }
     responseTypes(script) {
         return this.requirement
             .get("responses")
@@ -67,6 +82,7 @@ export class OperationTypeCoder extends TypeCoder {
         script.comments = READ_ONLY_COMMENTS;
         const xType = script.importSharedType("WideOperationArgument");
         script.importSharedType("OmitValueWhenNever");
+        script.importSharedType("MaybePromise");
         script.importSharedType("COUNTERFACT_RESPONSE");
         const contextTypeImportName = script.importExternalType("Context", CONTEXT_FILE_TOKEN);
         const parameters = this.requirement.get("parameters");
@@ -85,6 +101,13 @@ export class OperationTypeCoder extends TypeCoder {
         const responseType = new ResponsesTypeCoder(this.requirement.get("responses"), this.requirement.get("produces")?.data ??
             this.requirement.specification?.rootRequirement?.get("produces")?.data).write(script);
         const proxyType = "(url: string) => COUNTERFACT_RESPONSE";
-        return `($: OmitValueWhenNever<{ query: ${queryType}, path: ${pathType}, headers: ${headersType}, body: ${bodyType}, context: ${contextTypeImportName}, response: ${responseType}, x: ${xType}, proxy: ${proxyType}, user: ${this.userType()} }>) => ${this.responseTypes(script)} | { status: 415, contentType: "text/plain", body: string } | COUNTERFACT_RESPONSE | { ALL_REMAINING_HEADERS_ARE_OPTIONAL: COUNTERFACT_RESPONSE }`;
+        const delayType = "(milliseconds: number, maxMilliseconds?: number) => Promise<void>";
+        // Get the base name for this operation and export parameter types
+        const baseName = this.getOperationBaseName();
+        const modulePath = this.modulePath();
+        const queryTypeName = this.exportParameterType(script, "query", queryType, baseName, modulePath);
+        const pathTypeName = this.exportParameterType(script, "path", pathType, baseName, modulePath);
+        const headersTypeName = this.exportParameterType(script, "headers", headersType, baseName, modulePath);
+        return `($: OmitValueWhenNever<{ query: ${queryTypeName}, path: ${pathTypeName}, headers: ${headersTypeName}, body: ${bodyType}, context: ${contextTypeImportName}, response: ${responseType}, x: ${xType}, proxy: ${proxyType}, user: ${this.userType()}, delay: ${delayType} }>) => MaybePromise<${this.responseTypes(script)} | { status: 415, contentType: "text/plain", body: string } | COUNTERFACT_RESPONSE | { ALL_REMAINING_HEADERS_ARE_OPTIONAL: COUNTERFACT_RESPONSE }>`;
     }
 }

package/dist/typescript-generator/parameter-export-type-coder.js

@@ -0,0 +1,24 @@
+import { TypeCoder } from "./type-coder.js";
+// Helper class for exporting parameter types
+export class ParameterExportTypeCoder extends TypeCoder {
+    constructor(requirement, typeName, typeCode, parameterKind) {
+        super(requirement);
+        this._typeName = typeName;
+        this._typeCode = typeCode;
+        this._parameterKind = parameterKind;
+    }
+    get id() {
+        // Make the id unique by including the parameter kind
+        return `${super.id}:${this._parameterKind}`;
+    }
+    *names() {
+        yield this._typeName;
+    }
+    writeCode() {
+        return this._typeCode;
+    }
+    modulePath() {
+        // Use the same module path as the parent operation
+        return this._modulePath;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "1.4.9",
+  "version": "1.6.0",
   "description": "Generate a TypeScript-based mock server from an OpenAPI spec in seconds — with stateful routes, hot reload, and REPL support.",
   "type": "module",
   "main": "./dist/app.js",
@@ -78,10 +78,10 @@
   },
   "devDependencies": {
     "@changesets/cli": "2.29.8",
-    "@stryker-mutator/core": "9.4.0",
-    "@stryker-mutator/jest-runner": "9.4.0",
-    "@stryker-mutator/typescript-checker": "9.4.0",
-    "@swc/core": "1.15.8",
+    "@stryker-mutator/core": "9.5.1",
+    "@stryker-mutator/jest-runner": "9.5.1",
+    "@stryker-mutator/typescript-checker": "9.5.1",
+    "@swc/core": "1.15.11",
     "@swc/jest": "0.2.39",
     "@testing-library/dom": "10.4.1",
     "@types/debug": "^4.1.12",
@@ -95,26 +95,26 @@
     "@typescript-eslint/eslint-plugin": "^8.53.0",
     "@typescript-eslint/parser": "^8.53.0",
     "copyfiles": "2.4.1",
-    "eslint": "9.39.2",
+    "eslint": "9.39.3",
     "eslint-formatter-github-annotations": "0.1.0",
     "eslint-import-resolver-typescript": "4.4.4",
     "eslint-plugin-etc": "2.0.3",
     "eslint-plugin-file-progress": "3.0.2",
     "eslint-plugin-import": "2.32.0",
-    "eslint-plugin-jest": "29.12.1",
+    "eslint-plugin-jest": "29.15.0",
     "eslint-plugin-jest-dom": "5.5.0",
-    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-n": "^17.24.0",
     "eslint-plugin-no-explicit-type-exports": "0.12.1",
-    "eslint-plugin-prettier": "5.5.4",
+    "eslint-plugin-prettier": "5.5.5",
     "eslint-plugin-promise": "^7.2.1",
-    "eslint-plugin-regexp": "^2.10.0",
-    "eslint-plugin-security": "^3.0.1",
-    "eslint-plugin-unused-imports": "4.3.0",
+    "eslint-plugin-regexp": "^3.0.0",
+    "eslint-plugin-security": "^4.0.0",
+    "eslint-plugin-unused-imports": "4.4.1",
     "husky": "9.1.7",
     "jest": "30.2.0",
     "jest-retries": "1.0.1",
     "node-mocks-http": "1.17.2",
-    "rimraf": "6.1.2",
+    "rimraf": "6.1.3",
     "stryker-cli": "1.1.0",
     "supertest": "7.2.2",
     "tsd": "0.33.0",
@@ -125,7 +125,7 @@
     "@hapi/accept": "6.0.3",
     "@types/json-schema": "7.0.15",
     "chokidar": "5.0.0",
-    "commander": "14.0.2",
+    "commander": "14.0.3",
     "debug": "4.4.3",
     "fetch": "1.1.0",
     "fs-extra": "11.3.3",
@@ -138,12 +138,12 @@
     "koa-bodyparser": "4.4.1",
     "koa-proxies": "0.12.4",
     "koa2-swagger-ui": "5.12.0",
-    "lodash": "4.17.21",
+    "lodash": "4.17.23",
     "node-fetch": "3.3.2",
     "open": "11.0.0",
     "patch-package": "8.0.1",
     "precinct": "12.2.0",
-    "prettier": "3.7.4",
+    "prettier": "3.8.1",
     "typescript": "5.9.3"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",