8675825650

Committed 13 Apr 2024 07:37PM UTC coverage: 82.98% (-3.5%) from 86.517%

Build # 8675825650

Build Type

Pull #852

github

Committed by

pmcelhaney

Commit Message

response-type-coder should import TypeCoder, not Coder

Pull Request Pull Request #852: Support OpenAPI reusable responses in global components object (handle $ref properly everywhere)

Run Details

893 of 995 branches covered (89.75%)

Branch coverage included in aggregate %.

120 of 290 new or added lines in 9 files covered. (41.38%)

21 existing lines in 1 file now uncovered.

2905 of 3582 relevant lines covered (81.1%)

40.98 hits per line

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

72.11

/src/typescript-generator/responses-type-coder.js

import { printObject, printObjectWithoutQuotes } from "./printers.js";
import { ResponseTypeCoder } from "./response-type-coder.js";
import { SchemaTypeCoder } from "./schema-type-coder.js";
import { TypeCoder } from "./type-coder.js";

export class ResponsesTypeCoder extends TypeCoder {
  constructor(requirement, openApi2MediaTypes = []) {
    super(requirement);

    this.openApi2MediaTypes = openApi2MediaTypes;
  }

  typeForDefaultStatusCode(listedStatusCodes) {
    const definedStatusCodes = listedStatusCodes.filter(
      (key) => key !== "default",
    );

    if (definedStatusCodes.length === 0) {
      return "[statusCode in HttpStatusCode]";
    }

    return `[statusCode in Exclude<HttpStatusCode, ${definedStatusCodes.join(
      " | ",
    )}>]`;
  }

  normalizeStatusCode(statusCode) {
    if (statusCode === "default") {
      return this.typeForDefaultStatusCode(Object.keys(this.requirement.data));
    }

    return statusCode;
  }

  buildContentObjectType(script, response) {
    if (response.has("content")) {
      return response.get("content").map((content, mediaType) => [
        mediaType,
        `{ 
            schema:  ${new SchemaTypeCoder(content.get("schema")).write(script)}
         }`,
      ]);
    }

    return this.openApi2MediaTypes.map((mediaType) => [
      mediaType,
      `{
            schema: ${new SchemaTypeCoder(response.get("schema")).write(script)}
         }`,
    ]);
  }

  printContentObjectType(script, response) {
    if (response.has("content") || response.has("schema")) {
      return printObject(this.buildContentObjectType(script, response));
    }

    return "never";
  }

  buildHeaders(script, response) {
    return response
      .get("headers")
      .map((value, name) => [
        name,
        `{ schema: ${new SchemaTypeCoder(value.get("schema") ?? value).write(
          script,
        )}}`,
      ]);
  }

  printHeaders(script, response) {
    if (!response.has("headers")) {
      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),
        new ResponseTypeCoder(response, this.openApi2MediaTypes).write(script),
      ]),
    );
  }

  writeCode(script) {
    script.importSharedType("ResponseBuilderFactory");

    const text = `ResponseBuilderFactory<${this.buildResponseObjectType(
      script,
    )}>`;

    if (text.includes("HttpStatusCode")) {
      script.importSharedType("HttpStatusCode");
    }

    return text;
  }
}

1	import { printObject, printObjectWithoutQuotes } from "./printers.js";	2✔
2	import { ResponseTypeCoder } from "./response-type-coder.js";	2✔
3	import { SchemaTypeCoder } from "./schema-type-coder.js";	2✔
4	import { TypeCoder } from "./type-coder.js";	2✔
5		2✔
6	export class ResponsesTypeCoder extends TypeCoder {	2✔
7	constructor(requirement, openApi2MediaTypes = []) {	2✔
8	super(requirement);	64✔
9		64✔
10	this.openApi2MediaTypes = openApi2MediaTypes;	64✔
11	}	64✔
12		2✔
13	typeForDefaultStatusCode(listedStatusCodes) {	2✔
14	const definedStatusCodes = listedStatusCodes.filter(	30✔
15	(key) => key !== "default",	30✔
16	);	30✔
17		30✔
18	if (definedStatusCodes.length === 0) {	30✔
19	return "[statusCode in HttpStatusCode]";	20✔
20	}	20✔
21		10✔
22	return `[statusCode in Exclude<HttpStatusCode, ${definedStatusCodes.join(	10✔
23	" \| ",	10✔
24	)}>]`;	10✔
25	}	10✔
26		2✔
27	normalizeStatusCode(statusCode) {	2✔
28	if (statusCode === "default") {	108✔
29	return this.typeForDefaultStatusCode(Object.keys(this.requirement.data));	30✔
30	}	30✔
31		78✔
32	return statusCode;	78✔
33	}	78✔
34		2✔
35	buildContentObjectType(script, response) {	2✔
NEW 36	if (response.has("content")) {	×
NEW 37	return response.get("content").map((content, mediaType) => [	×
NEW 38	mediaType,	×
NEW 39	`{	×
NEW 40	schema: ${new SchemaTypeCoder(content.get("schema")).write(script)}	×
NEW 41	}`,	×
NEW 42	]);	×
NEW 43	}	×
NEW 44		×
NEW 45	return this.openApi2MediaTypes.map((mediaType) => [	×
NEW 46	mediaType,	×
NEW 47	`{	×
NEW 48	schema: ${new SchemaTypeCoder(response.get("schema")).write(script)}	×
NEW 49	}`,	×
NEW 50	]);	×
NEW 51	}	×
52		2✔
53	printContentObjectType(script, response) {	2✔
NEW 54	if (response.has("content") \|\| response.has("schema")) {	×
NEW 55	return printObject(this.buildContentObjectType(script, response));	×
NEW 56	}	×
NEW 57		×
NEW 58	return "never";	×
NEW 59	}	×
60		2✔
61	buildHeaders(script, response) {	2✔
NEW 62	return response	×
NEW 63	.get("headers")	×
NEW 64	.map((value, name) => [	×
NEW 65	name,	×
NEW 66	`{ schema: ${new SchemaTypeCoder(value.get("schema") ?? value).write(	×
NEW 67	script,	×
NEW 68	)}}`,	×
NEW 69	]);	×
NEW 70	}	×
71		2✔
72	printHeaders(script, response) {	2✔
NEW 73	if (!response.has("headers")) {	×
NEW 74	return "never";	×
NEW 75	}	×
NEW 76		×
NEW 77	return printObject(this.buildHeaders(script, response));	×
NEW 78	}	×
79		2✔
80	printRequiredHeaders(response) {	2✔
81	const requiredHeaders = (response.get("headers") ?? [])	2!
82	.map((value, name) => ({ name, required: value.data.required }))	2✔
83	.filter(({ required }) => required)	2✔
84	.map(({ name }) => `"${name}"`);	2✔
85		2✔
86	return requiredHeaders.length === 0 ? "never" : requiredHeaders.join(" \| ");	2!
87	}	2✔
88		2✔
89	buildResponseObjectType(script) {	2✔
90	return printObjectWithoutQuotes(	56✔
91	this.requirement.map((response, responseCode) => [	56✔
92	this.normalizeStatusCode(responseCode),	102✔
93	new ResponseTypeCoder(response, this.openApi2MediaTypes).write(script),	102✔
94	]),	102✔
95	);	56✔
96	}	56✔
97		2✔
98	writeCode(script) {	2✔
99	script.importSharedType("ResponseBuilderFactory");	56✔
100		56✔
101	const text = `ResponseBuilderFactory<${this.buildResponseObjectType(	56✔
102	script,	56✔
103	)}>`;	56✔
104		56✔
105	if (text.includes("HttpStatusCode")) {	56✔
106	script.importSharedType("HttpStatusCode");	26✔
107	}	26✔
108		56✔
109	return text;	56✔
110	}	56✔
111	}	2✔

pmcelhaney / counterfact / 8675825650

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