counterfact 2.5.0 → 2.6.0

package/dist/server/module-tree.js

@@ -3,8 +3,8 @@ function isDirectory(test) {
 }
 export class ModuleTree {
     root = {
-        directories: {},
-        files: {},
+        directories: new Map(),
+        files: new Map(),
         isWildcard: false,
         name: "",
         rawName: "",
@@ -17,16 +17,19 @@ export class ModuleTree {
         if (remainingSegments.length === 0) {
             return directory;
         }
-        const isNewDirectory = directory.directories[segment.toLowerCase()] === undefined;
-        const nextDirectory = (directory.directories[segment.toLowerCase()] ??= {
-            directories: {},
-            files: {},
-            isWildcard: segment.startsWith("{"),
-            name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
-            rawName: segment,
-        });
+        const isNewDirectory = !directory.directories.has(segment.toLowerCase());
+        if (isNewDirectory) {
+            directory.directories.set(segment.toLowerCase(), {
+                directories: new Map(),
+                files: new Map(),
+                isWildcard: segment.startsWith("{"),
+                name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
+                rawName: segment,
+            });
+        }
+        const nextDirectory = directory.directories.get(segment.toLowerCase());
         if (isNewDirectory && segment.startsWith("{")) {
-            const ambiguousWildcardDirectories = Object.values(directory.directories).filter((subdirectory) => subdirectory.isWildcard);
+            const ambiguousWildcardDirectories = Array.from(directory.directories.values()).filter((subdirectory) => subdirectory.isWildcard);
             if (ambiguousWildcardDirectories.length > 1) {
                 process.stderr.write(`[counterfact] ERROR: Ambiguous wildcard paths detected. Multiple wildcard directories exist at the same level: ${ambiguousWildcardDirectories.map((d) => d.rawName).join(", ")}. Requests may be routed unpredictably.\n`);
             }
@@ -42,14 +45,14 @@ export class ModuleTree {
         if (filename === undefined) {
             throw new Error("The file name (the last segment of the URL) is undefined. This is theoretically impossible but TypeScript can't enforce it.");
         }
-        targetDirectory.files[filename] = {
+        targetDirectory.files.set(filename, {
             isWildcard: filename.startsWith("{"),
             module,
             name: filename.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
             rawName: filename,
-        };
+        });
         if (filename.startsWith("{")) {
-            const ambiguousWildcardFiles = Object.values(targetDirectory.files).filter((file) => file.isWildcard);
+            const ambiguousWildcardFiles = Array.from(targetDirectory.files.values()).filter((file) => file.isWildcard);
             if (ambiguousWildcardFiles.length > 1) {
                 process.stderr.write(`[counterfact] ERROR: Ambiguous wildcard paths detected. Multiple wildcard files exist at the same path level: ${ambiguousWildcardFiles.map((f) => f.rawName).join(", ")}. Requests may be routed unpredictably.\n`);
             }
@@ -67,10 +70,10 @@ export class ModuleTree {
             return;
         }
         if (remainingSegments.length === 0) {
-            delete directory.files[segment.toLowerCase()];
+            directory.files.delete(segment.toLowerCase());
             return;
         }
-        this.removeModuleFromDirectory(directory.directories[segment.toLowerCase()], remainingSegments);
+        this.removeModuleFromDirectory(directory.directories.get(segment.toLowerCase()), remainingSegments);
     }
     remove(url) {
         const segments = url.split("/").slice(1);
@@ -81,14 +84,14 @@ export class ModuleTree {
     }
     buildMatch(directory, segment, pathVariables, matchedPath, method) {
         function normalizedSegment(segment, directory) {
-            for (const file in directory.files) {
+            for (const file of directory.files.keys()) {
                 if (file.toLowerCase() === segment.toLowerCase()) {
                     return file;
                 }
             }
             return "";
         }
-        const exactMatchFile = directory.files[normalizedSegment(segment, directory)];
+        const exactMatchFile = directory.files.get(normalizedSegment(segment, directory));
         // If the URL segment literally matches a file key (e.g., requesting "/{x}"
         // as a literal URL value), exactMatchFile may be a wildcard file. In that
         // case, fall through to wildcard matching below.
@@ -99,7 +102,7 @@ export class ModuleTree {
                 pathVariables,
             };
         }
-        const wildcardFiles = Object.values(directory.files).filter((file) => file.isWildcard && this.fileModuleDefined(file, method));
+        const wildcardFiles = Array.from(directory.files.values()).filter((file) => file.isWildcard && this.fileModuleDefined(file, method));
         if (wildcardFiles.length > 1) {
             const firstWildcard = wildcardFiles[0];
             return {
@@ -144,11 +147,11 @@ export class ModuleTree {
             (remainingSegments.length === 1 && remainingSegments[0] === "")) {
             return this.buildMatch(directory, segment, pathVariables, matchedPath, method);
         }
-        const exactMatch = directory.directories[segment.toLowerCase()];
+        const exactMatch = directory.directories.get(segment.toLowerCase());
         if (isDirectory(exactMatch)) {
             return this.matchWithinDirectory(exactMatch, remainingSegments, pathVariables, `${matchedPath}/${segment}`, method);
         }
-        const wildcardDirectories = Object.values(directory.directories).filter((subdirectory) => subdirectory.isWildcard);
+        const wildcardDirectories = Array.from(directory.directories.values()).filter((subdirectory) => subdirectory.isWildcard);
         const wildcardMatches = [];
         for (const wildcardDirectory of wildcardDirectories) {
             const wildcardMatch = this.matchWithinDirectory(wildcardDirectory, remainingSegments, {
@@ -171,10 +174,10 @@ export class ModuleTree {
     get routes() {
         const routes = [];
         function traverse(directory, path) {
-            Object.values(directory.directories).forEach((subdirectory) => {
+            directory.directories.forEach((subdirectory) => {
                 traverse(subdirectory, `${path}/${subdirectory.rawName}`);
             });
-            Object.values(directory.files).forEach((file) => {
+            directory.files.forEach((file) => {
                 const methods = Object.entries(file.module).map(([method, implementation]) => [method, String(implementation)]);
                 routes.push({
                     methods: Object.fromEntries(methods),

package/dist/server/openapi-middleware.js

@@ -1,5 +1,5 @@
 import { bundle } from "@apidevtools/json-schema-ref-parser";
-import yaml from "js-yaml";
+import { dump } from "js-yaml";
 export function openapiMiddleware(openApiPath, url) {
     return async (ctx, next) => {
         if (ctx.URL.pathname === "/counterfact/openapi") {
@@ -11,7 +11,7 @@ export function openapiMiddleware(openApiPath, url) {
             });
             // OpenApi 2 support:
             openApiDocument.host = url;
-            ctx.body = yaml.dump(openApiDocument);
+            ctx.body = dump(openApiDocument);
             return;
         }
         await next();

package/dist/server/registry.js

@@ -26,10 +26,10 @@ function castParameter(value, type) {
     }
     return value;
 }
-function castParameters(parameters = {}, parameterTypes = {}) {
+function castParameters(parameters = {}, parameterTypes = new Map()) {
     const copy = {};
     Object.entries(parameters).forEach(([key, value]) => {
-        copy[key] = castParameter(value, parameterTypes?.[key] ?? "string");
+        copy[key] = castParameter(value, parameterTypes.get(key) ?? "string");
     });
     return copy;
 }

package/dist/server/request-validator.js

@@ -0,0 +1,61 @@
+import Ajv from "ajv";
+const ajv = new Ajv({
+    allErrors: true,
+    unknownFormats: "ignore",
+    coerceTypes: false,
+});
+function findMissingRequired(parameters, location, values) {
+    return parameters
+        .filter((p) => p.in === location && p.required === true)
+        .filter((p) => !(p.name in values) || values[p.name] === undefined)
+        .map((p) => `${location} parameter '${p.name}' is required`);
+}
+export function validateRequest(operation, request) {
+    if (!operation) {
+        return { errors: [], valid: true };
+    }
+    const errors = [];
+    const parameters = operation.parameters ?? [];
+    // For query and header parameters, HTTP always delivers values as strings.
+    // Only check that required parameters are present; type coercion is handled
+    // by the registry before the route handler is called.
+    errors.push(...findMissingRequired(parameters, "query", request.query));
+    errors.push(...findMissingRequired(parameters, "header", request.headers));
+    // Validate request body (OpenAPI 3.x requestBody)
+    if (operation.requestBody?.content !== undefined) {
+        const schema = operation.requestBody.content["application/json"]?.schema ??
+            operation.requestBody.content["application/x-www-form-urlencoded"]
+                ?.schema;
+        if (schema !== undefined) {
+            const valid = ajv.validate(schema, request.body);
+            if (!valid && ajv.errors) {
+                for (const error of ajv.errors) {
+                    const path = error.instancePath ??
+                        error.dataPath ??
+                        "";
+                    errors.push(`body${path} ${error.message ?? "is invalid"}`);
+                }
+            }
+        }
+        else if (operation.requestBody.required === true && !request.body) {
+            errors.push("body is required");
+        }
+    }
+    // Validate request body (OpenAPI 2.x body parameter)
+    const bodyParam = parameters.find((p) => p.in === "body");
+    if (bodyParam?.schema !== undefined) {
+        const valid = ajv.validate(bodyParam.schema, request.body);
+        if (!valid && ajv.errors) {
+            for (const error of ajv.errors) {
+                const path = error.instancePath ??
+                    error.dataPath ??
+                    "";
+                errors.push(`body${path} ${error.message ?? "is invalid"}`);
+            }
+        }
+    }
+    return {
+        errors,
+        valid: errors.length === 0,
+    };
+}

package/dist/server/transpiler.js

@@ -67,12 +67,20 @@ export class Transpiler extends EventTarget {
     async transpileFile(eventName, sourcePath, destinationPath) {
         ensureDirectoryExists(destinationPath);
         const source = await fs.readFile(sourcePath, "utf8");
-        const result = ts.transpileModule(source, {
+        const transpileOutput = ts.transpileModule(source, {
             compilerOptions: {
                 module: ts.ModuleKind[this.moduleKind.toLowerCase() === "module" ? "ES2022" : "CommonJS"],
                 target: ts.ScriptTarget.ES2015,
             },
-        }).outputText;
+            reportDiagnostics: true,
+        });
+        if (transpileOutput.diagnostics?.length) {
+            for (const diagnostic of transpileOutput.diagnostics) {
+                const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                debug("TypeScript diagnostic in %s: %s", sourcePath, message);
+            }
+        }
+        const result = transpileOutput.outputText;
         const fullDestination = nodePath
             .join(sourcePath
             .replace(this.sourcePath, this.destinationPath)
@@ -82,10 +90,10 @@ export class Transpiler extends EventTarget {
         try {
             await fs.writeFile(fullDestination, resultWithTransformedFileExtensions);
         }
-        catch {
-            debug("error transpiling %s", fullDestination);
+        catch (error) {
+            debug("error writing transpiled output to %s: %o", fullDestination, error);
             this.dispatchEvent(new Event("error"));
-            throw new Error("could not transpile");
+            throw new Error("could not transpile", { cause: error });
         }
         this.dispatchEvent(new Event("write"));
     }

package/dist/typescript-generator/coder.js

@@ -1,14 +1,18 @@
 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 "";
+    }
+    jsdoc() {
         return "";
     }
     write(script) {
@@ -17,7 +21,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 +43,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/jsdoc.js

@@ -0,0 +1,45 @@
+/**
+ * Builds a JSDoc comment string from OpenAPI schema metadata.
+ * Returns an empty string if there is no relevant metadata.
+ */
+export function buildJsDoc(data) {
+    const lines = [];
+    const description = data["description"];
+    const summary = data["summary"];
+    const example = data["example"];
+    const examples = data["examples"];
+    const defaultValue = data["default"];
+    const format = data["format"];
+    const deprecated = data["deprecated"];
+    const mainText = description ?? summary;
+    if (mainText) {
+        // Escape */ to prevent prematurely closing the JSDoc block
+        const escaped = String(mainText).replace(/\*\//gu, "* /");
+        const textLines = escaped.split("\n");
+        for (const line of textLines) {
+            lines.push(` * ${line}`);
+        }
+    }
+    if (format !== undefined) {
+        lines.push(` * @format ${format}`);
+    }
+    if (defaultValue !== undefined) {
+        lines.push(` * @default ${JSON.stringify(defaultValue)}`);
+    }
+    // Use scalar `example`, or fall back to the first value from `examples`
+    const exampleValue = example !== undefined
+        ? example
+        : examples !== undefined
+            ? Object.values(examples)[0]?.value
+            : undefined;
+    if (exampleValue !== undefined) {
+        lines.push(` * @example ${JSON.stringify(exampleValue)}`);
+    }
+    if (deprecated === true) {
+        lines.push(` * @deprecated`);
+    }
+    if (lines.length === 0) {
+        return "";
+    }
+    return `/**\n${lines.join("\n")}\n */\n`;
+}

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,12 @@
 import nodePath from "node:path";
 import { CONTEXT_FILE_TOKEN } from "./context-file-token.js";
+import { buildJsDoc } from "./jsdoc.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",
@@ -72,6 +73,8 @@ function sanitizeIdentifier(value) {
     return result || "_";
 }
 export class OperationTypeCoder extends TypeCoder {
+    requestMethod;
+    securitySchemes;
     constructor(requirement, requestMethod, securitySchemes = []) {
         super(requirement);
         if (requestMethod === undefined) {
@@ -86,6 +89,9 @@ export class OperationTypeCoder extends TypeCoder {
             ? sanitizeIdentifier(operationId)
             : `HTTP_${this.requestMethod.toUpperCase()}`;
     }
+    jsdoc() {
+        return buildJsDoc(this.requirement.data);
+    }
     names() {
         return super.names(this.getOperationBaseName());
     }
@@ -114,15 +120,18 @@ export class OperationTypeCoder extends TypeCoder {
             }`);
             }
             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} 
@@ -157,17 +166,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

@@ -1,7 +1,9 @@
 import nodePath from "node:path";
+import { buildJsDoc } from "./jsdoc.js";
 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;
@@ -22,7 +24,10 @@ export class ParametersTypeCoder extends TypeCoder {
             const schema = parameter.has("schema")
                 ? parameter.get("schema")
                 : parameter;
-            return `"${name}"${optionalFlag}: ${new SchemaTypeCoder(schema).write(script)}`;
+            const comment = buildJsDoc(parameter.data);
+            const commentPrefix = comment ? `\n${comment}` : "";
+            const typeString = new SchemaTypeCoder(schema).write(script);
+            return `${commentPrefix}"${name}"${optionalFlag}: ${typeString}`;
         });
         if (typeDefinitions.length === 0) {
             return "never";

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,15 +37,16 @@ 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;
     try {
         entries = await fs.readdir(dir, { withFileTypes: true });
     }
-    catch {
+    catch (error) {
+        debug("could not read directory %s: %o", dir, error);
         return;
     }
     for (const entry of entries) {
@@ -65,8 +66,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 +75,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);