counterfact 0.37.2 → 0.38.1

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

@@ -24,6 +24,7 @@ type OmitValueWhenNever<Base> = Pick<
 interface OpenApiResponse {
   content: { [key: MediaType]: OpenApiContent };
   headers: { [key: string]: OpenApiHeader };
+  requiredHeaders: string
 }
 
 interface OpenApiResponses {
@@ -41,39 +42,40 @@ 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"];
+    requiredHeaders: Response["requiredHeaders"];
   }>,
   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"];
+  requiredHeaders: Response["requiredHeaders"];
 }>;
 
 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>>;
+  requiredHeaders: Exclude<Response["requiredHeaders"], 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 +92,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" :  keyof OmitValueWhenNever<Response> extends "headers" ? { header: HeaderFunction<Response>, ALL_REMAINING_HEADERS_ARE_OPTIONAL: "COUNTERFACT_RESPONSE" } : GenericResponseBuilderInner<Response>;
 
 type ResponseBuilderFactory<
   Responses extends OpenApiResponses = OpenApiResponses,
@@ -199,6 +205,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 +233,8 @@ export type {
   OpenApiResponse,
   ResponseBuilder,
   ResponseBuilderFactory,
+  WideOperationArgument,
+  OmitValueWhenNever
 };
+
+

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

@@ -53,28 +53,24 @@ export class OperationTypeCoder extends Coder {
     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" | { ALL_REMAINING_HEADERS_ARE_OPTIONAL: "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/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);

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";
@@ -40,7 +39,7 @@ export class ResponseTypeCoder extends Coder {
         if (response.has("content") || response.has("schema")) {
             return printObject(this.buildContentObjectType(script, response));
         }
-        return "{}";
+        return "never";
     }
     buildHeaders(script, response) {
         return response
@@ -52,29 +51,32 @@ export class ResponseTypeCoder extends Coder {
     }
     printHeaders(script, response) {
         if (!response.has("headers")) {
-            return "{}";
+            return "never";
         }
         return printObject(this.buildHeaders(script, response));
     }
+    printRequiredHeaders(response) {
+        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(" | ");
+    }
     buildResponseObjectType(script) {
         return printObjectWithoutQuotes(this.requirement.map((response, responseCode) => [
             this.normalizeStatusCode(responseCode),
             `{
           headers: ${this.printHeaders(script, response)};
+          requiredHeaders: ${this.printRequiredHeaders(response)};
           content: ${this.printContentObjectType(script, response)};
         }`,
         ]));
     }
     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/script.js

@@ -13,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)) {
@@ -97,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);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "counterfact",
-  "version": "0.37.2",
+  "version": "0.38.1",
   "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.6",
+    "@swc/core": "1.4.8",
     "@swc/jest": "0.2.36",
     "@testing-library/dom": "9.3.4",
     "@types/jest": "29.5.12",
@@ -92,7 +92,7 @@
     "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",