counterfact 1.2.0 → 1.4.0

package/dist/app.js

@@ -1,4 +1,4 @@
-import { rm } from "node:fs/promises";
+import fs, { rm } from "node:fs/promises";
 import nodePath from "node:path";
 import { dereference } from "@apidevtools/json-schema-ref-parser";
 import { createHttpTerminator } from "http-terminator";
@@ -6,14 +6,24 @@ import yaml from "js-yaml";
 import { startRepl } from "./repl/repl.js";
 import { ContextRegistry } from "./server/context-registry.js";
 import { createKoaApp } from "./server/create-koa-app.js";
-import { Dispatcher } from "./server/dispatcher.js";
+import { Dispatcher, } from "./server/dispatcher.js";
 import { koaMiddleware } from "./server/koa-middleware.js";
 import { ModuleLoader } from "./server/module-loader.js";
 import { Registry } from "./server/registry.js";
 import { Transpiler } from "./server/transpiler.js";
 import { CodeGenerator } from "./typescript-generator/code-generator.js";
 import { readFile } from "./util/read-file.js";
-async function loadOpenApiDocument(source) {
+const allowedMethods = [
+    "all",
+    "head",
+    "get",
+    "post",
+    "put",
+    "delete",
+    "patch",
+    "options",
+];
+export async function loadOpenApiDocument(source) {
     try {
         const text = await readFile(source);
         const openApiDocument = await yaml.load(text);
@@ -23,6 +33,50 @@ async function loadOpenApiDocument(source) {
         return undefined;
     }
 }
+const mswHandlers = {};
+export async function handleMswRequest(request) {
+    const { method, rawPath } = request;
+    const handler = mswHandlers[`${method}:${rawPath}`];
+    if (handler) {
+        return handler(request);
+    }
+    console.warn(`No handler found for ${method} ${rawPath}`);
+    return { error: `No handler found for ${method} ${rawPath}`, status: 404 };
+}
+export async function createMswHandlers(config, ModuleLoaderClass = ModuleLoader) {
+    // TODO: For some reason the Vitest Custom Commands needed by Vitest Browser mode fail on fs.readFile when they are called from the nested loadOpenApiDocument function.
+    // If we "pre-read" the file here it works. This is a workaround to avoid the issue.
+    const _ = await fs.readFile(config.openApiPath);
+    const openApiDocument = await loadOpenApiDocument(config.openApiPath);
+    if (openApiDocument === undefined) {
+        throw new Error(`Could not load OpenAPI document from ${config.openApiPath}`);
+    }
+    const modulesPath = config.basePath;
+    const compiledPathsDirectory = nodePath
+        .join(modulesPath, ".cache")
+        .replaceAll("\\", "/");
+    const registry = new Registry();
+    const contextRegistry = new ContextRegistry();
+    const dispatcher = new Dispatcher(registry, contextRegistry, openApiDocument, config);
+    const moduleLoader = new ModuleLoaderClass(compiledPathsDirectory, registry, contextRegistry);
+    await moduleLoader.load();
+    const routes = registry.routes;
+    const handlers = routes.flatMap((route) => {
+        const { methods, path } = route;
+        return Object.keys(methods)
+            .filter((method) => allowedMethods.includes(method.toLowerCase()))
+            .map((method) => {
+            const lowerMethod = method.toLowerCase();
+            const apiPath = `${openApiDocument.basePath ?? ""}${path.replaceAll("{", ":").replaceAll("}", "")}`;
+            const handler = async (request) => {
+                return await dispatcher.request(request);
+            };
+            mswHandlers[`${method}:${apiPath}`] = handler;
+            return { method: lowerMethod, path: apiPath };
+        });
+    });
+    return handlers;
+}
 export async function counterfact(config) {
     const modulesPath = config.basePath;
     const compiledPathsDirectory = nodePath

package/dist/server/dispatcher.js

@@ -62,14 +62,6 @@ export class Dispatcher {
         return operation;
     }
     normalizeResponse(response, acceptHeader) {
-        if (typeof response === "string") {
-            return {
-                body: response,
-                contentType: "text/plain",
-                headers: {},
-                status: 200,
-            };
-        }
         if (response.content !== undefined) {
             const content = this.selectContent(acceptHeader, response.content);
             if (content === undefined) {
@@ -89,7 +81,9 @@ export class Dispatcher {
         }
         return {
             ...response,
-            contentType: response.headers?.["content-type"]?.toString() ?? "unknown/unknown",
+            contentType: response.headers?.["content-type"]?.toString() ??
+                response.contentType ??
+                "unknown/unknown",
         };
     }
     selectContent(acceptHeader, content) {

package/dist/server/module-loader.js

@@ -15,6 +15,11 @@ const debug = createDebug("counterfact:server:module-loader");
 function isContextModule(module) {
     return "Context" in module && typeof module.Context === "function";
 }
+function isMiddlewareModule(module) {
+    return ("middleware" in module &&
+        typeof Object.getOwnPropertyDescriptor(module, "middleware")?.value ===
+            "function");
+}
 export class ModuleLoader extends EventTarget {
     basePath;
     registry;
@@ -96,23 +101,27 @@ export class ModuleLoader extends EventTarget {
             const doImport = (await determineModuleKind(pathName)) === "commonjs"
                 ? uncachedRequire
                 : uncachedImport;
-            const endpoint = (await doImport(pathName));
+            const endpoint = (await doImport(pathName).catch((err) => {
+                console.log("ERROR");
+            }));
             this.dispatchEvent(new Event("add"));
-            if (basename(pathName).startsWith("_.context")) {
-                if (isContextModule(endpoint)) {
-                    const loadContext = (path) => this.contextRegistry.find(path);
-                    this.contextRegistry.update(directory, 
-                    // @ts-expect-error TS says Context has no constructable signatures but that's not true?
-                    new endpoint.Context({
-                        loadContext,
-                    }));
-                }
+            if (basename(pathName).startsWith("_.context.") &&
+                isContextModule(endpoint)) {
+                const loadContext = (path) => this.contextRegistry.find(path);
+                this.contextRegistry.update(directory, 
+                // @ts-expect-error TS says Context has no constructable signatures but that's not true?
+                new endpoint.Context({
+                    loadContext,
+                }));
+                return;
             }
-            else {
-                if (url === "/index")
-                    this.registry.add("/", endpoint);
-                this.registry.add(url, endpoint);
+            if (basename(pathName).startsWith("_.middleware.") &&
+                isMiddlewareModule(endpoint)) {
+                this.registry.addMiddleware(url.slice(0, url.lastIndexOf("/")) || "/", endpoint.middleware);
             }
+            if (url === "/index")
+                this.registry.add("/", endpoint);
+            this.registry.add(url, endpoint);
         }
         catch (error) {
             if (String(error) ===
@@ -120,8 +129,8 @@ export class ModuleLoader extends EventTarget {
                 // Not sure why Node throws this error. It doesn't seem to matter.
                 return;
             }
-            throw error;
             process.stdout.write(`\nError loading ${pathName}:\n${String(error)}\n`);
+            throw error;
         }
     }
 }

package/dist/server/module-tree.js

@@ -9,31 +9,38 @@ export class ModuleTree {
         name: "",
         rawName: "",
     };
-    addModuleToDirectory(directory, segments, module) {
-        if (directory === undefined) {
-            return;
-        }
+    putDirectory(directory, segments) {
         const [segment, ...remainingSegments] = segments;
         if (segment === undefined) {
             throw new Error("segments array is empty");
         }
         if (remainingSegments.length === 0) {
-            directory.files[segment.toLowerCase()] = {
-                isWildcard: segment.startsWith("{"),
-                module,
-                name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
-                rawName: segment,
-            };
-            return;
+            return directory;
         }
-        directory.directories[segment.toLowerCase()] ??= {
+        const nextDirectory = (directory.directories[segment.toLowerCase()] ??= {
             directories: {},
             files: {},
             isWildcard: segment.startsWith("{"),
             name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
             rawName: segment,
+        });
+        return this.putDirectory(nextDirectory, remainingSegments);
+    }
+    addModuleToDirectory(directory, segments, module) {
+        if (directory === undefined) {
+            return;
+        }
+        const targetDirectory = this.putDirectory(directory, segments);
+        const filename = segments.at(-1);
+        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] = {
+            isWildcard: filename.startsWith("{"),
+            module,
+            name: filename.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
+            rawName: filename,
         };
-        this.addModuleToDirectory(directory.directories[segment.toLocaleLowerCase()], remainingSegments, module);
     }
     add(url, module) {
         this.addModuleToDirectory(this.root, url.split("/").slice(1), module);
@@ -60,7 +67,15 @@ export class ModuleTree {
         return file.module[method] !== undefined;
     }
     buildMatch(directory, segment, pathVariables, matchedPath, method) {
-        const match = directory.files[segment.toLowerCase()] ??
+        function normalizedSegment(segment, directory) {
+            for (const file in directory.files) {
+                if (file.toLowerCase() === segment.toLowerCase()) {
+                    return file;
+                }
+            }
+            return "";
+        }
+        const match = directory.files[normalizedSegment(segment, directory)] ??
             Object.values(directory.files).find((file) => file.isWildcard && this.fileModuleDefined(file, method));
         if (match === undefined) {
             return undefined;

package/dist/server/registry.js

@@ -25,12 +25,19 @@ function castParameters(parameters = {}, parameterTypes = {}) {
 }
 export class Registry {
     moduleTree = new ModuleTree();
+    middlewares = new Map();
+    constructor() {
+        this.middlewares.set("/", ($, respondTo) => respondTo($));
+    }
     get routes() {
         return this.moduleTree.routes;
     }
     add(url, module) {
         this.moduleTree.add(url, module);
     }
+    addMiddleware(url, callback) {
+        this.middlewares.set(url, callback);
+    }
     remove(url) {
         this.moduleTree.remove(url);
     }
@@ -66,7 +73,37 @@ export class Registry {
                 query: castParameters(requestData.query, parameterTypes.query),
             };
             operationArgument.x = operationArgument;
-            return await execute(operationArgument);
+            const executeAndNormalizeResponse = async (requestData) => {
+                const result = await execute(requestData);
+                if (typeof result === "string") {
+                    return {
+                        headers: {},
+                        status: 200,
+                        body: result,
+                        contentType: "text/plain",
+                    };
+                }
+                if (typeof result === "undefined") {
+                    return {
+                        headers: {},
+                        body: `The ${httpRequestMethod} function did not return anything. Did you forget a return statement?`,
+                        status: 500,
+                    };
+                }
+                return result;
+            };
+            const middlewares = this.middlewares;
+            function recurse(path, respondTo) {
+                if (path === null)
+                    return respondTo;
+                const nextPath = path === "" ? null : path.slice(0, path.lastIndexOf("/"));
+                const middleware = middlewares.get(path);
+                if (middleware !== undefined) {
+                    return recurse(nextPath, ($) => middleware($, respondTo));
+                }
+                return recurse(nextPath, respondTo);
+            }
+            return recurse(operationArgument.matchedPath ?? "/", executeAndNormalizeResponse)(operationArgument);
         };
     }
 }

package/dist/server/response-builder.js

@@ -55,7 +55,7 @@ export function createResponseBuilder(operation, config) {
                 return {
                     ...this,
                     content: [
-                        ...(this.content ?? []),
+                        ...(this.content ?? []).filter((response) => response.type !== contentType),
                         {
                             body: convertToXmlIfNecessary(contentType, body, operation.responses[this.status ?? "default"]?.content?.[contentType]?.schema),
                             type: contentType,

package/dist/server/types.ts

@@ -278,4 +278,5 @@ export type {
   ResponseBuilder,
   ResponseBuilderFactory,
   WideOperationArgument,
+  WideResponseBuilder,
 };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "counterfact",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "a library for building a fake REST API for testing",
   "type": "module",
-  "main": "./src/server/counterfact.js",
-  "exports": "./src/server/counterfact.js",
-  "types": "./src/counterfact.d.ts",
+  "main": "./dist/app.js",
+  "exports": "./dist/app.js",
+  "types": "./dist/server/types.d.ts",
   "author": "Patrick McElhaney <pmcelhaney@gmail.com> (https://patrickmcelhaney.com)",
   "license": "MIT",
   "repository": "github:pmcelhaney/counterfact",
@@ -44,12 +44,12 @@
     "postinstall": "patch-package"
   },
   "devDependencies": {
-    "@changesets/cli": "2.27.12",
-    "@stryker-mutator/core": "8.7.1",
-    "@stryker-mutator/jest-runner": "8.7.1",
-    "@stryker-mutator/typescript-checker": "8.7.1",
-    "@swc/core": "1.10.14",
-    "@swc/jest": "0.2.37",
+    "@changesets/cli": "2.29.4",
+    "@stryker-mutator/core": "9.0.1",
+    "@stryker-mutator/jest-runner": "9.0.1",
+    "@stryker-mutator/typescript-checker": "9.0.1",
+    "@swc/core": "1.11.29",
+    "@swc/jest": "0.2.38",
     "@testing-library/dom": "10.4.0",
     "@types/jest": "29.5.14",
     "@types/js-yaml": "4.0.9",
@@ -57,55 +57,56 @@
     "@types/koa-bodyparser": "4.3.12",
     "@types/koa-proxy": "1.0.7",
     "@types/koa-static": "4.0.4",
-    "@types/lodash": "4.17.15",
+    "@types/lodash": "4.17.17",
     "copyfiles": "2.4.1",
-    "eslint": "9.19.0",
+    "eslint": "9.28.0",
     "eslint-config-hardcore": "47.0.1",
     "eslint-formatter-github-annotations": "0.1.0",
-    "eslint-import-resolver-typescript": "3.7.0",
+    "eslint-import-resolver-typescript": "4.4.2",
     "eslint-plugin-etc": "2.0.3",
-    "eslint-plugin-file-progress": "3.0.1",
+    "eslint-plugin-file-progress": "3.0.2",
     "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-jest": "28.11.0",
+    "eslint-plugin-jest": "28.12.0",
     "eslint-plugin-jest-dom": "5.5.0",
     "eslint-plugin-no-explicit-type-exports": "0.12.1",
-    "eslint-plugin-prettier": "5.2.3",
+    "eslint-plugin-prettier": "5.4.1",
     "eslint-plugin-unused-imports": "4.1.4",
     "husky": "9.1.7",
     "jest": "29.7.0",
     "jest-retries": "1.0.1",
-    "node-mocks-http": "1.16.2",
+    "node-mocks-http": "1.17.2",
     "rimraf": "6.0.1",
     "stryker-cli": "1.0.2",
-    "supertest": "7.0.0",
+    "supertest": "7.1.1",
     "using-temporary-files": "2.2.1"
   },
   "dependencies": {
-    "@apidevtools/json-schema-ref-parser": "11.9.0",
+    "@apidevtools/json-schema-ref-parser": "12.0.2",
     "@hapi/accept": "6.0.3",
     "@types/json-schema": "7.0.15",
     "ast-types": "0.14.2",
     "chokidar": "4.0.3",
-    "commander": "13.1.0",
-    "debug": "4.4.0",
+    "commander": "14.0.0",
+    "debug": "4.4.1",
     "fetch": "1.1.0",
     "fs-extra": "11.3.0",
     "handlebars": "4.7.8",
     "http-terminator": "3.2.0",
     "js-yaml": "4.1.0",
-    "json-schema-faker": "0.5.8",
+    "json-schema-faker": "0.5.9",
     "jsonwebtoken": "9.0.2",
-    "koa": "2.15.3",
+    "koa": "3.0.0",
     "koa-bodyparser": "4.4.1",
     "koa-proxies": "0.12.4",
     "koa2-swagger-ui": "5.11.0",
     "lodash": "4.17.21",
     "node-fetch": "3.3.2",
-    "open": "10.1.0",
+    "open": "10.1.2",
     "patch-package": "8.0.0",
-    "precinct": "12.1.3",
-    "prettier": "3.4.2",
-    "recast": "0.23.9",
-    "typescript": "5.7.3"
-  }
+    "precinct": "12.2.0",
+    "prettier": "3.5.3",
+    "recast": "0.23.11",
+    "typescript": "5.8.3"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }