counterfact 2.5.0 → 2.5.1

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/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,11 @@
 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",
@@ -72,6 +72,8 @@ function sanitizeIdentifier(value) {
     return result || "_";
 }
 export class OperationTypeCoder extends TypeCoder {
+    requestMethod;
+    securitySchemes;
     constructor(requirement, requestMethod, securitySchemes = []) {
         super(requirement);
         if (requestMethod === undefined) {
@@ -114,15 +116,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 +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,16 +2,19 @@ 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:  ${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

@@ -4,6 +4,14 @@ 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 = [];
@@ -54,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;
@@ -126,15 +135,17 @@ export class Script {
     }
     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.5.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",