counterfact 0.37.1 → 0.38.0

package/dist/server/dispatcher.js

@@ -110,9 +110,15 @@ export class Dispatcher {
         }
         return false;
     }
-    // eslint-disable-next-line sonarjs/cognitive-complexity
+    // eslint-disable-next-line sonarjs/cognitive-complexity, max-statements
     async request({ body, headers = {}, method, path, query, req, }) {
         debug(`request: ${method} ${path}`);
+        // If the incoming path includes the base path, remove it
+        if (this.openApiDocument?.basePath !== undefined &&
+            path.toLowerCase().startsWith(this.openApiDocument.basePath.toLowerCase())) {
+            // eslint-disable-next-line security/detect-non-literal-regexp
+            path = path.replace(new RegExp(this.openApiDocument.basePath, "iu"), "");
+        }
         const { matchedPath } = this.registry.handler(path);
         const operation = this.operationForPathAndMethod(matchedPath, method);
         const response = await this.registry.endpoint(method, path, this.parameterTypes(operation?.parameters))({

package/dist/server/registry.js

@@ -46,12 +46,17 @@ export class Registry {
                 status: 404,
             });
         }
-        return async ({ ...requestData }) => await execute({
-            ...requestData,
-            headers: castParameters(requestData.headers, parameterTypes.header),
-            matchedPath: handler.matchedPath,
-            path: castParameters(handler.path, parameterTypes.path),
-            query: castParameters(requestData.query, parameterTypes.query),
-        });
+        return async ({ ...requestData }) => {
+            const operationArgument = {
+                ...requestData,
+                headers: castParameters(requestData.headers, parameterTypes.header),
+                matchedPath: handler.matchedPath,
+                path: castParameters(handler.path, parameterTypes.path),
+                query: castParameters(requestData.query, parameterTypes.query),
+            };
+            // eslint-disable-next-line id-length
+            operationArgument.x = operationArgument;
+            return await execute(operationArgument);
+        };
     }
 }

package/dist/server/types.d.ts

@@ -41,19 +41,21 @@ type MaybeShortcut<
   Response["content"],
   ContentType,
   (body: Response["content"][ContentType]["schema"]) => GenericResponseBuilder<{
-    content: Omit<Response["content"], ContentType>;
+    content: NeverIfEmpty<Omit<Response["content"], ContentType>>;
     headers: Response["headers"];
   }>,
   never
 >;
 
+type NeverIfEmpty<Record> = {} extends Record ? never : Record;
+
 type MatchFunction<Response extends OpenApiResponse> = <
   ContentType extends MediaType & keyof Response["content"],
 >(
   contentType: ContentType,
-  body: Response["content"][ContentType]["schema"],
+  body: Response["content"][ContentType]["schema"]
 ) => GenericResponseBuilder<{
-  content: Omit<Response["content"], ContentType>;
+  content: NeverIfEmpty<Omit<Response["content"], ContentType>>;
   headers: Response["headers"];
 }>;
 
@@ -61,19 +63,15 @@ type HeaderFunction<Response extends OpenApiResponse> = <
   Header extends string & keyof Response["headers"],
 >(
   header: Header,
-  value: Response["headers"][Header]["schema"],
+  value: Response["headers"][Header]["schema"]
 ) => GenericResponseBuilder<{
-  content: Response["content"];
-  headers: Omit<Response["headers"], Header>;
+  content: NeverIfEmpty<Response["content"]>;
+  headers: NeverIfEmpty<Omit<Response["headers"], Header>>;
 }>;
 
 type RandomFunction<Response extends OpenApiResponse> = <
   Header extends string & keyof Response["headers"],
->() => GenericResponseBuilder<{
-  content: {};
-  headers: Response["headers"];
-}>;
-
+>() => "COUNTERFACT_RESPONSE";
 
 interface ResponseBuilder {
   [status: number | `${number} ${string}`]: ResponseBuilder;
@@ -90,23 +88,27 @@ interface ResponseBuilder {
   xml: (body: unknown) => ResponseBuilder;
 }
 
+type GenericResponseBuilderInner<
+  Response extends OpenApiResponse = OpenApiResponse,
+> = 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
+    : RandomFunction<Response>;
+  text: MaybeShortcut<"text/plain", Response>;
+  xml: MaybeShortcut<"application/xml" | "text/xml", Response>;
+}>;
+
 type GenericResponseBuilder<
   Response extends OpenApiResponse = OpenApiResponse,
-> = [keyof Response["content"]] extends [never]
-  ? { }
-  : 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 : RandomFunction<Response>;
-      text: MaybeShortcut<"text/plain", Response>;
-      xml: MaybeShortcut<"application/xml" | "text/xml", Response>;
-    }>;
+> = {} extends OmitValueWhenNever<Response> ? "COUNTERFACT_RESPONSE" : GenericResponseBuilderInner<Response>;
 
 type ResponseBuilderFactory<
   Responses extends OpenApiResponses = OpenApiResponses,
@@ -199,6 +201,26 @@ interface OpenApiOperation {
   };
 }
 
+type WideResponseBuilder  = {   
+  header: (body: unknown) => WideResponseBuilder;
+  html: (body: unknown) => WideResponseBuilder;
+  json: (body: unknown) => WideResponseBuilder;
+  match: (contentType: string, body: unknown) => WideResponseBuilder;
+  random: () => WideResponseBuilder;
+  text: (body: unknown) => WideResponseBuilder;
+  xml: (body: unknown) => WideResponseBuilder;
+}
+
+type WideOperationArgument = {
+  path: Record<string, string>;
+  query: Record<string, string>;
+  header: Record<string, string>;
+  body: unknown;
+  response: Record<number, WideResponseBuilder>;
+  proxy: (url: string) => { proxyUrl: string };
+  context: unknown
+};
+
 export type {
   HttpStatusCode,
   MediaType,
@@ -207,4 +229,6 @@ export type {
   OpenApiResponse,
   ResponseBuilder,
   ResponseBuilderFactory,
+  WideOperationArgument,
+  OmitValueWhenNever
 };

package/dist/typescript-generator/operation-type-coder.js

@@ -2,6 +2,7 @@ import nodePath from "node:path";
 import { Coder } from "./coder.js";
 import { CONTEXT_FILE_TOKEN } from "./context-file-token.js";
 import { ParametersTypeCoder } from "./parameters-type-coder.js";
+import { READ_ONLY_COMMENTS } from "./read-only-comments.js";
 import { ResponseTypeCoder } from "./response-type-coder.js";
 import { SchemaTypeCoder } from "./schema-type-coder.js";
 export class OperationTypeCoder extends Coder {
@@ -48,29 +49,28 @@ export class OperationTypeCoder extends Coder {
             .join("path-types", pathString)
             .replaceAll("\\", "/")}.types.ts`;
     }
+    // eslint-disable-next-line max-statements
     write(script) {
+        // eslint-disable-next-line no-param-reassign
+        script.comments = READ_ONLY_COMMENTS;
+        const xType = script.importSharedType("WideOperationArgument");
+        script.importSharedType("OmitValueWhenNever");
         const contextTypeImportName = script.importExternalType("Context", CONTEXT_FILE_TOKEN);
         const parameters = this.requirement.get("parameters");
-        const queryType = parameters === undefined
-            ? "never"
-            : new ParametersTypeCoder(parameters, "query").write(script);
-        const pathType = parameters === undefined
-            ? "never"
-            : new ParametersTypeCoder(parameters, "path").write(script);
-        const headerType = parameters === undefined
-            ? "never"
-            : new ParametersTypeCoder(parameters, "header").write(script);
+        const queryType = new ParametersTypeCoder(parameters, "query").write(script);
+        const pathType = new ParametersTypeCoder(parameters, "path").write(script);
+        const headerType = new ParametersTypeCoder(parameters, "header").write(script);
         const bodyRequirement = this.requirement.get("consumes")
             ? parameters
                 .find((parameter) => ["body", "formData"].includes(parameter.get("in").data))
                 .get("schema")
             : this.requirement.select("requestBody/content/application~1json/schema");
-        const bodyType = bodyRequirement
-            ? new SchemaTypeCoder(bodyRequirement).write(script)
-            : "undefined";
+        const bodyType = bodyRequirement === undefined
+            ? "never"
+            : new SchemaTypeCoder(bodyRequirement).write(script);
         const responseType = new ResponseTypeCoder(this.requirement.get("responses"), this.requirement.get("produces")?.data ??
             this.requirement.specification?.rootRequirement?.get("produces")?.data).write(script);
-        const proxyType = "(url: string) => { proxyUrl: string }";
-        return `({ query, path, header, body, context, proxy }: { query: ${queryType}, path: ${pathType}, header: ${headerType}, body: ${bodyType}, context: ${contextTypeImportName}, response: ${responseType}, proxy: ${proxyType} }) => ${this.responseTypes(script)} | { status: 415, contentType: "text/plain", body: string } | { }`;
+        const proxyType = '(url: string) => "COUNTERFACT_RESPONSE"';
+        return `($: OmitValueWhenNever<{ query: ${queryType}, path: ${pathType}, header: ${headerType}, body: ${bodyType}, context: ${contextTypeImportName}, response: ${responseType}, x: ${xType}, proxy: ${proxyType} }>) => ${this.responseTypes(script)} | { status: 415, contentType: "text/plain", body: string } | "COUNTERFACT_RESPONSE"`;
     }
 }

package/dist/typescript-generator/parameters-type-coder.js

@@ -10,7 +10,7 @@ export class ParametersTypeCoder extends Coder {
         return super.names("parameters");
     }
     write(script) {
-        const typeDefinitions = this.requirement.data
+        const typeDefinitions = (this.requirement?.data ?? [])
             .filter((parameter) => parameter.in === this.placement)
             .map((parameter, index) => {
             const requirement = this.requirement.get(String(index));

package/dist/typescript-generator/read-only-comments.js

@@ -0,0 +1,5 @@
+export const READ_ONLY_COMMENTS = [
+    "This code was automatically generated from an OpenAPI description.",
+    "Do not edit this file. Edit the OpenAPI file instead.",
+    "For more information, see https://github.com/pmcelhaney/counterfact/blob/main/docs/faq-generated-code.md",
+];

package/dist/typescript-generator/repository.js

@@ -33,19 +33,13 @@ export class Repository {
         }
     }
     async copyCoreFiles(destination) {
-        const sourcePath = nodePath
-            .join(__dirname, "../../dist/server/types.d.ts")
-            .replaceAll("\\", "/");
+        const sourcePath = nodePath.join(__dirname, "../../dist/server/types.d.ts");
+        const destinationPath = nodePath.join(destination, "types.d.ts");
         if (!existsSync(sourcePath)) {
             return false;
         }
-        const destinationPath = nodePath
-            .join(destination, "types.d.ts")
-            .replaceAll("\\", "/");
         await ensureDirectoryExists(destination);
-        return fs.copyFile(nodePath
-            .join(__dirname, "../../dist/server/types.d.ts")
-            .replaceAll("\\", "/"), destinationPath);
+        return fs.copyFile(sourcePath, destinationPath);
     }
     async writeFiles(destination) {
         debug("waiting for %i or more scripts to finish before writing files", this.scripts.size);
@@ -93,7 +87,9 @@ export class Context {
 `);
     }
     findContextPath(destination, path) {
-        return nodePath.relative(nodePath.join(destination, nodePath.dirname(path)), this.nearestContextFile(destination, path));
+        return nodePath
+            .relative(nodePath.join(destination, nodePath.dirname(path)), this.nearestContextFile(destination, path))
+            .replaceAll("\\", "/");
     }
     nearestContextFile(destination, path) {
         const directory = nodePath.dirname(path).replace("path-types", "paths");

package/dist/typescript-generator/response-type-coder.js

@@ -1,4 +1,3 @@
-import nodePath from "node:path";
 import { Coder } from "./coder.js";
 import { printObject, printObjectWithoutQuotes } from "./printers.js";
 import { SchemaTypeCoder } from "./schema-type-coder.js";
@@ -66,15 +65,10 @@ export class ResponseTypeCoder extends Coder {
         ]));
     }
     write(script) {
-        const basePath = script.path
-            .split("/")
-            .slice(0, -1)
-            .map(() => "..")
-            .join("/");
-        script.importExternalType("ResponseBuilderFactory", nodePath.join(basePath, "types.d.ts").replaceAll("\\", "/"));
+        script.importSharedType("ResponseBuilderFactory");
         const text = `ResponseBuilderFactory<${this.buildResponseObjectType(script)}>`;
         if (text.includes("HttpStatusCode")) {
-            script.importExternalType("HttpStatusCode", nodePath.join(basePath, "types.d.ts").replaceAll("\\", "/"));
+            script.importSharedType("HttpStatusCode");
         }
         return text;
     }

package/dist/typescript-generator/schema-type-coder.js

@@ -73,6 +73,7 @@ export class SchemaTypeCoder extends Coder {
         return `components/${this.requirement.data.$ref.split("/").at(-1)}.ts`;
     }
     write(script) {
+        // script.comments = READ_ONLY_COMMENTS;
         if (this.requirement.isReference) {
             return script.importType(this);
         }

package/dist/typescript-generator/script.js

@@ -5,6 +5,7 @@ const debug = createDebugger("counterfact:typescript-generator:script");
 export class Script {
     constructor(repository, path) {
         this.repository = repository;
+        this.comments = [];
         this.exports = new Map();
         this.imports = new Map();
         this.externalImport = new Map();
@@ -12,6 +13,13 @@ export class Script {
         this.typeCache = new Map();
         this.path = path;
     }
+    get relativePathToBase() {
+        return this.path
+            .split("/")
+            .slice(0, -1)
+            .map(() => "..")
+            .join("/");
+    }
     firstUniqueName(coder) {
         for (const name of coder.names()) {
             if (!this.imports.has(name) && !this.exports.has(name)) {
@@ -96,6 +104,11 @@ export class Script {
     importExternalType(name, modulePath) {
         return this.importExternal(name, modulePath, true);
     }
+    importSharedType(name) {
+        return this.importExternal(name, nodePath
+            .join(this.relativePathToBase, "types.d.ts")
+            .replaceAll("\\", "/"), true);
+    }
     exportType(coder) {
         return this.export(coder, true);
     }
@@ -131,6 +144,8 @@ export class Script {
     }
     contents() {
         return prettier.format([
+            this.comments.map((comment) => `// ${comment}`).join("\n"),
+            this.comments.length > 0 ? "\n\n" : "",
             this.externalImportStatements().join("\n"),
             this.importStatements().join("\n"),
             "\n\n",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "0.37.1",
+  "version": "0.38.0",
   "description": "a library for building a fake REST API for testing",
   "type": "module",
   "main": "./src/server/counterfact.js",
@@ -47,7 +47,7 @@
     "@stryker-mutator/core": "8.2.6",
     "@stryker-mutator/jest-runner": "8.2.6",
     "@stryker-mutator/typescript-checker": "8.2.6",
-    "@swc/core": "1.4.4",
+    "@swc/core": "1.4.8",
     "@swc/jest": "0.2.36",
     "@testing-library/dom": "9.3.4",
     "@types/jest": "29.5.12",
@@ -92,13 +92,13 @@
     "json-schema-faker": "0.5.6",
     "json-schema-ref-parser": "9.0.9",
     "jsonwebtoken": "9.0.2",
-    "koa": "2.15.0",
+    "koa": "2.15.1",
     "koa-bodyparser": "4.4.1",
     "koa-proxy": "1.0.0-alpha.3",
     "koa2-swagger-ui": "5.10.0",
     "node-fetch": "3.3.2",
-    "open": "10.0.4",
+    "open": "10.1.0",
     "prettier": "3.2.5",
-    "typescript": "5.3.3"
+    "typescript": "5.4.2"
   }
 }