counterfact 2.4.0 → 2.5.1

package/README.md

@@ -206,7 +206,7 @@ npx counterfact@latest [openapi.yaml] [destination] [options]
 | `--proxy-url <url>` | Forward all requests to this URL by default |
 | `--prefix <path>`   | Base path prefix (e.g. `/api/v1`)           |
 
-Run `npx counterfact --help` for the full list of options.
+Run `npx counterfact@latest --help` for the full list of options.
 
 ---
 

package/bin/README.md

@@ -11,7 +11,7 @@ This directory contains the executable script that is run when a developer invok
 ## How It Works
 
 ```
-npx counterfact openapi.yaml ./api [options]
+npx counterfact@latest openapi.yaml ./api [options]
         │
         ▼
 ┌────────────────────────────┐
@@ -40,5 +40,6 @@ npx counterfact openapi.yaml ./api [options]
 | `--spec <path>` | Path or URL to the OpenAPI document (alternative to positional argument) |
 | `--proxy-url <url>` | Forward all unmatched requests to this upstream URL |
 | `--prefix <path>` | Base path prefix for all routes (e.g. `/api/v1`) |
+| `--no-update-check` | Disable the npm update check on startup |
 
-Run `npx counterfact --help` to see the full option list.
+Run `npx counterfact@latest --help` to see the full option list.

package/bin/counterfact.js

@@ -23,6 +23,18 @@ if (Number.parseInt(process.versions.node.split("."), 10) < MIN_NODE_VERSION) {
   process.exit(1);
 }
 
+const packageJson = JSON.parse(
+  await readFile(
+    nodePath.join(
+      nodePath.dirname(fileURLToPath(import.meta.url)),
+      "../package.json",
+    ),
+    "utf8",
+  ),
+);
+
+const CURRENT_VERSION = packageJson.version;
+
 const taglinesFile = await readFile(
   nodePath.join(
     nodePath.dirname(fileURLToPath(import.meta.url)),
@@ -37,6 +49,48 @@ const DEFAULT_PORT = 3100;
 
 const debug = createDebug("counterfact:bin:counterfact");
 
+function isOutdated(current, latest) {
+  const [cMajor, cMinor, cPatch] = current.split(".").map(Number);
+  const [lMajor, lMinor, lPatch] = latest.split(".").map(Number);
+
+  if (lMajor > cMajor) return true;
+  if (lMajor === cMajor && lMinor > cMinor) return true;
+  if (lMajor === cMajor && lMinor === cMinor && lPatch > cPatch) return true;
+
+  return false;
+}
+
+async function checkForUpdates(currentVersion) {
+  if (process.env.CI) {
+    debug("skipping update check in CI environment");
+    return;
+  }
+
+  try {
+    const response = await fetch(
+      "https://registry.npmjs.org/counterfact/latest",
+    );
+
+    if (!response.ok) {
+      debug("update check failed with status %d", response.status);
+      return;
+    }
+
+    const data = await response.json();
+    const latestVersion = data.version;
+
+    if (isOutdated(currentVersion, latestVersion)) {
+      process.stdout.write(
+        `\n⚠️  You're running counterfact ${currentVersion}\n`,
+      );
+      process.stdout.write(`   Latest version is ${latestVersion}\n`);
+      process.stdout.write(`   Run: npx counterfact@latest\n`);
+    }
+  } catch (error) {
+    debug("update check error: %o", error);
+  }
+}
+
 debug("running ./bin/counterfact.js");
 
 function padTagLine(tagLine) {
@@ -102,6 +156,11 @@ async function main(source, destination) {
 
   const options = program.opts();
 
+  const updateCheckPromise =
+    options.updateCheck === false
+      ? Promise.resolve()
+      : checkForUpdates(CURRENT_VERSION);
+
   // --spec takes precedence over the positional [openapi.yaml] argument.
   // When --spec is provided, the [openapi.yaml] positional slot shifts to
   // become the [destination] argument (so `counterfact --spec api.yaml ./api`
@@ -226,6 +285,7 @@ async function main(source, destination) {
     String.raw`   |___ [__] |__| |\|  |  |=== |--< |--- |--| |___  | `,
     "   " + padTagLine(taglines[Math.floor(Math.random() * taglines.length)]),
     "",
+    `   Version       ${CURRENT_VERSION}`,
     `   API Base URL  ${url}`,
     source === "_" ? undefined : `   Swagger UI    ${swaggerUrl}`,
     "",
@@ -254,6 +314,8 @@ async function main(source, destination) {
   await start(config);
   debug("started server");
 
+  await updateCheckPromise;
+
   if (config.startRepl) {
     startRepl();
   }
@@ -346,5 +408,6 @@ program
     "--spec <string>",
     "path or URL to OpenAPI document (alternative to the positional [openapi.yaml] argument)",
   )
+  .option("--no-update-check", "disable the npm update check on startup")
   .action(main)
   .parse(process.argv);

package/dist/migrate/update-route-types.js

@@ -1,7 +1,7 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import createDebug from "debug";
-import { OperationTypeCoder } from "../typescript-generator/operation-type-coder.js";
+import { OperationTypeCoder, } from "../typescript-generator/operation-type-coder.js";
 import { Specification } from "../typescript-generator/specification.js";
 const debug = createDebug("counterfact:migrate:update-route-types");
 const HTTP_METHODS = [
@@ -25,8 +25,8 @@ function openApiPathToFilePath(openApiPath) {
 }
 /**
  * Builds a mapping of route file paths to their operation type names per method
- * @param {Specification} specification - The OpenAPI specification
- * @returns {Promise<Map<string, Map<string, string>>>} - Map of filePath -> Map of method -> typeName
+ * @param specification - The OpenAPI specification
+ * @returns Map of filePath -> Map of method -> typeName
  */
 async function buildTypeNameMapping(specification) {
     debug("building type name mapping from specification");
@@ -68,8 +68,7 @@ async function buildTypeNameMapping(specification) {
 }
 /**
  * Checks if a route file needs migration by looking for old-style HTTP_ imports
- * @param {string} content - The file content
- * @returns {boolean}
+ * @param content - The file content
  */
 function needsMigration(content) {
     const methodAlternation = HTTP_METHODS.map((method) => method.toUpperCase()).join("|");
@@ -78,9 +77,9 @@ function needsMigration(content) {
 }
 /**
  * Updates a single route file with the correct type names
- * @param {string} filePath - Absolute path to the route file
- * @param {Map<string, string>} methodToTypeName - Map of HTTP method to type name
- * @returns {Promise<boolean>} - True if file was updated
+ * @param filePath - Absolute path to the route file
+ * @param methodToTypeName - Map of HTTP method to type name
+ * @returns True if file was updated
  */
 async function updateRouteFile(filePath, methodToTypeName) {
     debug("processing route file: %s", filePath);
@@ -97,7 +96,7 @@ async function updateRouteFile(filePath, methodToTypeName) {
     const importRegex = /import\s+type\s+\{(?<types>[^}]+)\}\s+from\s+["'][^"']+["'];?/gu;
     let importMatch;
     while ((importMatch = importRegex.exec(content)) !== null) {
-        const importedTypes = importMatch.groups.types
+        const importedTypes = (importMatch.groups?.["types"] ?? "")
             .split(",")
             .map((t) => t.trim())
             .filter((t) => t.length > 0);
@@ -105,7 +104,7 @@ async function updateRouteFile(filePath, methodToTypeName) {
             // Check if this is an HTTP_ type
             const httpMethodMatch = importedType.match(new RegExp(`^HTTP_(?<method>${HTTP_METHODS.join("|")})$`, "u"));
             if (httpMethodMatch) {
-                const method = httpMethodMatch.groups.method;
+                const method = httpMethodMatch.groups?.["method"] ?? "";
                 const newTypeName = methodToTypeName.get(method);
                 if (newTypeName && newTypeName !== importedType) {
                     replacements.set(importedType, newTypeName);
@@ -127,7 +126,7 @@ async function updateRouteFile(filePath, methodToTypeName) {
         // Match the method from the old type name
         const methodMatch = oldName.match(new RegExp(`^HTTP_(?<method>${HTTP_METHODS.join("|")})$`, "u"));
         if (methodMatch) {
-            const method = methodMatch.groups.method;
+            const method = methodMatch.groups?.["method"] ?? "";
             const exportPattern = new RegExp(`(export\\s+const\\s+${method}\\s*:\\s*)${oldName}(\\b)`, "g");
             content = content.replace(exportPattern, `$1${newName}$2`);
         }
@@ -141,10 +140,10 @@ async function updateRouteFile(filePath, methodToTypeName) {
 }
 /**
  * Recursively processes route files in a directory
- * @param {string} routesDir - Path to routes directory
- * @param {string} currentPath - Current subdirectory being processed
- * @param {Map<string, Map<string, string>>} mapping - Type name mapping
- * @returns {Promise<number>} - Number of files updated
+ * @param routesDir - Path to routes directory
+ * @param currentPath - Current subdirectory being processed
+ * @param mapping - Type name mapping
+ * @returns Number of files updated
  */
 async function processRouteDirectory(routesDir, currentPath, mapping) {
     let updatedCount = 0;
@@ -183,8 +182,7 @@ async function processRouteDirectory(routesDir, currentPath, mapping) {
 }
 /**
  * Checks if any route files need migration
- * @param {string} routesDir - Path to routes directory
- * @returns {Promise<boolean>}
+ * @param routesDir - Path to routes directory
  */
 async function checkIfMigrationNeeded(routesDir) {
     try {
@@ -213,9 +211,9 @@ async function checkIfMigrationNeeded(routesDir) {
 }
 /**
  * Main migration function - updates route type imports to use new naming convention
- * @param {string} basePath - Base path where routes and types are located
- * @param {string} openApiPath - Path or URL to OpenAPI specification
- * @returns {Promise<boolean>} - True if migration was performed
+ * @param basePath - Base path where routes and types are located
+ * @param openApiPath - Path or URL to OpenAPI specification
+ * @returns True if migration was performed
  */
 export async function updateRouteTypes(basePath, openApiPath) {
     debug("starting route type migration for base path: %s", basePath);

package/dist/repl/{RawHttpClient.js → raw-http-client.js}

@@ -89,6 +89,12 @@ export class RawHttpClient {
     #send(method, path, bodyAsStringOrObject, headers) {
         const requestNumber = ++this.requestNumber;
         const body = stringifyBody(bodyAsStringOrObject);
+        const effectiveHeaders = { ...headers };
+        if (typeof bodyAsStringOrObject === "object" &&
+            bodyAsStringOrObject !== null &&
+            !Object.keys(effectiveHeaders).some((k) => k.toLowerCase() === "content-type")) {
+            effectiveHeaders["Content-Type"] = "application/json";
+        }
         return new Promise((resolve, reject) => {
             const socket = net.createConnection({ host: this.host, port: this.port }, () => {
                 let request = `${method} ${path} HTTP/1.1\r\n`;
@@ -97,7 +103,7 @@ export class RawHttpClient {
                 if (body != null) {
                     request += `Content-Length: ${Buffer.byteLength(body)}\r\n`;
                 }
-                for (const [key, value] of Object.entries(headers)) {
+                for (const [key, value] of Object.entries(effectiveHeaders)) {
                     request += `${key}: ${value}\r\n`;
                 }
                 request += `\r\n`;

package/dist/repl/repl.js

@@ -1,5 +1,5 @@
 import repl from "node:repl";
-import { RawHttpClient } from "./RawHttpClient.js";
+import { RawHttpClient } from "./raw-http-client.js";
 function printToStdout(line) {
     process.stdout.write(`${line}\n`);
 }

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

@@ -1,4 +1,4 @@
-import { OpenApiHeader } from "./OpenApiHeader";
+import { OpenApiHeader } from "./open-api-header";
 
 interface OpenApiContent {
   schema: unknown;

package/dist/server/koa-middleware.js

@@ -19,10 +19,10 @@ const HEADERS_TO_DROP = new Set([
     "trailer",
     "trailers",
 ]);
-function addCors(ctx, headers) {
+function addCors(ctx, allowedMethods, headers) {
     // Always append CORS headers, reflecting back the headers requested if any
     ctx.set("Access-Control-Allow-Origin", headers?.origin ?? "*");
-    ctx.set("Access-Control-Allow-Methods", "GET,HEAD,PUT,POST,DELETE,PATCH");
+    ctx.set("Access-Control-Allow-Methods", allowedMethods);
     ctx.set("Access-Control-Allow-Headers", headers?.["access-control-request-headers"] ?? []);
     ctx.set("Access-Control-Expose-Headers", headers?.["access-control-request-headers"] ?? []);
     ctx.set("Access-Control-Allow-Credentials", "true");
@@ -55,7 +55,7 @@ export function koaMiddleware(dispatcher, config, proxy = koaProxy) {
         if (isProxyEnabledForPath(path, config) && proxyUrl) {
             return proxy("/", { changeOrigin: true, target: proxyUrl })(ctx, next);
         }
-        addCors(ctx, headers);
+        addCors(ctx, dispatcher.registry.allowedMethods(path), headers);
         if (method === "OPTIONS") {
             ctx.status = HTTP_STATUS_CODE_OK;
             return undefined;

package/dist/server/module-loader.js

@@ -55,6 +55,7 @@ export class ModuleLoader extends EventTarget {
             if (eventName === "unlink") {
                 this.registry.remove(url);
                 this.dispatchEvent(new Event("remove"));
+                return;
             }
             const dependencies = this.dependencyGraph.dependentsOf(pathName);
             void this.loadEndpoint(pathName);
@@ -102,9 +103,39 @@ export class ModuleLoader extends EventTarget {
             const doImport = (await determineModuleKind(pathName)) === "commonjs"
                 ? uncachedRequire
                 : uncachedImport;
-            const endpoint = (await doImport(pathName).catch(() => {
-                console.log("ERROR");
+            let importError;
+            const endpoint = (await doImport(pathName).catch((error) => {
+                importError = error;
             }));
+            if (importError !== undefined) {
+                const isSyntaxError = importError instanceof SyntaxError ||
+                    String(importError).startsWith("SyntaxError:");
+                const displayPath = nodePath
+                    .relative(process.cwd(), unescapePathForWindows(pathName))
+                    .replaceAll("\\", "/");
+                const message = isSyntaxError
+                    ? `There is a syntax error in the route file: ${displayPath}`
+                    : `There was an error loading the route file: ${displayPath}`;
+                const errorResponse = () => ({
+                    body: message,
+                    status: 500,
+                });
+                this.registry.add(url, {
+                    DELETE: errorResponse,
+                    GET: errorResponse,
+                    HEAD: errorResponse,
+                    OPTIONS: errorResponse,
+                    PATCH: errorResponse,
+                    POST: errorResponse,
+                    PUT: errorResponse,
+                    TRACE: errorResponse,
+                });
+                this.dispatchEvent(new Event("add"));
+                return;
+            }
+            if (!endpoint) {
+                return;
+            }
             this.dispatchEvent(new Event("add"));
             if (basename(pathName).startsWith("_.context.") &&
                 isContextModule(endpoint)) {

package/dist/server/uncached-require.cjs

@@ -2,9 +2,13 @@
 
 module.exports = {
   uncachedRequire: function uncachedRequire(moduleName) {
-    delete require.cache[require.resolve(moduleName)];
+    try {
+      delete require.cache[require.resolve(moduleName)];
 
-    // eslint-disable-next-line security/detect-non-literal-require
-    return Promise.resolve(require(moduleName));
+      // eslint-disable-next-line security/detect-non-literal-require
+      return Promise.resolve(require(moduleName));
+    } catch (error) {
+      return Promise.reject(error);
+    }
   },
 };

package/dist/typescript-generator/coder.js

@@ -1,14 +1,15 @@
 export class Coder {
+    requirement;
     constructor(requirement) {
         this.requirement = requirement;
     }
     get id() {
         if (this.requirement.isReference) {
-            return `${this.constructor.name}@${this.requirement.$ref}`;
+            return `${this.constructor.name}@${this.requirement.data["$ref"]}`;
         }
         return `${this.constructor.name}@${this.requirement.url}`;
     }
-    beforeExport() {
+    beforeExport(_path) {
         return "";
     }
     write(script) {
@@ -17,7 +18,7 @@ export class Coder {
         }
         return this.writeCode(script);
     }
-    writeCode() {
+    writeCode(_script) {
         throw new Error("write() is abstract and should be overwritten by a subclass");
     }
     async delegate() {
@@ -39,7 +40,7 @@ export class Coder {
             yield name + index;
         }
     }
-    typeDeclaration() {
+    typeDeclaration(_namespace, _script) {
         return "";
     }
     modulePath() {

package/dist/typescript-generator/generate.js

@@ -27,7 +27,7 @@ async function getPathsFromSpecification(specification) {
     }
     catch (error) {
         process.stderr.write(`Could not find #/paths in the specification.\n${error}\n`);
-        return new Set();
+        return undefined;
     }
 }
 export async function generate(source, destination, generateOptions, repository = new Repository()) {
@@ -40,10 +40,10 @@ export async function generate(source, destination, generateOptions, repository
     debug("created specification: $o", specification);
     debug("reading the #/paths from the specification");
     const paths = await getPathsFromSpecification(specification);
-    debug("got %i paths", paths.size);
+    debug("got %i paths", paths?.map?.length ?? 0);
     if (generateOptions.prune && generateOptions.routes) {
         debug("pruning defunct route files");
-        await pruneRoutes(destination, paths.keys());
+        await pruneRoutes(destination, paths.map((_v, key) => key));
         debug("done pruning");
     }
     const securityRequirement = specification.getRequirement("#/components/securitySchemes");

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

@@ -1,8 +1,10 @@
 import nodePath from "node:path";
 import { Coder } from "./coder.js";
-import { OperationTypeCoder } from "./operation-type-coder.js";
+import { OperationTypeCoder, } from "./operation-type-coder.js";
 export class OperationCoder extends Coder {
-    constructor(requirement, requestMethod, securitySchemes = {}) {
+    requestMethod;
+    securitySchemes;
+    constructor(requirement, requestMethod, securitySchemes = []) {
         super(requirement);
         if (requestMethod === undefined) {
             throw new Error("requestMethod is required");
@@ -15,9 +17,10 @@ export class OperationCoder extends Coder {
     }
     write() {
         const responses = this.requirement.get("responses");
-        const [firstStatusCode] = responses.map((response, statusCode) => statusCode);
+        const [firstStatusCode] = responses.map((_response, statusCode) => statusCode);
         const [firstResponse] = responses.map((response) => response.data);
-        if (!("content" in firstResponse || "schema" in firstResponse)) {
+        if (firstResponse === undefined ||
+            !("content" in firstResponse || "schema" in firstResponse)) {
             return `async ($) => {
         return $.response[${firstStatusCode === "default" ? 200 : firstStatusCode}];
       }`;
@@ -26,7 +29,7 @@ export class OperationCoder extends Coder {
       return $.response[${firstStatusCode === "default" ? 200 : firstStatusCode}].random();
     }`;
     }
-    typeDeclaration(namespace, script) {
+    typeDeclaration(_namespace, script) {
         const operationTypeCoder = new OperationTypeCoder(this.requirement, this.requestMethod, this.securitySchemes);
         return script.importType(operationTypeCoder);
     }

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

@@ -1,11 +1,61 @@
 import nodePath from "node:path";
 import { CONTEXT_FILE_TOKEN } from "./context-file-token.js";
+import { ParameterExportTypeCoder } from "./parameter-export-type-coder.js";
 import { ParametersTypeCoder } from "./parameters-type-coder.js";
 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";
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#reserved_words
+const RESERVED_WORDS = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "await",
+    "enum",
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "type",
+]);
 function sanitizeIdentifier(value) {
     // Treat any run of non-identifier characters as a camelCase separator
     let result = value.replaceAll(/[^\w$]+(?<next>.)/gu, (_, char) => char.toUpperCase());
@@ -15,9 +65,15 @@ function sanitizeIdentifier(value) {
     if (/^\d/u.test(result)) {
         result = `_${result}`;
     }
+    // If the identifier is a reserved word, append an underscore
+    if (RESERVED_WORDS.has(result)) {
+        result = `${result}_`;
+    }
     return result || "_";
 }
 export class OperationTypeCoder extends TypeCoder {
+    requestMethod;
+    securitySchemes;
     constructor(requirement, requestMethod, securitySchemes = []) {
         super(requirement);
         if (requestMethod === undefined) {
@@ -56,19 +112,22 @@ export class OperationTypeCoder extends TypeCoder {
                 return response.get("content").map((content, contentType) => `{  
               status: ${status}, 
               contentType?: "${contentType}",
-              body?: ${new SchemaTypeCoder(content.get("schema")).write(script)}
+              body?: ${content.has("schema") ? new SchemaTypeCoder(content.get("schema")).write(script) : "unknown"}
             }`);
             }
             if (response.has("schema")) {
-                const produces = this.requirement?.get("produces")?.data ??
-                    this.requirement.specification.rootRequirement.get("produces").data;
-                return produces
-                    .map((contentType) => `{
+                const producesReq = this.requirement?.get("produces") ??
+                    this.requirement.specification?.rootRequirement?.get("produces");
+                const produces = producesReq?.data;
+                if (produces) {
+                    return produces
+                        .map((contentType) => `{
             status: ${status},
             contentType?: "${contentType}",
             body?: ${new SchemaTypeCoder(response.get("schema")).write(script)}
           }`)
-                    .join(" | ");
+                        .join(" | ");
+                }
             }
             return `{  
           status: ${status} 
@@ -103,17 +162,18 @@ export class OperationTypeCoder extends TypeCoder {
         const pathType = new ParametersTypeCoder(parameters, "path").write(script);
         const headersType = new ParametersTypeCoder(parameters, "header").write(script);
         const cookieType = new ParametersTypeCoder(parameters, "cookie").write(script);
-        const bodyRequirement = this.requirement.get("consumes") ||
-            this.requirement.specification?.rootRequirement?.get("consumes")
+        const bodyRequirement = (this.requirement.get("consumes") ??
+            this.requirement.specification?.rootRequirement?.get("consumes"))
             ? parameters
-                ?.find((parameter) => ["body", "formData"].includes(parameter.get("in").data))
+                ?.find((parameter) => ["body", "formData"].includes(parameter.get("in")?.data))
                 ?.get("schema")
             : this.requirement.select("requestBody/content/application~1json/schema");
         const bodyType = bodyRequirement === undefined
             ? "never"
             : new SchemaTypeCoder(bodyRequirement).write(script);
-        const responseType = new ResponsesTypeCoder(this.requirement.get("responses"), this.requirement.get("produces")?.data ??
-            this.requirement.specification?.rootRequirement?.get("produces")?.data).write(script);
+        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";
         const delayType = "(milliseconds: number, maxMilliseconds?: number) => Promise<void>";
         // Get the base name for this operation and export parameter types

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

@@ -1,6 +1,9 @@
 import { TypeCoder } from "./type-coder.js";
-// Helper class for exporting parameter types
 export class ParameterExportTypeCoder extends TypeCoder {
+    _typeName;
+    _typeCode;
+    _parameterKind;
+    _modulePath;
     constructor(requirement, typeName, typeCode, parameterKind) {
         super(requirement);
         this._typeName = typeName;

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

@@ -2,6 +2,7 @@ import nodePath from "node:path";
 import { SchemaTypeCoder } from "./schema-type-coder.js";
 import { TypeCoder } from "./type-coder.js";
 export class ParametersTypeCoder extends TypeCoder {
+    placement;
     constructor(requirement, placement) {
         super(requirement);
         this.placement = placement;

package/dist/typescript-generator/prune.js

@@ -5,9 +5,9 @@ const debug = createDebug("counterfact:typescript-generator:prune");
 /**
  * Collects all .ts route files in a directory recursively.
  * Context files (_.context.ts) are excluded.
- * @param {string} routesDir - Path to routes directory
- * @param {string} currentPath - Current subdirectory being processed (relative to routesDir)
- * @returns {Promise<string[]>} - Array of relative paths (using forward slashes)
+ * @param routesDir - Path to routes directory
+ * @param currentPath - Current subdirectory being processed (relative to routesDir)
+ * @returns Array of relative paths (using forward slashes)
  */
 async function collectRouteFiles(routesDir, currentPath = "") {
     const files = [];
@@ -37,8 +37,8 @@ async function collectRouteFiles(routesDir, currentPath = "") {
 }
 /**
  * Recursively removes empty directories under rootDir, but not rootDir itself.
- * @param {string} dir - Directory to check
- * @param {string} rootDir - Root directory that should never be removed
+ * @param dir - Directory to check
+ * @param rootDir - Root directory that should never be removed
  */
 async function removeEmptyDirectories(dir, rootDir) {
     let entries;
@@ -65,8 +65,7 @@ async function removeEmptyDirectories(dir, rootDir) {
 /**
  * Converts an OpenAPI path to the expected route file path (relative to routesDir).
  * e.g. "/pet/{id}" -> "pet/{id}.ts", "/" -> "index.ts"
- * @param {string} openApiPath
- * @returns {string}
+ * @param openApiPath - The OpenAPI path string
  */
 function openApiPathToRouteFile(openApiPath) {
     const filePath = openApiPath === "/" ? "index" : openApiPath.slice(1);
@@ -75,9 +74,9 @@ function openApiPathToRouteFile(openApiPath) {
 /**
  * Prunes route files that no longer correspond to any path in the OpenAPI spec.
  * Context files (_.context.ts) are never pruned.
- * @param {string} destination - Base destination directory (contains the routes/ sub-directory)
- * @param {Iterable<string>} openApiPaths - Iterable of OpenAPI path strings (e.g. "/pet/{id}")
- * @returns {Promise<number>} - Number of files removed
+ * @param destination - Base destination directory (contains the routes/ sub-directory)
+ * @param openApiPaths - Iterable of OpenAPI path strings (e.g. "/pet/{id}")
+ * @returns Number of files removed
  */
 export async function pruneRoutes(destination, openApiPaths) {
     const routesDir = nodePath.join(destination, "routes");

package/dist/typescript-generator/repository.js

@@ -11,6 +11,7 @@ const debug = createDebug("counterfact:server:repository");
 const __dirname = dirname(fileURLToPath(import.meta.url)).replaceAll("\\", "/");
 debug("dirname is %s", __dirname);
 export class Repository {
+    scripts;
     constructor() {
         this.scripts = new Map();
     }
@@ -37,7 +38,6 @@ export class Repository {
         if (!existsSync(sourcePath)) {
             return false;
         }
-        // eslint-disable-next-line n/no-unsupported-features/node-builtins
         return fs.cp(sourcePath, destinationPath, { recursive: true });
     }
     async writeFiles(destination, { routes, types }) {

package/dist/typescript-generator/requirement.js

@@ -1,14 +1,17 @@
 export class Requirement {
+    data;
+    url;
+    specification;
     constructor(data, url = "", specification = undefined) {
         this.data = data;
         this.url = url;
         this.specification = specification;
     }
     get isReference() {
-        return this.data?.$ref !== undefined;
+        return this.data["$ref"] !== undefined;
     }
     reference() {
-        return this.specification.getRequirement(this.data.$ref);
+        return this.specification.getRequirement(this.data["$ref"]);
     }
     has(item) {
         if (this.isReference) {
@@ -20,19 +23,21 @@ export class Requirement {
         if (this.isReference) {
             return this.reference().get(item);
         }
-        if (!this.has(item)) {
+        const key = String(item);
+        if (!this.has(key)) {
             return undefined;
         }
-        return new Requirement(this.data[item], `${this.url}/${this.escapeJsonPointer(item)}`, this.specification);
+        return new Requirement(this.data[key], `${this.url}/${this.escapeJsonPointer(key)}`, this.specification);
     }
     select(path) {
         const parts = path
             .split("/")
-            .map(this.unescapeJsonPointer)
+            .map((p) => this.unescapeJsonPointer(p))
             // Unescape URL encoded characters (e.g. %20 -> " ")
             // Technically we should not be unescaping, but it came up in https://github.com/pmcelhaney/counterfact/issues/1083
             // and I can't think of a reason anyone would intentionally put a % in a key name.
             .map(unescape);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
         let result = this;
         for (const part of parts) {
             result = result.get(part);

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

@@ -2,19 +2,22 @@ import { printObject } from "./printers.js";
 import { SchemaTypeCoder } from "./schema-type-coder.js";
 import { TypeCoder } from "./type-coder.js";
 export class ResponseTypeCoder extends TypeCoder {
+    openApi2MediaTypes;
     constructor(requirement, openApi2MediaTypes = []) {
         super(requirement);
         this.openApi2MediaTypes = openApi2MediaTypes;
     }
     names() {
-        return super.names(this.requirement.data.$ref.split("/").at(-1));
+        return super.names(this.requirement.data["$ref"].split("/").at(-1));
     }
     buildContentObjectType(script, response) {
         if (response.has("content")) {
-            return response.get("content").map((content, mediaType) => [
+            return response
+                .get("content")
+                .map((content, mediaType) => [
                 mediaType,
                 `{ 
-            schema:  ${new SchemaTypeCoder(content.get("schema")).write(script)}
+            schema:  ${content.has("schema") ? new SchemaTypeCoder(content.get("schema")).write(script) : "unknown"}
          }`,
             ]);
         }
@@ -46,8 +49,10 @@ export class ResponseTypeCoder extends TypeCoder {
         return printObject(this.buildHeaders(script, response));
     }
     printRequiredHeaders(response) {
-        const requiredHeaders = (response.get("headers") ?? [])
-            .map((value, name) => ({ name, required: value.data.required }))
+        const requiredHeaders = (response.get("headers")?.map((value, name) => ({
+            name,
+            required: value.data.required,
+        })) ?? [])
             .filter(({ required }) => required)
             .map(({ name }) => `"${name}"`);
         return requiredHeaders.length === 0 ? "never" : requiredHeaders.join(" | ");
@@ -72,7 +77,7 @@ export class ResponseTypeCoder extends TypeCoder {
         return printObject(exampleNames.map((name) => [name, "unknown"]));
     }
     modulePath() {
-        return `types/${this.requirement.data.$ref}.ts`;
+        return `types/${this.requirement.data["$ref"]}.ts`;
     }
     writeCode(script) {
         return `{

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

@@ -2,6 +2,7 @@ import { printObjectWithoutQuotes } from "./printers.js";
 import { ResponseTypeCoder } from "./response-type-coder.js";
 import { TypeCoder } from "./type-coder.js";
 export class ResponsesTypeCoder extends TypeCoder {
+    openApi2MediaTypes;
     constructor(requirement, openApi2MediaTypes = []) {
         super(requirement);
         this.openApi2MediaTypes = openApi2MediaTypes;

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

@@ -2,13 +2,13 @@ import { Coder } from "./coder.js";
 function scrubSchema(schema) {
     // remove properties that are not valid in JSON Schema 6 and not useful anyway
     const cleaned = { ...schema };
-    delete cleaned.example;
-    delete cleaned.xml;
+    delete cleaned["example"];
+    delete cleaned["xml"];
     return cleaned;
 }
 export class SchemaCoder extends Coder {
     names() {
-        return super.names(`${this.requirement.data.$ref.split("/").at(-1)}Schema`);
+        return super.names(`${this.requirement.data["$ref"].split("/").at(-1)}Schema`);
     }
     objectSchema(script) {
         const { properties, required } = this.requirement.data;
@@ -30,11 +30,11 @@ export class SchemaCoder extends Coder {
         items: ${new SchemaCoder(this.requirement.get("items")).write(script)}
       }`;
     }
-    typeDeclaration(namespace, script) {
+    typeDeclaration(_namespace, script) {
         return script.importExternalType("JSONSchema6", "json-schema");
     }
     modulePath() {
-        return `types/${this.requirement.data.$ref}.ts`;
+        return `types/${this.requirement.data["$ref"]}.ts`;
     }
     writeCode(script) {
         const { type } = this.requirement.data;

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

@@ -1,7 +1,7 @@
 import { TypeCoder } from "./type-coder.js";
 export class SchemaTypeCoder extends TypeCoder {
     names() {
-        return super.names(this.requirement.data.$ref.split("/").at(-1));
+        return super.names(this.requirement.data["$ref"]?.split("/").at(-1));
     }
     additionalPropertiesType(script) {
         const { additionalProperties, properties } = this.requirement.data;
@@ -16,13 +16,15 @@ export class SchemaTypeCoder extends TypeCoder {
     }
     objectSchema(script) {
         const { data } = this.requirement;
-        const properties = Object.keys(data.properties ?? {}).map((name) => {
+        const typedData = data;
+        const properties = Object.keys(typedData.properties ?? {}).map((name) => {
             const property = this.requirement.get("properties").get(name);
-            const isRequired = data.required?.includes(name) || property.data.required === true;
+            const propertyData = property.data;
+            const isRequired = typedData.required?.includes(name) || propertyData.required === true;
             const optionalFlag = isRequired ? "" : "?";
             return `"${name}"${optionalFlag}: ${new SchemaTypeCoder(property).write(script)}`;
         });
-        if (data.additionalProperties) {
+        if (typedData.additionalProperties) {
             properties.push(`[key: string]: ${this.additionalPropertiesType(script)}`);
         }
         return `{${properties.join(",")}}`;
@@ -37,11 +39,13 @@ export class SchemaTypeCoder extends TypeCoder {
         if (value === null) {
             return "null";
         }
-        return value;
+        return String(value);
     }
     writeType(script, type) {
         if (Array.isArray(type)) {
-            return type.map((item) => this.writeType(script, item)).join(" | ");
+            return type
+                .map((item) => this.writeType(script, item))
+                .join(" | ");
         }
         if (typeof type !== "string") {
             return "unknown";
@@ -57,7 +61,7 @@ export class SchemaTypeCoder extends TypeCoder {
         }
         return type ?? "unknown";
     }
-    writeGroup(script, { allOf, anyOf, oneOf }) {
+    writeGroup(script, { allOf, anyOf, oneOf, }) {
         function matchingKey() {
             if (allOf) {
                 return "allOf";
@@ -67,19 +71,20 @@ export class SchemaTypeCoder extends TypeCoder {
             }
             return "oneOf";
         }
-        const types = (allOf ?? anyOf ?? oneOf).map((item, index) => new SchemaTypeCoder(this.requirement.get(matchingKey()).get(index)).write(script));
+        const key = matchingKey();
+        const items = (allOf ?? anyOf ?? oneOf);
+        const types = items.map((_item, index) => new SchemaTypeCoder(this.requirement.get(key).get(index)).write(script));
         return types.join(allOf ? " & " : " | ");
     }
-    writeEnum(script, requirement) {
+    writeEnum(_script, requirement) {
         return requirement.data
             .map((item) => this.writePrimitive(item))
             .join(" | ");
     }
     modulePath() {
-        return `types/${this.requirement.data.$ref.replace(/^#\//u, "")}.ts`;
+        return `types/${this.requirement.data["$ref"].replace(/^#\//u, "")}.ts`;
     }
     writeCode(script) {
-        // script.comments = READ_ONLY_COMMENTS;
         const { allOf, anyOf, oneOf, type, format } = this.requirement.data;
         if (allOf ?? anyOf ?? oneOf) {
             return this.writeGroup(script, { allOf, anyOf, oneOf });

package/dist/typescript-generator/script.js

@@ -1,8 +1,17 @@
 import nodePath from "node:path";
 import createDebugger from "debug";
 import { format } from "prettier";
+import { escapePathForWindows } from "../util/windows-escape.js";
 const debug = createDebugger("counterfact:typescript-generator:script");
 export class Script {
+    repository;
+    comments;
+    exports;
+    imports;
+    externalImport;
+    cache;
+    typeCache;
+    path;
     constructor(repository, path) {
         this.repository = repository;
         this.comments = [];
@@ -53,6 +62,7 @@ export class Script {
             .catch((error) => {
             exportStatement.code = `{/* error creating export "${name}" for ${this.path}: ${error.stack} */}`;
             exportStatement.error = error;
+            return undefined;
         })
             .finally(() => {
             exportStatement.done = true;
@@ -117,23 +127,25 @@ export class Script {
     }
     importStatements() {
         return Array.from(this.imports, ([name, { isDefault, isType, script }]) => {
-            const resolvedPath = nodePath
+            const resolvedPath = escapePathForWindows(nodePath
                 .relative(nodePath.dirname(this.path).replaceAll("\\", "/"), script.path.replace(/\.ts$/u, ".js"))
-                .replaceAll("\\", "/");
+                .replaceAll("\\", "/"));
             return `import${isType ? " type" : ""} ${isDefault ? name : `{ ${name} }`} from "${resolvedPath.includes("../") ? "" : "./"}${resolvedPath}";`;
         });
     }
     exportStatements() {
         return Array.from(this.exports.values(), ({ beforeExport, code, isDefault, isType, name, typeDeclaration }) => {
-            if (code.raw) {
+            if (typeof code === "object" && code !== null && "raw" in code) {
                 return code.raw;
             }
             if (isDefault) {
                 return `${beforeExport}export default ${code};`;
             }
             const keyword = isType ? "type" : "const";
-            const typeAnnotation = typeDeclaration.length === 0 ? "" : `:${typeDeclaration}`;
-            return `${beforeExport}export ${keyword} ${name}${typeAnnotation} = ${code};`;
+            const typeAnnotation = (typeDeclaration ?? "").length === 0
+                ? ""
+                : `:${typeDeclaration ?? ""}`;
+            return `${beforeExport}export ${keyword} ${name ?? ""}${typeAnnotation} = ${code};`;
         });
     }
     contents() {

package/dist/typescript-generator/specification.js

@@ -1,12 +1,15 @@
+import { bundle } from "@apidevtools/json-schema-ref-parser";
 import createDebug from "debug";
 import { Requirement } from "./requirement.js";
-import { bundle } from "@apidevtools/json-schema-ref-parser";
 const debug = createDebug("counterfact:typescript-generator:specification");
 export class Specification {
+    cache;
+    rootRequirement;
     constructor(rootRequirement) {
         this.cache = new Map();
-        this.rootUrl = rootRequirement;
-        this.rootRequirement = rootRequirement;
+        if (rootRequirement) {
+            this.rootRequirement = rootRequirement;
+        }
     }
     static async fromFile(urlOrPath) {
         const specification = new Specification();
@@ -18,6 +21,6 @@ export class Specification {
         return this.rootRequirement.select(url.slice(2));
     }
     async load(urlOrPath) {
-        this.rootRequirement = new Requirement(await bundle(urlOrPath), urlOrPath, this);
+        this.rootRequirement = new Requirement((await bundle(urlOrPath)), urlOrPath, this);
     }
 }

package/dist/util/ensure-directory-exists.js

@@ -3,7 +3,7 @@ import nodePath from "node:path";
 export function ensureDirectoryExists(filePath) {
     const directory = nodePath.dirname(filePath);
     try {
-        fs.accessSync(directory, fs.fsConstants.W_OK);
+        fs.accessSync(directory, fs.constants.W_OK);
     }
     catch {
         // with the async option, await doesn't seem to wait for the directory to be created

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "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",
@@ -66,13 +66,13 @@
   "scripts": {
     "test": "yarn node --experimental-vm-modules ./node_modules/jest-cli/bin/jest --testPathIgnorePatterns=black-box",
     "test:black-box": "rimraf dist && yarn build && python3 -m pytest test-black-box/ -v",
-    "test:mutants": "stryker run stryker.config.json",
     "test:tsd": "tsd --typings ./dist/server/counterfact-types/index.ts --files ./test/**/*.test-d.ts",
     "build": "rm -rf dist && tsc && copyfiles -f \"src/client/**\" dist/client && copyfiles -f \"src/counterfact-types/*.ts\" dist/server/counterfact-types && copyfiles -f \"src/server/*.cjs\" dist/server",
     "prepack": "yarn build",
     "release": "npx changeset publish",
     "prepare": "husky install",
     "lint": "eslint . --plugin file-progress --rule 'file-progress/activate: 1' --ignore-pattern dist --ignore-pattern out --ignore-pattern coverage",
+    "lint:fix": "eslint --fix . --ignore-pattern dist --ignore-pattern out --ignore-pattern coverage",
     "lint:quickfix": "eslint --fix . eslint --fix demo-ts --rule=\"import/namespace: 0,etc/no-deprecated:0,import/no-cycle:0,no-explicit-type-exports/no-explicit-type-exports:0,import/no-deprecated:0,import/no-self-import:0,import/default:0,import/no-named-as-default:0\" --ignore-pattern dist --ignore-pattern out",
     "go:petstore": "yarn build && yarn counterfact https://petstore3.swagger.io/api/v3/openapi.json out",
     "go:petstore2": "yarn build && yarn counterfact  https://petstore.swagger.io/v2/swagger.json out",
@@ -84,9 +84,6 @@
     "@changesets/cli": "2.30.0",
     "@eslint/js": "10.0.1",
     "@jest/globals": "^30.3.0",
-    "@stryker-mutator/core": "9.6.0",
-    "@stryker-mutator/jest-runner": "9.6.0",
-    "@stryker-mutator/typescript-checker": "9.6.0",
     "@swc/core": "1.15.21",
     "@swc/jest": "0.2.39",
     "@testing-library/dom": "10.4.1",
@@ -122,7 +119,6 @@
     "jest-retries": "1.0.1",
     "node-mocks-http": "1.17.2",
     "rimraf": "6.1.3",
-    "stryker-cli": "1.1.0",
     "supertest": "7.2.2",
     "tsd": "0.33.0",
     "using-temporary-files": "2.2.1"
@@ -141,11 +137,11 @@
     "js-yaml": "4.1.1",
     "json-schema-faker": "0.6.0",
     "jsonwebtoken": "9.0.3",
-    "koa": "3.1.2",
+    "koa": "3.2.0",
     "koa-bodyparser": "4.4.1",
     "koa-proxies": "0.12.4",
     "koa2-swagger-ui": "5.12.0",
-    "lodash": "4.17.23",
+    "lodash": "4.18.1",
     "node-fetch": "3.3.2",
     "open": "11.0.0",
     "patch-package": "8.0.1",