8272577639

Committed 13 Mar 2024 10:46PM UTC coverage: 86.298% (-0.02%) from 86.316%

Build # 8272577639

Build Type

Pull #796

github

Committed by

pmcelhaney

Commit Message

link generated code FAQ to the usage page

Pull Request Pull Request #796: comments at top of generated files

Run Details

881 of 971 branches covered (90.73%)

Branch coverage included in aggregate %.

15 of 15 new or added lines in 4 files covered. (100.0%)

8 existing lines in 1 file now uncovered.

2791 of 3284 relevant lines covered (84.99%)

40.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.96

/src/server/dispatcher.ts

/* eslint-disable import/newline-after-import */

import { mediaTypes } from "@hapi/accept";
import createDebugger from "debug";
// eslint-disable-next-line @typescript-eslint/no-shadow
import fetch, { Headers } from "node-fetch";

import type { ContextRegistry } from "./context-registry.js";
import type {
  CounterfactResponseObject,
  HttpMethods,
  NormalizedCounterfactResponseObject,
  Registry,
} from "./registry.js";
import { createResponseBuilder } from "./response-builder.js";
import { Tools } from "./tools.js";
import type { OpenApiOperation, OpenApiParameters } from "./types.d.ts";

const debug = createDebugger("counterfact:server:dispatcher");

interface ParameterTypes {
  body: {
    [key: string]: string;
  };
  cookie: {
    [key: string]: string;
  };
  formData: {
    [key: string]: string;
  };
  header: {
    [key: string]: string;
  };
  path: {
    [key: string]: string;
  };
  query: {
    [key: string]: string;
  };
}

export interface OpenApiDocument {
  paths: {
    [key: string]: {
      [key in Lowercase<HttpMethods>]?: OpenApiOperation;
    };
  };
  produces?: string[];
}

export class Dispatcher {
  public registry: Registry;

  public contextRegistry: ContextRegistry;

  public openApiDocument: OpenApiDocument | undefined;

  public fetch: typeof fetch;

  public constructor(
    registry: Registry,
    contextRegistry: ContextRegistry,
    openApiDocument?: OpenApiDocument,
  ) {
    this.registry = registry;
    this.contextRegistry = contextRegistry;
    this.openApiDocument = openApiDocument;
    this.fetch = fetch;
  }

  private parameterTypes(
    parameters: OpenApiParameters[] | undefined,
  ): ParameterTypes {
    const types: ParameterTypes = {
      body: {},
      cookie: {},
      formData: {},
      header: {},
      path: {},
      query: {},
    };

    if (!parameters) {
      return types;
    }

    for (const parameter of parameters) {
      if (parameter.schema !== undefined) {
        types[parameter.in][parameter.name] =
          parameter.schema.type === "integer"
            ? "number"
            : parameter.schema.type;
      }
    }

    return types;
  }

  public operationForPathAndMethod(
    path: string,
    method: HttpMethods,
  ): OpenApiOperation | undefined {
    const operation: OpenApiOperation | undefined =
      this.openApiDocument?.paths[path]?.[
        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
        method.toLowerCase() as Lowercase<HttpMethods>
      ];

    if (operation === undefined) {
      return undefined;
    }

    if (this.openApiDocument?.produces) {
      return {
        produces: this.openApiDocument.produces,
        ...operation,
      };
    }

    return operation;
  }

  private normalizeResponse(
    response: CounterfactResponseObject,
    acceptHeader: string,
  ): NormalizedCounterfactResponseObject {
    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) {
        return {
          body: `Not Acceptable: could not produce a response matching any of the following content types: ${acceptHeader}`,
          contentType: "text/plain",
          status: 406,
        };
      }

      const normalizedResponse = {
        ...response,
        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
        body: content.body as string | undefined,
        contentType: content.type,
      };

      delete normalizedResponse.content;

      return normalizedResponse;
    }

    return {
      ...response,

      contentType:
        response.headers?.["content-type"]?.toString() ?? "unknown/unknown",
    };
  }

  public selectContent(
    acceptHeader: string,
    content: { body: unknown; type: string }[],
  ) {
    const preferredMediaTypes = mediaTypes(acceptHeader);

    for (const mediaType of preferredMediaTypes) {
      const contentItem = content.find((item) =>
        this.isMediaType(item.type, mediaType),
      );

      if (contentItem) {
        return contentItem;
      }
    }

    return undefined;
  }

  private isMediaType(type: string, pattern: string) {
    if (pattern === "*/*") {
      return true;
    }

    const [baseType, subType] = type.split("/");

    const [patternType, patternSubType] = pattern.split("/");

    if (baseType === patternType) {
      return subType === patternSubType || patternSubType === "*";
    }

    if (subType === patternSubType) {
      return baseType === patternType || patternType === "*";
    }

    return false;
  }

  // eslint-disable-next-line sonarjs/cognitive-complexity
  public async request({
    body,
    headers = {},
    method,
    path,
    query,
    req,
  }: {
    body: unknown;
    headers: {
      [key: string]: string;
    };
    method: HttpMethods;
    path: string;
    query: {
      [key: string]: string;
    };
    req: {
      path?: string;
    };
  }): Promise<NormalizedCounterfactResponseObject> {
    debug(`request: ${method} ${path}`);

    const { matchedPath } = this.registry.handler(path);
    const operation = this.operationForPathAndMethod(matchedPath, method);

    const response = await this.registry.endpoint(
      method,
      path,
      this.parameterTypes(operation?.parameters),
    )({
      body,
      context: this.contextRegistry.find(matchedPath),
      headers,

      proxy: async (url: string) => {
        if (body !== undefined && headers.contentType !== "application/json") {
          throw new Error(
            `$.proxy() is currently limited to application/json requests. You tried to proxy to ${url} with a Content-Type of ${
              headers.contentType ?? "[unknown]"
            }. Please open an issue at https://github.com/pmcelhaney/counterfact/issues and prod me to fix this limitation.`,
          );
        }

        const fetchResponse = await this.fetch(`${url}${req.path ?? ""}`, {
          body: body === undefined ? undefined : JSON.stringify(body),
          headers: new Headers(headers),
          method,
        });

        const responseHeaders = Object.fromEntries(
          fetchResponse.headers.entries(),
        );

        return {
          body: await fetchResponse.text(),
          contentType: responseHeaders["content-type"] ?? "unknown/unknown",
          headers: responseHeaders,
          status: fetchResponse.status,
        };
      },

      query,

      // @ts-expect-error - Might be pushing the limits of what TypeScript can do here
      response: createResponseBuilder(operation ?? { responses: {} }),

      tools: new Tools({ headers }),
    });

    if (response === undefined) {
      return {
        body: `The ${method} function did not return anything. Did you forget a return statement?`,
        status: 500,
      };
    }

    const normalizedResponse = this.normalizeResponse(
      response,
      headers.accept ?? "*/*",
    );

    if (
      normalizedResponse.body !== undefined &&
      !mediaTypes(headers.accept ?? "*/*").some((type) =>
        this.isMediaType(normalizedResponse.contentType ?? "", type),
      )
    ) {
      return {
        body: JSON.stringify(mediaTypes(headers.accept ?? "*/*")),
        status: 406,
      };
    }

    return normalizedResponse;
  }
}

1	/* eslint-disable import/newline-after-import */	2✔
2		2✔
3	import { mediaTypes } from "@hapi/accept";	2✔
4	import createDebugger from "debug";	2✔
5	// eslint-disable-next-line @typescript-eslint/no-shadow	2✔
6	import fetch, { Headers } from "node-fetch";	2✔
7		2✔
8	import type { ContextRegistry } from "./context-registry.js";	2✔
9	import type {	2✔
10	CounterfactResponseObject,	2✔
11	HttpMethods,	2✔
12	NormalizedCounterfactResponseObject,	2✔
13	Registry,	2✔
14	} from "./registry.js";	2✔
15	import { createResponseBuilder } from "./response-builder.js";	2✔
16	import { Tools } from "./tools.js";	2✔
17	import type { OpenApiOperation, OpenApiParameters } from "./types.d.ts";	2✔
18		2✔
19	const debug = createDebugger("counterfact:server:dispatcher");	2✔
20		2✔
21	interface ParameterTypes {	2✔
22	body: {	2✔
23	[key: string]: string;	2✔
24	};	2✔
25	cookie: {	2✔
26	[key: string]: string;	2✔
27	};	2✔
28	formData: {	2✔
29	[key: string]: string;	2✔
30	};	2✔
31	header: {	2✔
32	[key: string]: string;	2✔
33	};	2✔
34	path: {	2✔
35	[key: string]: string;	2✔
36	};	2✔
37	query: {	2✔
38	[key: string]: string;	2✔
39	};	2✔
40	}	2✔
41		2✔
42	export interface OpenApiDocument {	2✔
43	paths: {	2✔
44	[key: string]: {	2✔
45	[key in Lowercase<HttpMethods>]?: OpenApiOperation;	2✔
46	};	2✔
47	};	2✔
48	produces?: string[];	2✔
49	}	2✔
50		2✔
51	export class Dispatcher {	2✔
52	public registry: Registry;	66✔
53		66✔
54	public contextRegistry: ContextRegistry;	66✔
55		66✔
56	public openApiDocument: OpenApiDocument \| undefined;	66✔
57		66✔
58	public fetch: typeof fetch;	66✔
59		66✔
60	public constructor(	66✔
61	registry: Registry,	66✔
62	contextRegistry: ContextRegistry,	66✔
63	openApiDocument?: OpenApiDocument,	66✔
64	) {	66✔
65	this.registry = registry;	66✔
66	this.contextRegistry = contextRegistry;	66✔
67	this.openApiDocument = openApiDocument;	66✔
68	this.fetch = fetch;	66✔
69	}	66✔
70		66✔
71	private parameterTypes(	66✔
72	parameters: OpenApiParameters[] \| undefined,	54✔
73	): ParameterTypes {	54✔
74	const types: ParameterTypes = {	54✔
75	body: {},	54✔
76	cookie: {},	54✔
77	formData: {},	54✔
78	header: {},	54✔
79	path: {},	54✔
80	query: {},	54✔
81	};	54✔
82		54✔
83	if (!parameters) {	54✔
84	return types;	52✔
85	}	52✔
86		2✔
87	for (const parameter of parameters) {	40✔
88	if (parameter.schema !== undefined) {	12✔
89	types[parameter.in][parameter.name] =	12✔
90	parameter.schema.type === "integer"	12✔
91	? "number"	2✔
92	: parameter.schema.type;	12✔
93	}	12✔
94	}	12✔
95		2✔
96	return types;	2✔
97	}	2✔
98		66✔
99	public operationForPathAndMethod(	66✔
100	path: string,	56✔
101	method: HttpMethods,	56✔
102	): OpenApiOperation \| undefined {	56✔
103	const operation: OpenApiOperation \| undefined =	56✔
104	this.openApiDocument?.paths[path]?.[	56✔
105	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions	6✔
106	method.toLowerCase() as Lowercase<HttpMethods>	6✔
107	];	56✔
108		56✔
109	if (operation === undefined) {	56✔
110	return undefined;	50✔
111	}	50✔
112		6✔
113	if (this.openApiDocument?.produces) {	56✔
114	return {	2✔
115	produces: this.openApiDocument.produces,	2✔
116	...operation,	2✔
117	};	2✔
118	}	2✔
119		4✔
120	return operation;	4✔
121	}	4✔
122		66✔
123	private normalizeResponse(	66✔
124	response: CounterfactResponseObject,	52✔
125	acceptHeader: string,	52✔
126	): NormalizedCounterfactResponseObject {	52✔
127	if (typeof response === "string") {	52✔
128	return {	2✔
129	body: response,	2✔
130	contentType: "text/plain",	2✔
131	headers: {},	2✔
132	status: 200,	2✔
133	};	2✔
134	}	2✔
135		50✔
136	if (response.content !== undefined) {	52✔
137	const content = this.selectContent(acceptHeader, response.content);	8✔
138		8✔
139	if (content === undefined) {	8!
UNCOV 140	return {	×
141	body: `Not Acceptable: could not produce a response matching any of the following content types: ${acceptHeader}`,	×
142	contentType: "text/plain",	×
143	status: 406,	×
144	};	×
145	}	×
146		8✔
147	const normalizedResponse = {	8✔
148	...response,	8✔
149	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions	8✔
150	body: content.body as string \| undefined,	8✔
151	contentType: content.type,	8✔
152	};	8✔
153		8✔
154	delete normalizedResponse.content;	8✔
155		8✔
156	return normalizedResponse;	8✔
157	}	8✔
158		42✔
159	return {	42✔
160	...response,	42✔
161		42✔
162	contentType:	42✔
163	response.headers?.["content-type"]?.toString() ?? "unknown/unknown",	52✔
164	};	52✔
165	}	52✔
166		66✔
167	public selectContent(	66✔
168	acceptHeader: string,	20✔
169	content: { body: unknown; type: string }[],	20✔
170	) {	20✔
171	const preferredMediaTypes = mediaTypes(acceptHeader);	20✔
172		20✔
173	for (const mediaType of preferredMediaTypes) {	20✔
174	const contentItem = content.find((item) =>	20✔
175	this.isMediaType(item.type, mediaType),	32✔
176	);	20✔
177		20✔
178	if (contentItem) {	20✔
179	return contentItem;	20✔
180	}	20✔
181	}	20!
UNCOV 182		×
183	return undefined;	×
184	}	×
185		66✔
186	private isMediaType(type: string, pattern: string) {	66✔
187	if (pattern === "/") {	78✔
188	return true;	40✔
189	}	40✔
190		38✔
191	const [baseType, subType] = type.split("/");	38✔
192		38✔
193	const [patternType, patternSubType] = pattern.split("/");	38✔
194		38✔
195	if (baseType === patternType) {	66✔
196	return subType === patternSubType \|\| patternSubType === "*";	28✔
197	}	28✔
198		10✔
199	if (subType === patternSubType) {	66✔
200	return baseType === patternType \|\| patternType === "*";	4✔
201	}	4✔
202		6✔
203	return false;	6✔
204	}	6✔
205		66✔
206	// eslint-disable-next-line sonarjs/cognitive-complexity	66✔
207	public async request({	66✔
208	body,	54✔
209	headers = {},	54✔
210	method,	54✔
211	path,	54✔
212	query,	54✔
213	req,	54✔
214	}: {	54✔
215	body: unknown;	54✔
216	headers: {	54✔
217	[key: string]: string;	54✔
218	};	54✔
219	method: HttpMethods;	54✔
220	path: string;	54✔
221	query: {	54✔
222	[key: string]: string;	54✔
223	};	54✔
224	req: {	54✔
225	path?: string;	54✔
226	};	54✔
227	}): Promise<NormalizedCounterfactResponseObject> {	54✔
228	debug(`request: ${method} ${path}`);	54✔
229		54✔
230	const { matchedPath } = this.registry.handler(path);	54✔
231	const operation = this.operationForPathAndMethod(matchedPath, method);	54✔
232		54✔
233	const response = await this.registry.endpoint(	54✔
234	method,	54✔
235	path,	54✔
236	this.parameterTypes(operation?.parameters),	54✔
237	)({	54✔
238	body,	54✔
239	context: this.contextRegistry.find(matchedPath),	54✔
240	headers,	54✔
241		54✔
242	proxy: async (url: string) => {	54✔
243	if (body !== undefined && headers.contentType !== "application/json") {	2!
UNCOV 244	throw new Error(	×
UNCOV 245	`$.proxy() is currently limited to application/json requests. You tried to proxy to ${url} with a Content-Type of ${	×
UNCOV 246	headers.contentType ?? "[unknown]"	×
UNCOV 247	}. Please open an issue at https://github.com/pmcelhaney/counterfact/issues and prod me to fix this limitation.`,	×
UNCOV 248	);	×
UNCOV 249	}	×
250		2✔
251	const fetchResponse = await this.fetch(`${url}${req.path ?? ""}`, {	2!
252	body: body === undefined ? undefined : JSON.stringify(body),	2!
253	headers: new Headers(headers),	2✔
254	method,	2✔
255	});	2✔
256		2✔
257	const responseHeaders = Object.fromEntries(	2✔
258	fetchResponse.headers.entries(),	2✔
259	);	2✔
260		2✔
261	return {	2✔
262	body: await fetchResponse.text(),	2✔
263	contentType: responseHeaders["content-type"] ?? "unknown/unknown",	2!
264	headers: responseHeaders,	2✔
265	status: fetchResponse.status,	2✔
266	};	2✔
267	},	2✔
268		54✔
269	query,	54✔
270		54✔
271	// @ts-expect-error - Might be pushing the limits of what TypeScript can do here	54✔
272	response: createResponseBuilder(operation ?? { responses: {} }),	54✔
273		54✔
274	tools: new Tools({ headers }),	54✔
275	});	54✔
276		54✔
277	if (response === undefined) {	54✔
278	return {	2✔
279	body: `The ${method} function did not return anything. Did you forget a return statement?`,	2✔
280	status: 500,	2✔
281	};	2✔
282	}	2✔
283		52✔
284	const normalizedResponse = this.normalizeResponse(	52✔
285	response,	52✔
286	headers.accept ?? "/",	54✔
287	);	54✔
288		54✔
289	if (	54✔
290	normalizedResponse.body !== undefined &&	54✔
291	!mediaTypes(headers.accept ?? "/").some((type) =>	46✔
292	this.isMediaType(normalizedResponse.contentType ?? "", type),	46!
293	)	54✔
294	) {	54✔
295	return {	2✔
296	body: JSON.stringify(mediaTypes(headers.accept ?? "/")),	2!
297	status: 406,	2✔
298	};	2✔
299	}	2✔
300		50✔
301	return normalizedResponse;	50✔
302	}	50✔
303	}	66✔

pmcelhaney / counterfact / 8272577639

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous