counterfact 0.30.0 → 0.32.0

package/bin/counterfact.js

@@ -57,29 +57,19 @@ async function main(source, destination) {
 
   debug("loaded counterfact", config);
 
-  const waysToInteract = [
-    `Call the REST APIs at ${url} (with your front end app, curl, Postman, etc.)`,
-    `Change the implementation of the APIs by editing files under ${nodePath
-      .join(basePath, "paths")
-      .replaceAll("\\", "/")} (no need to restart)`,
-    `Use the GUI at ${guiUrl}`,
-    "Use the REPL below (type .counterfact for more information)",
-  ];
-
   const introduction = [
+    "____ ____ _  _ _ _ ___ ____ ____ ____ ____ ____ ___",
+    "|___ [__] |__| |\\|  |  |=== |--< |--- |--| |___  | ",
+    "       High code, low effort mock REST APIs",
     "",
-    "Welcome to Counterfact!",
-    "",
-    "Counterfact is a mock server used to develop and test your front end app.",
-    "There are several ways to poke and prod the server in order to make it behave the way you need for testing.",
+    `| API Base URL  ==> ${url}`,
+    `| Admin Console ==> ${guiUrl}`,
+    "| Instructions  ==> https://counterfact.dev/docs/usage.html",
     "",
+    "Starting REPL, type .help for more info",
   ];
 
-  process.stdout.write(`${introduction.join("\n")}\n`);
-
-  process.stdout.write(
-    waysToInteract.map((text, index) => `${index + 1}. ${text}`).join("\n"),
-  );
+  process.stdout.write(introduction.join("\n"));
 
   process.stdout.write("\n\n");
 

package/dist/server/module-tree.js

@@ -0,0 +1,130 @@
+function isDirectory(test) {
+    return test !== undefined;
+}
+export class ModuleTree {
+    root = {
+        directories: {},
+        files: {},
+        isWildcard: false,
+        name: "",
+        rawName: "",
+    };
+    addModuleToDirectory(directory, segments, module) {
+        if (directory === undefined) {
+            return;
+        }
+        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;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        directory.directories[segment.toLowerCase()] ??= {
+            directories: {},
+            files: {},
+            isWildcard: segment.startsWith("{"),
+            name: segment.replace(/^\{(?<name>.*)\}$/u, "$<name>"),
+            rawName: segment,
+        };
+        this.addModuleToDirectory(directory.directories[segment.toLocaleLowerCase()], remainingSegments, module);
+    }
+    add(url, module) {
+        this.addModuleToDirectory(this.root, url.split("/").slice(1), module);
+    }
+    removeModuleFromDirectory(directory, segments) {
+        if (!isDirectory(directory)) {
+            return;
+        }
+        const [segment, ...remainingSegments] = segments;
+        if (segment === undefined) {
+            return;
+        }
+        if (remainingSegments.length === 0) {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete directory.files[segment.toLowerCase()];
+            return;
+        }
+        this.removeModuleFromDirectory(directory.directories[segment.toLowerCase()], remainingSegments);
+    }
+    remove(url) {
+        const segments = url.split("/").slice(1);
+        this.removeModuleFromDirectory(this.root, segments);
+    }
+    // eslint-disable-next-line max-params
+    buildMatch(directory, segment, pathVariables, matchedPath) {
+        const match = directory.files[segment.toLowerCase()] ??
+            Object.values(directory.files).find((file) => file.isWildcard);
+        if (match === undefined) {
+            return undefined;
+        }
+        if (match.isWildcard) {
+            return {
+                ...match,
+                matchedPath: `${matchedPath}/${match.rawName}`,
+                pathVariables: {
+                    ...pathVariables,
+                    [match.name]: segment,
+                },
+            };
+        }
+        return {
+            ...match,
+            matchedPath: `${matchedPath}/${match.rawName}`,
+            pathVariables,
+        };
+    }
+    // eslint-disable-next-line max-statements, max-params
+    matchWithinDirectory(directory, segments, pathVariables, matchedPath) {
+        if (segments.length === 0) {
+            return undefined;
+        }
+        const [segment, ...remainingSegments] = segments;
+        if (segment === undefined) {
+            throw new Error("segment cannot be undefined but TypeScript doesn't know that");
+        }
+        if (remainingSegments.length === 0) {
+            return this.buildMatch(directory, segment, pathVariables, matchedPath);
+        }
+        const exactMatch = directory.directories[segment.toLowerCase()];
+        if (isDirectory(exactMatch)) {
+            return this.matchWithinDirectory(exactMatch, remainingSegments, pathVariables, `${matchedPath}/${segment}`);
+        }
+        const wildcardDirectory = Object.values(directory.directories).find((subdirectory) => subdirectory.isWildcard);
+        if (wildcardDirectory) {
+            return this.matchWithinDirectory(wildcardDirectory, remainingSegments, {
+                ...pathVariables,
+                [wildcardDirectory.name]: segment,
+            }, `${matchedPath}/${wildcardDirectory.rawName}`);
+        }
+        return undefined;
+    }
+    match(url) {
+        return this.matchWithinDirectory(this.root, url.split("/").slice(1), {}, "");
+    }
+    get routes() {
+        const routes = [];
+        function traverse(directory, path) {
+            Object.values(directory.directories).forEach((subdirectory) => {
+                traverse(subdirectory, `${path}/${subdirectory.rawName}`);
+            });
+            Object.values(directory.files).forEach((file) => {
+                routes.push(`${path}/${file.rawName}`);
+            });
+        }
+        // eslint-disable-next-line unicorn/consistent-function-scoping
+        function stripBrackets(string) {
+            return string.replaceAll(/\{|\}/gu, "");
+        }
+        traverse(this.root, "");
+        // eslint-disable-next-line etc/no-assign-mutated-array
+        return routes.sort((first, second) => stripBrackets(first).localeCompare(stripBrackets(second)));
+    }
+}

package/dist/server/registry.js

@@ -1,4 +1,5 @@
 import createDebugger from "debug";
+import { ModuleTree } from "./module-tree.js";
 const debug = createDebugger("counterfact:server:registry");
 function castParameters(parameters, parameterTypes) {
     const copy = { ...parameters };
@@ -11,87 +12,27 @@ function castParameters(parameters, parameterTypes) {
     });
     return copy;
 }
-function maybe(flag, value) {
-    return flag ? [value] : [];
-}
-function stripBrackets(string) {
-    return string.replaceAll(/\{|\}/gu, "");
-}
-function routesForNode(node) {
-    if (!node.children) {
-        return [];
-    }
-    return Object.entries(node.children)
-        .flatMap(([segment, child]) => [
-        ...maybe(child.module, `/${segment}`),
-        ...routesForNode(child).map((route) => `/${segment}${route}`),
-    ])
-        .sort((segment1, segment2) => stripBrackets(segment1).localeCompare(stripBrackets(segment2)));
-}
 export class Registry {
-    modules = {};
-    moduleTree = { children: {} };
+    moduleTree = new ModuleTree();
     get routes() {
-        return routesForNode(this.moduleTree);
+        return this.moduleTree.routes;
     }
     add(url, module) {
-        let node = this.moduleTree;
-        for (const segment of url.split("/").slice(1)) {
-            node.children ??= {};
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            node.children[segment] ??= {};
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            node = node.children[segment];
-        }
-        node.module = module;
+        this.moduleTree.add(url, module);
     }
     remove(url) {
-        let node = this.moduleTree;
-        for (const segment of url.split("/").slice(1)) {
-            node = node.children?.[segment];
-            if (!node) {
-                return false;
-            }
-        }
-        delete node.module;
-        return true;
+        this.moduleTree.remove(url);
     }
     exists(method, url) {
         return Boolean(this.handler(url).module?.[method]);
     }
-    // eslint-disable-next-line max-statements, sonarjs/cognitive-complexity
     handler(url) {
-        let node = this.moduleTree;
-        const path = {};
-        const matchedParts = [""];
-        for (const segment of url.split("/").slice(1)) {
-            if (node === undefined) {
-                throw new Error("node or node node.children cannot be undefined");
-            }
-            if (node.children === undefined) {
-                throw new Error("node or node node.children cannot be undefined");
-            }
-            const matchingChild = Object.keys(node.children).find((candidate) => candidate.toLowerCase() === segment.toLowerCase());
-            debug("segment: %s", segment);
-            debug("matching child: %s", matchingChild);
-            if (matchingChild === undefined) {
-                const dynamicSegment = Object.keys(node.children).find((ds) => ds.startsWith("{") && ds.endsWith("}"));
-                if (dynamicSegment !== undefined) {
-                    const variableName = dynamicSegment.slice(1, -1);
-                    path[variableName] = segment;
-                    node = node.children[dynamicSegment];
-                    matchedParts.push(dynamicSegment);
-                }
-            }
-            else {
-                node = node.children[matchingChild];
-                matchedParts.push(matchingChild);
-            }
-        }
-        if (node === undefined) {
-            throw new Error("node cannot be undefined");
-        }
-        return { matchedPath: matchedParts.join("/"), module: node.module, path };
+        const match = this.moduleTree.match(url);
+        return {
+            matchedPath: match?.matchedPath ?? "",
+            module: match?.module,
+            path: match?.pathVariables ?? {},
+        };
     }
     endpoint(httpRequestMethod, url, parameterTypes = {}) {
         const handler = this.handler(url);

package/dist/server/types.d.ts

@@ -0,0 +1,201 @@
+interface OpenApiHeader {
+  schema: unknown;
+}
+
+interface OpenApiContent {
+  schema: unknown;
+}
+
+interface Example {
+  description: string;
+  summary: string;
+  value: unknown;
+}
+
+type MediaType = `${string}/${string}`;
+
+type OmitValueWhenNever<Base> = Pick<
+  Base,
+  {
+    [Key in keyof Base]: [Base[Key]] extends [never] ? never : Key;
+  }[keyof Base]
+>;
+
+interface OpenApiResponse {
+  content: { [key: MediaType]: OpenApiContent };
+  headers: { [key: string]: OpenApiHeader };
+}
+
+interface OpenApiResponses {
+  [key: string]: OpenApiResponse;
+}
+
+type IfHasKey<SomeObject, Key, Yes, No> = Key extends keyof SomeObject
+  ? Yes
+  : No;
+
+type MaybeShortcut<
+  ContentType extends MediaType,
+  Response extends OpenApiResponse,
+> = IfHasKey<
+  Response["content"],
+  ContentType,
+  (body: Response["content"][ContentType]["schema"]) => GenericResponseBuilder<{
+    content: Omit<Response["content"], ContentType>;
+    headers: Response["headers"];
+  }>,
+  never
+>;
+
+type MatchFunction<Response extends OpenApiResponse> = <
+  ContentType extends MediaType & keyof Response["content"],
+>(
+  contentType: ContentType,
+  body: Response["content"][ContentType]["schema"],
+) => GenericResponseBuilder<{
+  content: Omit<Response["content"], ContentType>;
+  headers: Response["headers"];
+}>;
+
+type HeaderFunction<Response extends OpenApiResponse> = <
+  Header extends string & keyof Response["headers"],
+>(
+  header: Header,
+  value: Response["headers"][Header]["schema"],
+) => GenericResponseBuilder<{
+  content: Response["content"];
+  headers: Omit<Response["headers"], Header>;
+}>;
+
+interface ResponseBuilder {
+  [status: number | `${number} ${string}`]: ResponseBuilder;
+  content?: { body: unknown; type: string }[];
+  header: (name: string, value: string) => ResponseBuilder;
+  headers: { [name: string]: string };
+  html: (body: unknown) => ResponseBuilder;
+  json: (body: unknown) => ResponseBuilder;
+  match: (contentType: string, body: unknown) => ResponseBuilder;
+  random: () => ResponseBuilder;
+  randomLegacy: () => ResponseBuilder;
+  status?: number;
+  text: (body: unknown) => ResponseBuilder;
+}
+
+type GenericResponseBuilder<
+  Response extends OpenApiResponse = OpenApiResponse,
+> = [keyof Response["content"]] extends [never]
+  ? // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    void
+  : OmitValueWhenNever<{
+      header: [keyof Response["headers"]] extends [never]
+        ? never
+        : HeaderFunction<Response>;
+      html: MaybeShortcut<"text/html", Response>;
+      json: MaybeShortcut<"application/json", Response>;
+      match: [keyof Response["content"]] extends [never]
+        ? never
+        : MatchFunction<Response>;
+      random: [keyof Response["content"]] extends [never] ? never : () => void;
+      text: MaybeShortcut<"text/plain", Response>;
+    }>;
+
+type ResponseBuilderFactory<
+  Responses extends OpenApiResponses = OpenApiResponses,
+> = {
+  [StatusCode in keyof Responses]: GenericResponseBuilder<
+    Responses[StatusCode]
+  >;
+} & { [key: string]: GenericResponseBuilder<Responses["default"]> };
+
+type HttpStatusCode =
+  | 100
+  | 101
+  | 102
+  | 200
+  | 201
+  | 202
+  | 203
+  | 204
+  | 205
+  | 206
+  | 207
+  | 226
+  | 300
+  | 301
+  | 302
+  | 303
+  | 304
+  | 305
+  | 307
+  | 308
+  | 400
+  | 401
+  | 402
+  | 403
+  | 404
+  | 405
+  | 406
+  | 407
+  | 408
+  | 409
+  | 410
+  | 411
+  | 412
+  | 413
+  | 414
+  | 415
+  | 416
+  | 417
+  | 418
+  | 422
+  | 423
+  | 424
+  | 426
+  | 428
+  | 429
+  | 431
+  | 451
+  | 500
+  | 501
+  | 502
+  | 503
+  | 504
+  | 505
+  | 506
+  | 507
+  | 511;
+
+interface OpenApiParameters {
+  in: "body" | "cookie" | "formData" | "header" | "path" | "query";
+  name: string;
+  schema?: {
+    type: string;
+  };
+}
+
+interface OpenApiOperation {
+  parameters?: OpenApiParameters[];
+  produces?: string[];
+  responses: {
+    [status: string]: {
+      content?: {
+        [type: number | string]: {
+          examples?: { [key: string]: Example };
+          schema: unknown;
+        };
+      };
+      examples?: { [key: string]: unknown };
+      schema?: unknown;
+    };
+  };
+}
+
+export type {
+  HttpStatusCode,
+  MediaType,
+  OpenApiOperation,
+  OpenApiParameters,
+  OpenApiResponse,
+  ResponseBuilder,
+  ResponseBuilderFactory,
+};

package/dist/typescript-generator/repository.js

@@ -32,7 +32,7 @@ export class Repository {
     }
     copyCoreFiles(destination) {
         return fs.copyFile(nodePath
-            .join(__dirname, "../../src/server/types.d.ts")
+            .join(__dirname, "../../dist/server/types.d.ts")
             .replaceAll("\\", "/"), nodePath.join(destination, "types.d.ts").replaceAll("\\", "/"));
     }
     async writeFiles(destination) {
@@ -48,13 +48,12 @@ export class Repository {
                     .stat(fullPath)
                     .then((stat) => stat.isFile())
                     .catch(() => false))) {
-                process.stdout.write(`not overwriting ${fullPath}\n`);
+                debug(`not overwriting ${fullPath}\n`);
                 return;
             }
             debug("about to write", fullPath);
             await fs.writeFile(fullPath, contents);
             debug("did write", fullPath);
-            process.stdout.write(`writing ${fullPath}\n`);
         });
         await Promise.all(writeFiles);
         await this.copyCoreFiles(destination);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "0.30.0",
+  "version": "0.32.0",
   "description": "a library for building a fake REST API for testing",
   "type": "module",
   "main": "./src/server/counterfact.js",
@@ -31,7 +31,7 @@
     "test": "yarn node --experimental-vm-modules ./node_modules/jest-cli/bin/jest --testPathIgnorePatterns=black-box --forceExit",
     "test:black-box": "rimraf dist && rimraf out && yarn build && yarn node --experimental-vm-modules ./node_modules/jest-cli/bin/jest black-box --forceExit --coverage=false",
     "test:mutants": "stryker run stryker.config.json",
-    "build": "tsc && copyfiles -f \"src/client/**\" dist/client",
+    "build": "tsc && copyfiles -f \"src/client/**\" dist/client && copyfiles -f \"src/server/*.d.ts\" dist/server",
     "prepack": "yarn build",
     "release": "npx changeset publish",
     "prepare": "husky install",
@@ -43,21 +43,21 @@
     "counterfact": "./bin/counterfact.js"
   },
   "devDependencies": {
-    "@changesets/cli": "2.26.2",
-    "@stryker-mutator/core": "7.3.0",
-    "@stryker-mutator/jest-runner": "7.3.0",
-    "@stryker-mutator/typescript-checker": "7.3.0",
-    "@swc/core": "1.3.96",
+    "@changesets/cli": "2.27.1",
+    "@stryker-mutator/core": "8.0.0",
+    "@stryker-mutator/jest-runner": "8.0.0",
+    "@stryker-mutator/typescript-checker": "8.0.0",
+    "@swc/core": "1.3.100",
     "@swc/jest": "0.2.29",
     "@testing-library/dom": "9.3.3",
-    "@types/jest": "29.5.8",
+    "@types/jest": "29.5.10",
     "@types/js-yaml": "4.0.9",
-    "@types/koa": "2.13.11",
+    "@types/koa": "2.13.12",
     "@types/koa-bodyparser": "4.3.12",
     "@types/koa-proxy": "1.0.7",
     "@types/koa-static": "4.0.4",
     "copyfiles": "2.4.1",
-    "eslint": "8.53.0",
+    "eslint": "8.55.0",
     "eslint-config-hardcore": "41.3.0",
     "eslint-formatter-github-annotations": "0.1.0",
     "eslint-import-resolver-typescript": "3.6.1",
@@ -71,7 +71,7 @@
     "husky": "8.0.3",
     "jest": "29.7.0",
     "node-mocks-http": "1.13.0",
-    "nodemon": "3.0.1",
+    "nodemon": "3.0.2",
     "patch-package": "8.0.0",
     "rimraf": "5.0.5",
     "stryker-cli": "1.0.2",
@@ -84,20 +84,20 @@
     "commander": "11.1.0",
     "debug": "4.3.4",
     "fetch": "1.1.0",
-    "fs-extra": "11.1.1",
+    "fs-extra": "11.2.0",
     "handlebars": "4.7.8",
     "http-terminator": "3.2.0",
     "js-yaml": "4.1.0",
-    "json-schema-faker": "0.5.3",
+    "json-schema-faker": "0.5.4",
     "json-schema-ref-parser": "9.0.9",
     "jsonwebtoken": "9.0.2",
     "koa": "2.14.2",
     "koa-bodyparser": "4.4.1",
     "koa-proxy": "1.0.0-alpha.3",
-    "koa2-swagger-ui": "5.9.1",
+    "koa2-swagger-ui": "5.10.0",
     "node-fetch": "3.3.2",
     "open": "9.1.0",
-    "prettier": "3.0.3",
-    "typescript": "5.2.2"
+    "prettier": "3.1.0",
+    "typescript": "5.3.2"
   }
 }