20967508103

Committed 13 Jan 2026 06:11PM UTC coverage: 84.26%. Remained the same

Build # 20967508103

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1470 from pmcelhaney/fix-typescript-errors

fix typescript errors

Run Details

1165 of 1297 branches covered (89.82%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

3562 of 4313 relevant lines covered (82.59%)

60.18 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 readonly string[]> = {
  [P in keyof T as P extends `${string}${K[number]}${string}`
    ? 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 readonly string[],
  Yes,
  No,
> = Keys extends [
  infer FirstKey extends string,
  ...infer RestKeys extends string[],
]
  ? keyof SomeObject extends FirstKey
    ? Yes
    : IfHasKey<SomeObject, RestKeys, Yes, 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;
}

export 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;
  };
  type?: "string" | "number" | "integer" | "boolean";
}

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;
  headers: { [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,
  WideResponseBuilder,
  OmitAll,
  IfHasKey,
};

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

pmcelhaney / counterfact / 20967508103

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