10645385797

Committed 31 Aug 2024 12:51PM UTC coverage: 82.599%. Remained the same

Build # 10645385797

Build Type

push

github

Committed by

web-flow

Commit Message

chore(deps): update dependency @swc/core to v1.7.21

Run Details

1001 of 1114 branches covered (89.86%)

Branch coverage included in aggregate %.

3233 of 4012 relevant lines covered (80.58%)

42.37 hits per line

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

0.0

/src/server/types.ts

interface OpenApiHeader {
  schema: unknown;
}

interface OpenApiContent {
  schema: unknown;
}

interface Example {
  description: string;
  summary: string;
  value: unknown;
}

const counterfactResponse = Symbol("Counterfact Response");

const counterfactResponseObject = {
  [counterfactResponse]: counterfactResponse,
};

type COUNTERFACT_RESPONSE = typeof counterfactResponseObject;

type MediaType = `${string}/${string}`;

type OmitAll<T, K extends (keyof T)[]> = {
  [P in keyof T as P extends K[number] ? never : P]: T[P];
};

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 };
  requiredHeaders: string;
}

interface OpenApiResponses {
  [key: string]: OpenApiResponse;
}

type IfHasKey<SomeObject, Keys extends (keyof any)[], Yes, No> = Keys extends [
  infer FirstKey,
  ...infer RestKeys,
]
  ? FirstKey extends keyof SomeObject
    ? Yes
    : RestKeys extends (keyof any)[]
      ? IfHasKey<SomeObject, RestKeys, Yes, No>
      : No
  : No;

type SchemasOf<T extends { [key: string]: { schema: any } }> = {
  [K in keyof T]: T[K]["schema"];
}[keyof T];

type MaybeShortcut<
  ContentTypes extends MediaType[],
  Response extends OpenApiResponse,
> = IfHasKey<
  Response["content"],
  ContentTypes,
  (body: SchemasOf<Response["content"]>) => GenericResponseBuilder<{
    content: NeverIfEmpty<OmitAll<Response["content"], ContentTypes>>;
    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"],
) => GenericResponseBuilder<{
  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"],
) => GenericResponseBuilder<{
  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"],
>() => COUNTERFACT_RESPONSE;

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;
  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",
      "text/json",
      "text/x-json",
      "application/xml",
      "text/xml",
    ],
    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,
> =
  object extends OmitValueWhenNever<Response>
    ? COUNTERFACT_RESPONSE
    : keyof OmitValueWhenNever<Response> extends "headers"
      ? {
          ALL_REMAINING_HEADERS_ARE_OPTIONAL: COUNTERFACT_RESPONSE;
          header: HeaderFunction<Response>;
        }
      : GenericResponseBuilderInner<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: { [key: string]: unknown };
        };
      };
      examples?: { [key: string]: unknown };
      schema?: { [key: string]: unknown };
    };
  };
}

interface 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;
}

interface WideOperationArgument {
  body: unknown;
  context: unknown;
  header: { [key: string]: string };
  path: { [key: string]: string };
  proxy: (url: string) => { proxyUrl: string };
  query: { [key: string]: string };
  response: { [key: number]: WideResponseBuilder };
}

export type { COUNTERFACT_RESPONSE };

export type {
  HttpStatusCode,
  MediaType,
  OmitValueWhenNever,
  OpenApiOperation,
  OpenApiParameters,
  OpenApiResponse,
  ResponseBuilder,
  ResponseBuilderFactory,
  WideOperationArgument,
};

1	interface OpenApiHeader {	×
2	schema: unknown;	×
3	}	×
4		×
5	interface OpenApiContent {	×
6	schema: unknown;	×
7	}	×
8		×
9	interface Example {	×
10	description: string;	×
11	summary: string;	×
12	value: unknown;	×
13	}	×
14		×
15	const counterfactResponse = Symbol("Counterfact Response");	×
16		×
17	const counterfactResponseObject = {	×
18	[counterfactResponse]: counterfactResponse,	×
19	};	×
20		×
21	type COUNTERFACT_RESPONSE = typeof counterfactResponseObject;	×
22		×
23	type MediaType = `${string}/${string}`;	×
24		×
25	type OmitAll<T, K extends (keyof T)[]> = {	×
26	[P in keyof T as P extends K[number] ? never : P]: T[P];	×
27	};	×
28		×
29	type OmitValueWhenNever<Base> = Pick<	×
30	Base,	×
31	{	×
32	[Key in keyof Base]: [Base[Key]] extends [never] ? never : Key;	×
33	}[keyof Base]	×
34	>;	×
35		×
36	interface OpenApiResponse {	×
37	content: { [key: MediaType]: OpenApiContent };	×
38	headers: { [key: string]: OpenApiHeader };	×
39	requiredHeaders: string;	×
40	}	×
41		×
42	interface OpenApiResponses {	×
43	[key: string]: OpenApiResponse;	×
44	}	×
45		×
46	type IfHasKey<SomeObject, Keys extends (keyof any)[], Yes, No> = Keys extends [	×
47	infer FirstKey,	×
48	...infer RestKeys,	×
49	]	×
50	? FirstKey extends keyof SomeObject	×
51	? Yes	×
52	: RestKeys extends (keyof any)[]	×
53	? IfHasKey<SomeObject, RestKeys, Yes, No>	×
54	: No	×
55	: No;	×
56		×
57	type SchemasOf<T extends { [key: string]: { schema: any } }> = {	×
58	[K in keyof T]: T[K]["schema"];	×
59	}[keyof T];	×
60		×
61	type MaybeShortcut<	×
62	ContentTypes extends MediaType[],	×
63	Response extends OpenApiResponse,	×
64	> = IfHasKey<	×
65	Response["content"],	×
66	ContentTypes,	×
67	(body: SchemasOf<Response["content"]>) => GenericResponseBuilder<{	×
68	content: NeverIfEmpty<OmitAll<Response["content"], ContentTypes>>;	×
69	headers: Response["headers"];	×
70	requiredHeaders: Response["requiredHeaders"];	×
71	}>,	×
72	never	×
73	>;	×
74		×
75	type NeverIfEmpty<Record> = {} extends Record ? never : Record;	×
76		×
77	type MatchFunction<Response extends OpenApiResponse> = <	×
78	ContentType extends MediaType & keyof Response["content"],	×
79	>(	×
80	contentType: ContentType,	×
81	body: Response["content"][ContentType]["schema"],	×
82	) => GenericResponseBuilder<{	×
83	content: NeverIfEmpty<Omit<Response["content"], ContentType>>;	×
84	headers: Response["headers"];	×
85	requiredHeaders: Response["requiredHeaders"];	×
86	}>;	×
87		×
88	type HeaderFunction<Response extends OpenApiResponse> = <	×
89	Header extends string & keyof Response["headers"],	×
90	>(	×
91	header: Header,	×
92	value: Response["headers"][Header]["schema"],	×
93	) => GenericResponseBuilder<{	×
94	content: NeverIfEmpty<Response["content"]>;	×
95	headers: NeverIfEmpty<Omit<Response["headers"], Header>>;	×
96	requiredHeaders: Exclude<Response["requiredHeaders"], Header>;	×
97	}>;	×
98		×
99	type RandomFunction<Response extends OpenApiResponse> = <	×
100	Header extends string & keyof Response["headers"],	×
101	>() => COUNTERFACT_RESPONSE;	×
102		×
103	interface ResponseBuilder {	×
104	[status: number \| `${number} ${string}`]: ResponseBuilder;	×
105	content?: { body: unknown; type: string }[];	×
106	header: (name: string, value: string) => ResponseBuilder;	×
107	headers: { [name: string]: string };	×
108	html: (body: unknown) => ResponseBuilder;	×
109	json: (body: unknown) => ResponseBuilder;	×
110	match: (contentType: string, body: unknown) => ResponseBuilder;	×
111	random: () => ResponseBuilder;	×
112	randomLegacy: () => ResponseBuilder;	×
113	status?: number;	×
114	text: (body: unknown) => ResponseBuilder;	×
115	xml: (body: unknown) => ResponseBuilder;	×
116	}	×
117		×
118	type GenericResponseBuilderInner<	×
119	Response extends OpenApiResponse = OpenApiResponse,	×
120	> = OmitValueWhenNever<{	×
121	header: [keyof Response["headers"]] extends [never]	×
122	? never	×
123	: HeaderFunction<Response>;	×
124	html: MaybeShortcut<["text/html"], Response>;	×
125	json: MaybeShortcut<	×
126	[	×
127	"application/json",	×
128	"text/json",	×
129	"text/x-json",	×
130	"application/xml",	×
131	"text/xml",	×
132	],	×
133	Response	×
134	>;	×
135	match: [keyof Response["content"]] extends [never]	×
136	? never	×
137	: MatchFunction<Response>;	×
138	random: [keyof Response["content"]] extends [never]	×
139	? never	×
140	: RandomFunction<Response>;	×
141	text: MaybeShortcut<["text/plain"], Response>;	×
142	xml: MaybeShortcut<["application/xml", "text/xml"], Response>;	×
143	}>;	×
144		×
145	type GenericResponseBuilder<	×
146	Response extends OpenApiResponse = OpenApiResponse,	×
147	> =	×
148	object extends OmitValueWhenNever<Response>	×
149	? COUNTERFACT_RESPONSE	×
150	: keyof OmitValueWhenNever<Response> extends "headers"	×
151	? {	×
152	ALL_REMAINING_HEADERS_ARE_OPTIONAL: COUNTERFACT_RESPONSE;	×
153	header: HeaderFunction<Response>;	×
154	}	×
155	: GenericResponseBuilderInner<Response>;	×
156		×
157	type ResponseBuilderFactory<	×
158	Responses extends OpenApiResponses = OpenApiResponses,	×
159	> = {	×
160	[StatusCode in keyof Responses]: GenericResponseBuilder<	×
161	Responses[StatusCode]	×
162	>;	×
163	} & { [key: string]: GenericResponseBuilder<Responses["default"]> };	×
164		×
165	type HttpStatusCode =	×
166	\| 100	×
167	\| 101	×
168	\| 102	×
169	\| 200	×
170	\| 201	×
171	\| 202	×
172	\| 203	×
173	\| 204	×
174	\| 205	×
175	\| 206	×
176	\| 207	×
177	\| 226	×
178	\| 300	×
179	\| 301	×
180	\| 302	×
181	\| 303	×
182	\| 304	×
183	\| 305	×
184	\| 307	×
185	\| 308	×
186	\| 400	×
187	\| 401	×
188	\| 402	×
189	\| 403	×
190	\| 404	×
191	\| 405	×
192	\| 406	×
193	\| 407	×
194	\| 408	×
195	\| 409	×
196	\| 410	×
197	\| 411	×
198	\| 412	×
199	\| 413	×
200	\| 414	×
201	\| 415	×
202	\| 416	×
203	\| 417	×
204	\| 418	×
205	\| 422	×
206	\| 423	×
207	\| 424	×
208	\| 426	×
209	\| 428	×
210	\| 429	×
211	\| 431	×
212	\| 451	×
213	\| 500	×
214	\| 501	×
215	\| 502	×
216	\| 503	×
217	\| 504	×
218	\| 505	×
219	\| 506	×
220	\| 507	×
221	\| 511;	×
222		×
223	interface OpenApiParameters {	×
224	in: "body" \| "cookie" \| "formData" \| "header" \| "path" \| "query";	×
225	name: string;	×
226	schema?: {	×
227	type: string;	×
228	};	×
229	}	×
230		×
231	interface OpenApiOperation {	×
232	parameters?: OpenApiParameters[];	×
233	produces?: string[];	×
234	responses: {	×
235	[status: string]: {	×
236	content?: {	×
237	[type: number \| string]: {	×
238	examples?: { [key: string]: Example };	×
239	schema: { [key: string]: unknown };	×
240	};	×
241	};	×
242	examples?: { [key: string]: unknown };	×
243	schema?: { [key: string]: unknown };	×
244	};	×
245	};	×
246	}	×
247		×
248	interface WideResponseBuilder {	×
249	header: (body: unknown) => WideResponseBuilder;	×
250	html: (body: unknown) => WideResponseBuilder;	×
251	json: (body: unknown) => WideResponseBuilder;	×
252	match: (contentType: string, body: unknown) => WideResponseBuilder;	×
253	random: () => WideResponseBuilder;	×
254	text: (body: unknown) => WideResponseBuilder;	×
255	xml: (body: unknown) => WideResponseBuilder;	×
256	}	×
257		×
258	interface WideOperationArgument {	×
259	body: unknown;	×
260	context: unknown;	×
261	header: { [key: string]: string };	×
262	path: { [key: string]: string };	×
263	proxy: (url: string) => { proxyUrl: string };	×
264	query: { [key: string]: string };	×
265	response: { [key: number]: WideResponseBuilder };	×
266	}	×
267		×
268	export type { COUNTERFACT_RESPONSE };	×
269		×
270	export type {	×
271	HttpStatusCode,	×
272	MediaType,	×
273	OmitValueWhenNever,	×
274	OpenApiOperation,	×
275	OpenApiParameters,	×
276	OpenApiResponse,	×
277	ResponseBuilder,	×
278	ResponseBuilderFactory,	×
279	WideOperationArgument,	×
280	};	×

pmcelhaney / counterfact / 10645385797

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