counterfact 2.7.0 → 2.8.1

package/dist/typescript-generator/{generate.js → scenario-file-generator.js}

@@ -1,70 +1,10 @@
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import nodePath from "node:path";
-import createDebug from "debug";
-import { ensureDirectoryExists } from "../util/ensure-directory-exists.js";
-import { OperationCoder } from "./operation-coder.js";
-import { pruneRoutes } from "./prune.js";
-import { Repository } from "./repository.js";
-import { Specification } from "./specification.js";
-const debug = createDebug("counterfact:typescript-generator:generate");
-async function buildCacheDirectory(destination) {
-    const gitignorePath = nodePath.join(destination, ".gitignore");
-    const cacheReadmePath = nodePath.join(destination, ".cache", "README.md");
-    debug("ensuring the directory containing .gitgnore exists");
-    await ensureDirectoryExists(gitignorePath);
-    debug("creating the .gitignore file if it doesn't already exist");
-    if (!existsSync(gitignorePath)) {
-        await fs.writeFile(gitignorePath, ".cache\n", "utf8");
-    }
-    debug("creating the .cache/README.md file");
-    ensureDirectoryExists(cacheReadmePath);
-    await fs.writeFile(cacheReadmePath, "This directory contains compiled JS files from the paths directory. Do not edit these files directly.\n", "utf8");
-}
-async function getPathsFromSpecification(specification) {
-    try {
-        return specification.getRequirement("#/paths") ?? new Set();
-    }
-    catch (error) {
-        process.stderr.write(`Could not find #/paths in the specification.\n${error}\n`);
-        return undefined;
-    }
-}
-export async function generate(source, destination, generateOptions, repository = new Repository()) {
-    debug("generating code from %s to %s", source, destination);
-    debug("initializing the .cache directory");
-    await buildCacheDirectory(destination);
-    debug("done initializing the .cache directory");
-    debug("creating specification from %s", source);
-    const specification = await Specification.fromFile(source);
-    debug("created specification: $o", specification);
-    debug("reading the #/paths from the specification");
-    const paths = await getPathsFromSpecification(specification);
-    debug("got %i paths", paths?.map?.length ?? 0);
-    if (generateOptions.prune && generateOptions.routes) {
-        debug("pruning defunct route files");
-        await pruneRoutes(destination, paths.map((_v, key) => key));
-        debug("done pruning");
-    }
-    const securityRequirement = specification.getRequirement("#/components/securitySchemes");
-    const securitySchemes = Object.values(securityRequirement?.data ?? {});
-    paths.forEach((pathDefinition, key) => {
-        debug("processing path %s", key);
-        const path = key === "/" ? "/index" : key;
-        pathDefinition.forEach((operation, requestMethod) => {
-            repository
-                .get(`routes${path}.ts`)
-                .export(new OperationCoder(operation, requestMethod, securitySchemes));
-        });
-    });
-    debug("telling the repository to write the files to %s", destination);
-    await repository.writeFiles(destination, generateOptions);
-    debug("finished writing the files");
-    if (generateOptions.types) {
-        await writeApplyContextType(destination);
-        await writeDefaultScenariosIndex(destination);
-    }
-}
+import { watch } from "chokidar";
+import { CHOKIDAR_OPTIONS } from "../server/constants.js";
+import { pathRelative } from "../util/forward-slash-path.js";
+import { waitForEvent } from "../util/wait-for-event.js";
 async function collectContextFiles(destination) {
     const routesDir = nodePath.join(destination, "routes");
     const results = [];
@@ -88,9 +28,7 @@ async function walkForContextFiles(routesDir, currentDir, results) {
             await walkForContextFiles(routesDir, nodePath.join(currentDir, entry.name), results);
         }
         else if (entry.name === "_.context.ts") {
-            const relDir = nodePath
-                .relative(routesDir, currentDir)
-                .replaceAll("\\", "/");
+            const relDir = pathRelative(routesDir, currentDir);
             const routePath = relDir === "" ? "/" : `/${relDir}`;
             const depth = relDir === "" ? 0 : relDir.split("/").length;
             const importPath = relDir === "" ? "../routes/_.context" : `../routes/${relDir}/_.context`;
@@ -128,7 +66,7 @@ function buildLoadContextOverload(routePath, alias) {
         .join("/")}`;
     return `  loadContext(path: \`${templatePath}\`): ${alias};`;
 }
-function buildApplyContextContent(contextFiles) {
+function buildScenarioContextContent(contextFiles) {
     const rootContext = contextFiles.find((f) => f.routePath === "/");
     const contextType = rootContext
         ? rootContext.alias
@@ -141,38 +79,60 @@ function buildApplyContextContent(contextFiles) {
         "// This file is generated by Counterfact. Do not edit manually.",
         ...importLines,
         "",
-        "export interface ApplyContext {",
-        '  /** Root context, same as loadContext("/") */',
-        `  context: ${contextType};`,
-        "  /** Load a context object for a specific path */",
+        "interface LoadContextDefinitions {",
+        "  /* code generator adds additional signatures here */",
         ...overloadLines,
         "  loadContext(path: string): Record<string, unknown>;",
+        "}",
+        "",
+        "export interface Scenario$ {",
+        '  /** Root context, same as loadContext("/") */',
+        `  readonly context: ${contextType};`,
+        '  readonly loadContext: LoadContextDefinitions["loadContext"];',
         "  /** Named route builders stored in the REPL execution context */",
-        "  routes: Record<string, unknown>;",
+        "  readonly routes: Record<string, unknown>;",
         "  /** Create a new route builder for a given path */",
-        "  route: (path: string) => unknown;",
+        "  readonly route: (path: string) => unknown;",
         "}",
         "",
         "/** A scenario function that receives the live REPL environment */",
-        "export type Scenario = ($: ApplyContext) => Promise<void> | void;",
+        "export type Scenario = ($: Scenario$) => Promise<void> | void;",
+        "",
+        "/** Interface for Context objects defined in _.context.ts files */",
+        "export interface Context$ {",
+        "  /** Load a context object for a specific path */",
+        '  readonly loadContext: LoadContextDefinitions["loadContext"];',
+        "  /** Load a JSON file relative to this file's path */",
+        "  readonly readJson: (relativePath: string) => Promise<unknown>;",
+        "}",
         "",
     ];
     return parts.join("\n");
 }
-export async function writeApplyContextType(destination) {
+/**
+ * Writes the `types/_.context.ts` file, which exports the
+ * `Scenario$` interface used to type scenario functions.
+ *
+ * The interface is generated from all `_.context.ts` files found under the
+ * `routes/` directory, providing strongly typed `loadContext()` overloads for
+ * every route path that has a context file.
+ *
+ * @param destination - Root output directory.
+ */
+async function writeScenarioContextType(destination) {
     const typesDir = nodePath.join(destination, "types");
-    const filePath = nodePath.join(typesDir, "scenario-context.ts");
+    const filePath = nodePath.join(typesDir, "_.context.ts");
     const contextFiles = await collectContextFiles(destination);
-    const content = buildApplyContextContent(contextFiles);
+    const content = buildScenarioContextContent(contextFiles);
     await fs.mkdir(typesDir, { recursive: true });
     await fs.writeFile(filePath, content, "utf8");
 }
-const DEFAULT_SCENARIOS_INDEX = `import type { Scenario } from "../types/scenario-context.js";
+const DEFAULT_SCENARIOS_INDEX = `import type { Scenario } from "../types/_.context.js";
 
 /**
  * Scenario scripts are plain TypeScript functions that receive the live REPL
  * environment and can read or mutate server state. Run them from the REPL with:
- *   .apply <functionName>
+ *   .scenario <functionName>
  */
 
 /**
@@ -186,9 +146,24 @@ const DEFAULT_SCENARIOS_INDEX = `import type { Scenario } from "../types/scenari
  *   $.routes.myRequest = $.route("/pets").method("get");
  */
 
+/**
+ * startup() runs automatically when the server initializes, right before the
+ * REPL starts. Use it to seed dummy data so the server is ready to use
+ * immediately. It receives the same $ argument as all other scenario functions.
+ *
+ * Tip: delegate to other scenario functions and pass $ along so each function
+ * stays focused on a single concern. You can also pass additional arguments to
+ * configure them, e.g. addPets($, 20, "dog").
+ *
+ * If you don't need a startup scenario, delete this function or leave it empty.
+ */
+export const startup: Scenario = ($) => {
+  void $;
+};
+
 /**
  * An example scenario. To use it in the REPL, type:
- *   .apply help
+ *   .scenario help
  */
 export const help: Scenario = ($) => {
   void $;
@@ -216,3 +191,45 @@ async function writeDefaultScenariosIndex(destination) {
     await fs.mkdir(scenariosDir, { recursive: true });
     await fs.writeFile(filePath, DEFAULT_SCENARIOS_INDEX, "utf8");
 }
+/**
+ * Encapsulates the generation of scenario-related files:
+ * - `types/_.context.ts` — the typed `Scenario$` interface derived from all
+ *   `_.context.ts` files found under `routes/`.
+ * - `scenarios/index.ts` — the default scenarios entry-point (created only if
+ *   it does not already exist).
+ *
+ * When {@link watch} is called, a file-system watcher monitors the `routes/`
+ * directory for changes to `_.context.ts` files and automatically regenerates
+ * `types/_.context.ts`.
+ */
+export class ScenarioFileGenerator {
+    destination;
+    watcher;
+    constructor(destination) {
+        this.destination = destination;
+    }
+    /** Generates both scenario-related files once and resolves when complete. */
+    async generate() {
+        await writeScenarioContextType(this.destination);
+        await writeDefaultScenariosIndex(this.destination);
+    }
+    /**
+     * Starts watching the `routes/` directory for `_.context.ts` changes and
+     * regenerates `types/_.context.ts` on every change.
+     *
+     * Resolves once the watcher is ready.
+     */
+    async watch() {
+        const routesDir = nodePath.join(this.destination, "routes");
+        this.watcher = watch(routesDir, CHOKIDAR_OPTIONS).on("all", (_event, filePath) => {
+            if (filePath.endsWith("_.context.ts")) {
+                void writeScenarioContextType(this.destination);
+            }
+        });
+        await waitForEvent(this.watcher, "ready");
+    }
+    /** Closes the file-system watcher. */
+    async stopWatching() {
+        await this.watcher?.close();
+    }
+}

package/dist/typescript-generator/script.js

@@ -1,8 +1,18 @@
-import nodePath from "node:path";
 import createDebugger from "debug";
 import { format } from "prettier";
 import { escapePathForWindows } from "../util/windows-escape.js";
+import { pathJoin, pathRelative, pathDirname, } from "../util/forward-slash-path.js";
 const debug = createDebugger("counterfact:typescript-generator:script");
+/**
+ * Represents a single TypeScript file being assembled by the code generator.
+ *
+ * A `Script` accumulates exports, imports, and external imports contributed by
+ * {@link Coder} instances.  Once all coders have resolved, {@link contents}
+ * formats the result with Prettier and returns the final source text.
+ *
+ * Scripts are created and retrieved through a {@link Repository} so that the
+ * same module path always maps to the same `Script` instance.
+ */
 export class Script {
     repository;
     comments;
@@ -22,6 +32,10 @@ export class Script {
         this.typeCache = new Map();
         this.path = path;
     }
+    /**
+     * A `"../"` path fragment that points from this script's directory back to
+     * the repository root, used to resolve relative import paths.
+     */
     get relativePathToBase() {
         return this.path
             .split("/")
@@ -29,6 +43,13 @@ export class Script {
             .map(() => "..")
             .join("/");
     }
+    /**
+     * Picks the first name from `coder.names()` that is not already used as an
+     * import in this script, ensuring export/import name uniqueness.
+     *
+     * @param coder - The coder needing a name.
+     * @throws When all 100 candidate names are already taken.
+     */
     firstUniqueName(coder) {
         for (const name of coder.names()) {
             if (!this.imports.has(name)) {
@@ -37,6 +58,17 @@ export class Script {
         }
         throw new Error(`could not find a unique name for ${coder.id}`);
     }
+    /**
+     * Registers an export for `coder` in this script and returns the export name.
+     *
+     * If the same coder has already been exported (cache hit), the previously
+     * assigned name is returned without creating a duplicate.
+     *
+     * @param coder - The coder to export.
+     * @param isType - Emit `export type` instead of `export const`.
+     * @param isDefault - Emit `export default` instead of a named export.
+     * @returns The name under which the coder is exported.
+     */
     export(coder, isType = false, isDefault = false) {
         const cacheKey = isDefault ? "default" : `${coder.id}:${isType}`;
         if (this.cache.has(cacheKey)) {
@@ -75,6 +107,16 @@ export class Script {
     exportDefault(coder, isType = false) {
         this.export(coder, isType, true);
     }
+    /**
+     * Registers an import of `coder` from its owning module and returns the
+     * local alias used in this script.
+     *
+     * The coder is also exported from its home module as a side effect.
+     *
+     * @param coder - The coder to import.
+     * @param isType - Use a `import type` declaration.
+     * @param isDefault - Import the default export rather than a named export.
+     */
     import(coder, isType = false, isDefault = false) {
         debug("import coder: %s", coder.id);
         const modulePath = coder.modulePath();
@@ -103,24 +145,42 @@ export class Script {
     importDefault(coder, isType = false) {
         return this.import(coder, isType, true);
     }
+    /**
+     * Registers an import from an external npm package or absolute module path
+     * (not managed by the repository).
+     *
+     * @param name - The local binding name.
+     * @param modulePath - The module specifier (e.g. `"counterfact-types/index"`).
+     * @param isType - Use a `import type` declaration.
+     * @returns `name` (for convenience in method chaining).
+     */
     importExternal(name, modulePath, isType = false) {
         this.externalImport.set(name, { isType, modulePath });
         return name;
     }
+    /**
+     * Convenience wrapper that calls {@link importExternal} with `isType = true`.
+     */
     importExternalType(name, modulePath) {
         return this.importExternal(name, modulePath, true);
     }
+    /**
+     * Imports a type from the shared `counterfact-types/index.ts` module,
+     * resolving the path relative to this script's location in the repository.
+     *
+     * @param name - The type name to import (e.g. `"WideOperationArgument"`).
+     */
     importSharedType(name) {
-        return this.importExternal(name, nodePath
-            .join(this.relativePathToBase, "counterfact-types/index.ts")
-            .replaceAll("\\", "/"), true);
+        return this.importExternal(name, pathJoin(this.relativePathToBase, "counterfact-types/index.ts"), true);
     }
     exportType(coder) {
         return this.export(coder, true);
     }
+    /** `true` while at least one export promise is still pending. */
     isInProgress() {
         return Array.from(this.exports.values()).some((exportStatement) => !exportStatement.done);
     }
+    /** Returns a promise that resolves when all pending export promises settle. */
     finished() {
         return Promise.all(Array.from(this.exports.values(), (value) => value.promise));
     }
@@ -129,9 +189,7 @@ export class Script {
     }
     importStatements() {
         return Array.from(this.imports, ([name, { isDefault, isType, script }]) => {
-            const resolvedPath = escapePathForWindows(nodePath
-                .relative(nodePath.dirname(this.path).replaceAll("\\", "/"), script.path.replace(/\.ts$/u, ".js"))
-                .replaceAll("\\", "/"));
+            const resolvedPath = escapePathForWindows(pathRelative(pathDirname(this.path), script.path.replace(/\.ts$/u, ".js")));
             return `import${isType ? " type" : ""} ${isDefault ? name : `{ ${name} }`} from "${resolvedPath.includes("../") ? "" : "./"}${resolvedPath}";`;
         });
     }
@@ -150,6 +208,11 @@ export class Script {
             return `${jsdoc}${beforeExport}export ${keyword} ${name ?? ""}${typeAnnotation} = ${code};`;
         });
     }
+    /**
+     * Formats the fully assembled script source with Prettier and returns it.
+     *
+     * All pending export promises are awaited before formatting.
+     */
     contents() {
         return format([
             this.comments.map((comment) => `// ${comment}`).join("\n"),

package/dist/typescript-generator/specification.js

@@ -2,6 +2,14 @@ import { bundle } from "@apidevtools/json-schema-ref-parser";
 import createDebug from "debug";
 import { Requirement } from "./requirement.js";
 const debug = createDebug("counterfact:typescript-generator:specification");
+/**
+ * Represents a fully dereferenced OpenAPI specification as a navigable tree
+ * of {@link Requirement} nodes.
+ *
+ * Use {@link Specification.fromFile} to load a spec from disk or a URL; the
+ * static method bundles external `$ref` references into a single in-memory
+ * object before constructing the tree.
+ */
 export class Specification {
     cache;
     rootRequirement;
@@ -11,15 +19,34 @@ export class Specification {
             this.rootRequirement = rootRequirement;
         }
     }
+    /**
+     * Loads the OpenAPI document at `urlOrPath`, bundles all external `$ref`
+     * references, and returns a fully initialised {@link Specification}.
+     *
+     * @param urlOrPath - A local file path or HTTP(S) URL.
+     * @throws When the document cannot be found or parsed.
+     */
     static async fromFile(urlOrPath) {
         const specification = new Specification();
         await specification.load(urlOrPath);
         return specification;
     }
+    /**
+     * Returns the {@link Requirement} at `url` (a JSON Pointer such as
+     * `"#/paths"`).
+     *
+     * @param url - A JSON Pointer string (must start with `"#/"`).
+     */
     getRequirement(url) {
         debug("getting requirement at %s", url);
         return this.rootRequirement.select(url.slice(2));
     }
+    /**
+     * Loads (or reloads) the specification from `urlOrPath`.
+     *
+     * @param urlOrPath - A local file path or HTTP(S) URL.
+     * @throws When the document cannot be found or parsed.
+     */
     async load(urlOrPath) {
         try {
             this.rootRequirement = new Requirement((await bundle(urlOrPath)), urlOrPath, this);

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

@@ -1,5 +1,12 @@
 import fs from "node:fs";
 import nodePath from "node:path";
+/**
+ * Synchronously ensures that the directory containing `filePath` exists,
+ * creating it (and any missing ancestors) if necessary.
+ *
+ * @param filePath - Path to a file; the *directory* part of this path is
+ *   created, not the file itself.
+ */
 export function ensureDirectoryExists(filePath) {
     const directory = nodePath.dirname(filePath);
     try {

package/dist/util/forward-slash-path.js

@@ -0,0 +1,63 @@
+import nodePath from "node:path";
+/**
+ * Converts a file-system path to use forward slashes as separators.
+ *
+ * On Windows, `node:path` methods such as `path.join` and `path.resolve`
+ * return paths with backslash separators.  Many parts of Counterfact
+ * (chokidar watchers, ES module import specifiers, URL routing) require
+ * forward slashes.  This function centralises that normalisation and returns
+ * a {@link ForwardSlashPath} branded type so that call sites that demand a
+ * forward-slash path are statically enforced.
+ *
+ * @param path - Any file-system path string.
+ * @returns The same path with every `\` replaced by `/`.
+ */
+export function toForwardSlashPath(path) {
+    return path.replaceAll("\\", "/");
+}
+/**
+ * Joins path segments and returns a {@link ForwardSlashPath} with forward
+ * slashes regardless of the host operating system.
+ *
+ * Equivalent to `toForwardSlashPath(nodePath.join(...paths))`.
+ *
+ * @param paths - Path segments to join.
+ * @returns The joined path normalised to forward slashes.
+ */
+export function pathJoin(...paths) {
+    return toForwardSlashPath(nodePath.join(...paths));
+}
+/**
+ * Returns the relative path from `from` to `to` using forward slashes.
+ *
+ * Equivalent to `toForwardSlashPath(nodePath.relative(from, to))`.
+ *
+ * @param from - The starting path.
+ * @param to - The destination path.
+ * @returns The relative path normalised to forward slashes.
+ */
+export function pathRelative(from, to) {
+    return toForwardSlashPath(nodePath.relative(from, to));
+}
+/**
+ * Returns the directory portion of a path using forward slashes.
+ *
+ * Equivalent to `toForwardSlashPath(nodePath.dirname(path))`.
+ *
+ * @param path - The file path.
+ * @returns The directory portion normalised to forward slashes.
+ */
+export function pathDirname(path) {
+    return toForwardSlashPath(nodePath.dirname(path));
+}
+/**
+ * Resolves a sequence of paths into an absolute path using forward slashes.
+ *
+ * Equivalent to `toForwardSlashPath(nodePath.resolve(...paths))`.
+ *
+ * @param paths - Path segments to resolve.
+ * @returns The resolved absolute path normalised to forward slashes.
+ */
+export function pathResolve(...paths) {
+    return toForwardSlashPath(nodePath.resolve(...paths));
+}

package/dist/util/read-file.js

@@ -1,5 +1,16 @@
 import fs from "node:fs/promises";
 import nodeFetch from "node-fetch";
+/**
+ * Reads the content of a file or URL and returns it as a UTF-8 string.
+ *
+ * Accepts three kinds of inputs:
+ * - **HTTP(S) URLs** — fetches with `node-fetch`.
+ * - **`file://` URLs** — reads via the Node.js `fs` module.
+ * - **File system paths** — reads via the Node.js `fs` module.
+ *
+ * @param urlOrPath - A URL string or file-system path.
+ * @returns The file contents as a string.
+ */
 export async function readFile(urlOrPath) {
     if (urlOrPath.startsWith("http")) {
         const response = await nodeFetch(urlOrPath);

package/dist/util/runtime-can-execute-erasable-ts.js

@@ -2,6 +2,17 @@ import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+/**
+ * Probes the current Node.js runtime to determine whether it can execute
+ * TypeScript source files directly (via `--experimental-strip-types` or
+ * equivalent).
+ *
+ * The check works by writing a tiny TypeScript module to a temporary directory
+ * and attempting to import it.  If the import succeeds and returns the
+ * expected value, the runtime supports native TypeScript execution.
+ *
+ * @returns `true` when the runtime can execute `.ts` files natively.
+ */
 export async function runtimeCanExecuteErasableTs() {
     const dir = mkdtempSync(join(tmpdir(), "ts-probe-"));
     // helper.ts is imported via .js extension — the TypeScript convention used

package/dist/util/windows-escape.js

@@ -1,5 +1,16 @@
 const UNICODE_RATIO_SYMBOL = "∶"; // U+2236
 const REGULAR_COLON = ":";
+/**
+ * Escapes a Windows absolute path for use in an ES module import specifier.
+ *
+ * On Windows, drive letters produce colons (e.g. `C:\path`) which are invalid
+ * in URL-like import paths.  The drive separator colon and any additional
+ * colons in the path are replaced with the Unicode ratio symbol `∶` (U+2236),
+ * which is visually identical but safe in import specifiers.
+ *
+ * @param path - The file-system path to escape.
+ * @returns An escaped path safe for use in an import specifier.
+ */
 export function escapePathForWindows(path) {
     if (path.at(1) === ":") {
         return (path.slice(0, 2) +
@@ -7,6 +18,13 @@ export function escapePathForWindows(path) {
     }
     return path.replaceAll(REGULAR_COLON, UNICODE_RATIO_SYMBOL);
 }
+/**
+ * Reverses the transformation applied by {@link escapePathForWindows},
+ * converting `∶` back to `:`.
+ *
+ * @param path - A previously escaped path.
+ * @returns The original unescaped path.
+ */
 export function unescapePathForWindows(path) {
     return path.replaceAll(UNICODE_RATIO_SYMBOL, REGULAR_COLON);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "2.7.0",
+  "version": "2.8.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",
@@ -21,9 +21,9 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/pmcelhaney/counterfact.git"
+    "url": "git+https://github.com/counterfact/api-simulator.git"
   },
-  "bugs": "https://github.com/pmcelhaney/counterfact/issues",
+  "bugs": "https://github.com/counterfact/api-simulator/issues",
   "homepage": "https://counterfact.dev",
   "funding": {
     "type": "github",
@@ -76,7 +76,7 @@
     "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",
-    "go:example": "yarn build && node ./bin/counterfact.js ./openapi-example.yaml out",
+    "go:example": "yarn build && node ./bin/counterfact.js ./test/fixtures/openapi-example.yaml out",
     "counterfact": "./bin/counterfact.js",
     "postinstall": "patch-package"
   },