counterfact 1.4.9 → 1.5.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

@@ -67,6 +67,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 +86,7 @@ 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>";
+        return `($: OmitValueWhenNever<{ query: ${queryType}, path: ${pathType}, headers: ${headersType}, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "1.4.9",
+  "version": "1.5.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",
@@ -105,7 +105,7 @@
     "eslint-plugin-jest-dom": "5.5.0",
     "eslint-plugin-n": "^17.23.2",
     "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",
@@ -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.0",
     "typescript": "5.9.3"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",