counterfact 2.5.0 → 2.6.0

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,11 @@
+import { buildJsDoc } from "./jsdoc.js";
 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));
+    }
+    jsdoc() {
+        return buildJsDoc(this.requirement.data);
     }
     additionalPropertiesType(script) {
         const { additionalProperties, properties } = this.requirement.data;
@@ -16,13 +20,17 @@ 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)}`;
+            const comment = buildJsDoc(property.data);
+            const commentPrefix = comment ? `\n${comment}` : "";
+            return `${commentPrefix}"${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 +45,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 +67,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 +77,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 = [];
@@ -42,6 +50,7 @@ export class Script {
             id: coder.id,
             isDefault,
             isType,
+            jsdoc: "",
             typeDeclaration: coder.typeDeclaration(this.exports, this),
         };
         exportStatement.promise = coder
@@ -49,11 +58,13 @@ export class Script {
             .then((availableCoder) => {
             exportStatement.name = name;
             exportStatement.code = availableCoder.write(this);
+            exportStatement.jsdoc = availableCoder.jsdoc();
             return availableCoder;
         })
             .catch((error) => {
             exportStatement.code = `{/* error creating export "${name}" for ${this.path}: ${error.stack} */}`;
             exportStatement.error = error;
+            return undefined;
         })
             .finally(() => {
             exportStatement.done = true;
@@ -125,16 +136,18 @@ export class Script {
         });
     }
     exportStatements() {
-        return Array.from(this.exports.values(), ({ beforeExport, code, isDefault, isType, name, typeDeclaration }) => {
-            if (code.raw) {
+        return Array.from(this.exports.values(), ({ beforeExport, code, isDefault, isType, jsdoc, name, typeDeclaration, }) => {
+            if (typeof code === "object" && code !== null && "raw" in code) {
                 return code.raw;
             }
             if (isDefault) {
-                return `${beforeExport}export default ${code};`;
+                return `${jsdoc}${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 `${jsdoc}${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,12 @@ export class Specification {
         return this.rootRequirement.select(url.slice(2));
     }
     async load(urlOrPath) {
-        this.rootRequirement = new Requirement(await bundle(urlOrPath), urlOrPath, this);
+        try {
+            this.rootRequirement = new Requirement((await bundle(urlOrPath)), urlOrPath, this);
+        }
+        catch (error) {
+            const details = error instanceof Error ? error.message : String(error);
+            throw new Error(`Could not load the OpenAPI spec from "${urlOrPath}".\n${details}`, { cause: error });
+        }
     }
 }

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/dist/util/runtime-can-execute-erasable-ts.js

@@ -0,0 +1,22 @@
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+export async function runtimeCanExecuteErasableTs() {
+    const dir = mkdtempSync(join(tmpdir(), "ts-probe-"));
+    // helper.ts is imported via .js extension — the TypeScript convention used
+    // throughout this codebase. If the runtime resolves helper.js → helper.ts,
+    // it is fully capable of running the TypeScript source tree.
+    writeFileSync(join(dir, "helper.ts"), 'export const value: string = "ok";\n', "utf8");
+    writeFileSync(join(dir, "main.ts"), 'import { value } from "./helper.js"; export default value;\n', "utf8");
+    try {
+        const mod = await import(pathToFileURL(join(dir, "main.ts")).href);
+        return mod?.default === "ok";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Generate a TypeScript-based mock server from an OpenAPI spec in seconds — with stateful routes, hot reload, and REPL support.",
   "type": "module",
   "main": "./dist/app.js",
@@ -94,10 +94,9 @@
     "@types/koa-bodyparser": "4.3.13",
     "@types/koa-proxy": "1.0.8",
     "@types/koa-static": "4.0.4",
-    "@types/lodash": "4.17.24",
     "@types/node": "22",
-    "@typescript-eslint/eslint-plugin": "^8.53.0",
-    "@typescript-eslint/parser": "^8.53.0",
+    "@typescript-eslint/eslint-plugin": "^8.58.0",
+    "@typescript-eslint/parser": "^8.58.0",
     "copyfiles": "2.4.1",
     "eslint": "10.1.0",
     "eslint-formatter-github-annotations": "0.1.0",
@@ -127,10 +126,10 @@
     "@apidevtools/json-schema-ref-parser": "13.0.5",
     "@hapi/accept": "6.0.3",
     "@types/json-schema": "7.0.15",
+    "ajv": "6.14.0",
     "chokidar": "5.0.0",
     "commander": "14.0.3",
     "debug": "4.4.3",
-    "fetch": "1.1.0",
     "fs-extra": "11.3.4",
     "handlebars": "4.7.9",
     "http-terminator": "3.2.0",
@@ -141,12 +140,14 @@
     "koa-bodyparser": "4.4.1",
     "koa-proxies": "0.12.4",
     "koa2-swagger-ui": "5.12.0",
-    "lodash": "4.18.1",
     "node-fetch": "3.3.2",
     "open": "11.0.0",
     "patch-package": "8.0.1",
+    "posthog-node": "^5.28.11",
     "precinct": "12.2.0",
     "prettier": "3.8.1",
+    "recast": "0.23.11",
+    "tsx": "^4.20.3",
     "typescript": "6.0.2"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e",