swagger-typescript-api 13.0.3 → 13.0.5

package/src/configuration.js

@@ -1,34 +1,34 @@
 /* eslint-disable no-unused-vars */
-const { objectAssign } = require('./util/object-assign');
-const _ = require('lodash');
-const CONSTANTS = require('./constants');
-const { ComponentTypeNameResolver } = require('./component-type-name-resolver');
-const { cosmiconfigSync } = require('cosmiconfig');
-const ts = require('typescript');
+const { objectAssign } = require("./util/object-assign");
+const _ = require("lodash");
+const CONSTANTS = require("./constants");
+const { ComponentTypeNameResolver } = require("./component-type-name-resolver");
+const { cosmiconfigSync } = require("cosmiconfig");
+const ts = require("typescript");
 
 const TsKeyword = {
-  Number: 'number',
-  String: 'string',
-  Boolean: 'boolean',
-  Any: 'any',
-  Void: 'void',
-  Unknown: 'unknown',
-  Null: 'null',
-  Undefined: 'undefined',
-  Object: 'object',
-  File: 'File',
-  Date: 'Date',
-  Type: 'type',
-  Enum: 'enum',
-  Interface: 'interface',
-  Array: 'Array',
-  Record: 'Record',
-  Intersection: '&',
-  Union: '|',
+  Number: "number",
+  String: "string",
+  Boolean: "boolean",
+  Any: "any",
+  Void: "void",
+  Unknown: "unknown",
+  Null: "null",
+  Undefined: "undefined",
+  Object: "object",
+  File: "File",
+  Date: "Date",
+  Type: "type",
+  Enum: "enum",
+  Interface: "interface",
+  Array: "Array",
+  Record: "Record",
+  Intersection: "&",
+  Union: "|",
 };
 
 const TsCodeGenKeyword = {
-  UtilRequiredKeys: 'UtilRequiredKeys',
+  UtilRequiredKeys: "UtilRequiredKeys",
 };
 
 /**
@@ -37,7 +37,7 @@ const TsCodeGenKeyword = {
 class CodeGenConfig {
   version = CONSTANTS.PROJECT_VERSION;
   /** CLI flag */
-  templates = '';
+  templates = "";
   /** CLI flag */
   generateResponses = false;
   /** CLI flag */
@@ -60,7 +60,7 @@ class CodeGenConfig {
 
   /** { "#/components/schemas/Foo": @TypeInfo, ... } */
   componentsMap = {};
-  /** flag for catching convertion from swagger 2.0 */
+  /** flag for catching conversion from swagger 2.0 */
   convertedFromSwagger2 = false;
 
   /** url index from paths used for merging into modules */
@@ -77,10 +77,10 @@ class CodeGenConfig {
   extractResponses = false;
   extractEnums = false;
   fileNames = {
-    dataContracts: 'data-contracts',
-    routeTypes: 'route-types',
-    httpClient: 'http-client',
-    outOfModuleApi: 'Common',
+    dataContracts: "data-contracts",
+    routeTypes: "route-types",
+    httpClient: "http-client",
+    outOfModuleApi: "Common",
   };
   routeNameDuplicatesMap = new Map();
   prettierOptions = { ...CONSTANTS.PRETTIER_OPTIONS };
@@ -108,28 +108,28 @@ class CodeGenConfig {
   sortRoutes = false;
   templatePaths = {
     /** `templates/base` */
-    base: '',
+    base: "",
     /** `templates/default` */
-    default: '',
+    default: "",
     /** `templates/modular` */
-    modular: '',
+    modular: "",
     /** usage path if `--templates` option is not set */
-    original: '',
+    original: "",
     /** custom path to templates (`--templates`) */
-    custom: '',
+    custom: "",
   };
   /** Record<templateName, templateContent> */
   templatesToRender = {
-    api: '',
-    dataContracts: '',
-    dataContractJsDoc: '',
-    interfaceDataContract: '',
-    typeDataContract: '',
-    enumDataContract: '',
-    objectFieldJsDoc: '',
-    httpClient: '',
-    routeTypes: '',
-    routeName: '',
+    api: "",
+    dataContracts: "",
+    dataContractJsDoc: "",
+    interfaceDataContract: "",
+    typeDataContract: "",
+    enumDataContract: "",
+    objectFieldJsDoc: "",
+    httpClient: "",
+    routeTypes: "",
+    routeName: "",
   };
   /**
    * @type {Record<string, (...args: any[]) => MonoSchemaParser>}
@@ -137,68 +137,68 @@ class CodeGenConfig {
   schemaParsers = {};
   toJS = false;
   silent = false;
-  typePrefix = '';
-  typeSuffix = '';
-  enumKeyPrefix = '';
-  enumKeySuffix = '';
+  typePrefix = "";
+  typeSuffix = "";
+  enumKeyPrefix = "";
+  enumKeySuffix = "";
   patch = false;
   /** @type {ComponentTypeNameResolver} */
   componentTypeNameResolver;
   /** name of the main exported class */
-  apiClassName = 'Api';
+  apiClassName = "Api";
   debug = false;
   anotherArrayType = false;
   internalTemplateOptions = {
     addUtilRequiredKeysType: false,
   };
   extraTemplates = [];
-  input = '';
+  input = "";
   modular = false;
-  output = '';
-  url = '';
+  output = "";
+  url = "";
   cleanOutput = false;
   spec = null;
-  fileName = 'Api.ts';
+  fileName = "Api.ts";
   authorizationToken = void 0;
   requestOptions = null;
 
   jsPrimitiveTypes = [];
   jsEmptyTypes = [];
-  fixInvalidTypeNamePrefix = 'Type';
-  fixInvalidEnumKeyPrefix = 'Value';
+  fixInvalidTypeNamePrefix = "Type";
+  fixInvalidEnumKeyPrefix = "Value";
 
-  enumKeyResolverName = 'Value';
-  typeNameResolverName = 'ComponentType';
-  specificArgNameResolverName = 'arg';
+  enumKeyResolverName = "Value";
+  typeNameResolverName = "ComponentType";
+  specificArgNameResolverName = "arg";
 
   successResponseStatusRange = [200, 299];
 
   /** @type {ExtractingOptions} */
   extractingOptions = {
-    requestBodySuffix: ['Payload', 'Body', 'Input'],
-    requestParamsSuffix: ['Params'],
-    responseBodySuffix: ['Data', 'Result', 'Output'],
+    requestBodySuffix: ["Payload", "Body", "Input"],
+    requestParamsSuffix: ["Params"],
+    responseBodySuffix: ["Data", "Result", "Output"],
     responseErrorSuffix: [
-      'Error',
-      'Fail',
-      'Fails',
-      'ErrorData',
-      'HttpError',
-      'BadResponse',
+      "Error",
+      "Fail",
+      "Fails",
+      "ErrorData",
+      "HttpError",
+      "BadResponse",
     ],
-    enumSuffix: ['Enum'],
-    discriminatorMappingSuffix: ['Mapping', 'Mapper', 'MapType'],
+    enumSuffix: ["Enum"],
+    discriminatorMappingSuffix: ["Mapping", "Mapper", "MapType"],
     discriminatorAbstractPrefix: [
-      'Base',
-      'Abstract',
-      'Discriminator',
-      'Internal',
-      'Polymorph',
+      "Base",
+      "Abstract",
+      "Discriminator",
+      "Internal",
+      "Polymorph",
     ],
   };
 
   compilerTsConfig = {
-    module: 'ESNext',
+    module: "ESNext",
     noImplicitReturns: true,
     alwaysStrict: true,
     target: ts.ScriptTarget.ESNext,
@@ -241,7 +241,7 @@ class CodeGenConfig {
     /**
      * $A
      */
-    NullValue: (content) => `null`,
+    NullValue: (content) => "null",
     /**
      * $A1 | $A2
      */
@@ -250,7 +250,7 @@ class CodeGenConfig {
     /**
      * ($A1)
      */
-    ExpressionGroup: (content) => (content ? `(${content})` : ''),
+    ExpressionGroup: (content) => (content ? `(${content})` : ""),
     /**
      * $A1 & $A2
      */
@@ -266,12 +266,12 @@ class CodeGenConfig {
      */
     TypeField: ({ readonly, key, optional, value }) =>
       _.compact([
-        readonly && 'readonly ',
+        readonly && "readonly ",
         key,
-        optional && '?',
-        ': ',
+        optional && "?",
+        ": ",
         value,
-      ]).join(''),
+      ]).join(""),
     /**
      * [key: $A1]: $A2
      */
@@ -294,7 +294,7 @@ class CodeGenConfig {
       _.map(
         contents,
         ({ key, value }) => `  ${this.Ts.EnumField(key, value)}`,
-      ).join(',\n'),
+      ).join(",\n"),
     /**
      * {\n $A \n}
      */
@@ -306,21 +306,21 @@ class CodeGenConfig {
       [
         ...(contents.length === 1
           ? [`/** ${contents[0]} */`]
-          : ['/**', ...contents.map((content) => ` * ${content}`), ' */']),
+          : ["/**", ...contents.map((content) => ` * ${content}`), " */"]),
       ].map((part) => `${formatFn ? formatFn(part) : part}\n`),
     /**
      * $A1<...$A2.join(,)>
      */
     TypeWithGeneric: (typeName, genericArgs) => {
       return `${typeName}${
-        genericArgs.length ? `<${genericArgs.join(',')}>` : ''
+        genericArgs.length ? `<${genericArgs.join(",")}>` : ""
       }`;
     },
     /**
      * [$A1, $A2, ...$AN]
      */
     Tuple: (values) => {
-      return `[${values.join(', ')}]`;
+      return `[${values.join(", ")}]`;
     },
   };
 
@@ -341,39 +341,39 @@ class CodeGenConfig {
       /** formats */
       binary: () => this.Ts.Keyword.File,
       file: () => this.Ts.Keyword.File,
-      'date-time': () => this.Ts.Keyword.String,
+      "date-time": () => this.Ts.Keyword.String,
       time: () => this.Ts.Keyword.String,
       date: () => this.Ts.Keyword.String,
       duration: () => this.Ts.Keyword.String,
       email: () => this.Ts.Keyword.String,
-      'idn-email': () => this.Ts.Keyword.String,
-      'idn-hostname': () => this.Ts.Keyword.String,
+      "idn-email": () => this.Ts.Keyword.String,
+      "idn-hostname": () => this.Ts.Keyword.String,
       ipv4: () => this.Ts.Keyword.String,
       ipv6: () => this.Ts.Keyword.String,
       uuid: () => this.Ts.Keyword.String,
       uri: () => this.Ts.Keyword.String,
-      'uri-reference': () => this.Ts.Keyword.String,
-      'uri-template': () => this.Ts.Keyword.String,
-      'json-pointer': () => this.Ts.Keyword.String,
-      'relative-json-pointer': () => this.Ts.Keyword.String,
+      "uri-reference": () => this.Ts.Keyword.String,
+      "uri-template": () => this.Ts.Keyword.String,
+      "json-pointer": () => this.Ts.Keyword.String,
+      "relative-json-pointer": () => this.Ts.Keyword.String,
       regex: () => this.Ts.Keyword.String,
     },
   };
 
   templateInfos = [
-    { name: 'api', fileName: 'api' },
-    { name: 'dataContracts', fileName: 'data-contracts' },
-    { name: 'dataContractJsDoc', fileName: 'data-contract-jsdoc' },
-    { name: 'interfaceDataContract', fileName: 'interface-data-contract' },
-    { name: 'typeDataContract', fileName: 'type-data-contract' },
-    { name: 'enumDataContract', fileName: 'enum-data-contract' },
-    { name: 'objectFieldJsDoc', fileName: 'object-field-jsdoc' },
-    { name: 'httpClient', fileName: 'http-client' },
-    { name: 'routeTypes', fileName: 'route-types' },
-    { name: 'routeName', fileName: 'route-name' },
+    { name: "api", fileName: "api" },
+    { name: "dataContracts", fileName: "data-contracts" },
+    { name: "dataContractJsDoc", fileName: "data-contract-jsdoc" },
+    { name: "interfaceDataContract", fileName: "interface-data-contract" },
+    { name: "typeDataContract", fileName: "type-data-contract" },
+    { name: "enumDataContract", fileName: "enum-data-contract" },
+    { name: "objectFieldJsDoc", fileName: "object-field-jsdoc" },
+    { name: "httpClient", fileName: "http-client" },
+    { name: "routeTypes", fileName: "route-types" },
+    { name: "routeName", fileName: "route-name" },
   ];
 
-  templateExtensions = ['.eta', '.ejs'];
+  templateExtensions = [".eta", ".ejs"];
 
   /**
    * @param config {Partial<GenerateApiConfiguration['config']>}
@@ -429,12 +429,12 @@ class CodeGenConfig {
 }
 
 const getDefaultPrettierOptions = () => {
-  const prettier = cosmiconfigSync('prettier').search();
+  const prettier = cosmiconfigSync("prettier").search();
 
   if (prettier) {
     return {
       ...prettier.config,
-      parser: 'typescript',
+      parser: "typescript",
     };
   }
 

package/src/constants.js

@@ -1,33 +1,33 @@
-const packageJson = require('../package.json');
-const RESERVED_QUERY_ARG_NAMES = ['query', 'queryParams', 'queryArg'];
-const RESERVED_BODY_ARG_NAMES = ['data', 'body', 'reqBody'];
+const packageJson = require("../package.json");
+const RESERVED_QUERY_ARG_NAMES = ["query", "queryParams", "queryArg"];
+const RESERVED_BODY_ARG_NAMES = ["data", "body", "reqBody"];
 const RESERVED_REQ_PARAMS_ARG_NAMES = [
-  'params',
-  'requestParams',
-  'reqParams',
-  'httpParams',
+  "params",
+  "requestParams",
+  "reqParams",
+  "httpParams",
 ];
-const RESERVED_PATH_ARG_NAMES = ['path', 'pathParams'];
-const RESERVED_HEADER_ARG_NAMES = ['headers', 'headersParams'];
+const RESERVED_PATH_ARG_NAMES = ["path", "pathParams"];
+const RESERVED_HEADER_ARG_NAMES = ["headers", "headersParams"];
 
 const SCHEMA_TYPES = {
-  ARRAY: 'array',
-  OBJECT: 'object',
-  ENUM: 'enum',
-  REF: '$ref',
-  PRIMITIVE: 'primitive',
-  COMPLEX: 'complex',
-  DISCRIMINATOR: 'discriminator',
-  COMPLEX_ONE_OF: 'oneOf',
-  COMPLEX_ANY_OF: 'anyOf',
-  COMPLEX_ALL_OF: 'allOf',
-  COMPLEX_NOT: 'not',
-  COMPLEX_UNKNOWN: '__unknown',
+  ARRAY: "array",
+  OBJECT: "object",
+  ENUM: "enum",
+  REF: "$ref",
+  PRIMITIVE: "primitive",
+  COMPLEX: "complex",
+  DISCRIMINATOR: "discriminator",
+  COMPLEX_ONE_OF: "oneOf",
+  COMPLEX_ANY_OF: "anyOf",
+  COMPLEX_ALL_OF: "allOf",
+  COMPLEX_NOT: "not",
+  COMPLEX_UNKNOWN: "__unknown",
 };
 
 const HTTP_CLIENT = {
-  FETCH: 'fetch',
-  AXIOS: 'axios',
+  FETCH: "fetch",
+  AXIOS: "axios",
 };
 
 const PROJECT_VERSION = packageJson.version;
@@ -47,7 +47,7 @@ const FILE_PREFIX = `/* eslint-disable */
 
 module.exports = {
   FILE_PREFIX,
-  DEFAULT_BODY_ARG_NAME: 'data',
+  DEFAULT_BODY_ARG_NAME: "data",
   PROJECT_VERSION,
   SCHEMA_TYPES,
   HTTP_CLIENT,
@@ -59,7 +59,7 @@ module.exports = {
   PRETTIER_OPTIONS: {
     printWidth: 120,
     tabWidth: 2,
-    trailingComma: 'all',
-    parser: 'typescript',
+    trailingComma: "all",
+    parser: "typescript",
   },
 };

package/src/index.js

@@ -6,9 +6,9 @@
 // License text available at https://opensource.org/licenses/MIT
 // Repository https://github.com/acacode/swagger-typescript-api
 
-const constants = require('./constants');
-const { CodeGenProcess } = require('./code-gen-process.js');
-const { generateTemplates } = require('./commands/generate-templates');
+const constants = require("./constants");
+const { CodeGenProcess } = require("./code-gen-process.js");
+const { generateTemplates } = require("./commands/generate-templates");
 
 module.exports = {
   constants: constants,

package/src/schema-components-map.js

@@ -1,4 +1,4 @@
-const _ = require('lodash');
+const _ = require("lodash");
 
 class SchemaComponentsMap {
   /** @type {SchemaComponent[]} */
@@ -15,11 +15,11 @@ class SchemaComponentsMap {
   }
 
   createRef = (paths) => {
-    return ['#', ...paths].join('/');
+    return ["#", ...paths].join("/");
   };
 
   parseRef = (ref) => {
-    return ref.split('/');
+    return ref.split("/");
   };
 
   createComponent($ref, rawTypeData) {

package/src/schema-parser/base-schema-parsers/array.js

@@ -1,6 +1,6 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
-const _ = require('lodash');
-const { SCHEMA_TYPES } = require('../../constants');
+const { MonoSchemaParser } = require("../mono-schema-parser");
+const _ = require("lodash");
+const { SCHEMA_TYPES } = require("../../constants");
 
 class ArraySchemaParser extends MonoSchemaParser {
   parse() {

package/src/schema-parser/base-schema-parsers/complex.js

@@ -1,6 +1,6 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
-const _ = require('lodash');
-const { SCHEMA_TYPES } = require('../../constants');
+const { MonoSchemaParser } = require("../mono-schema-parser");
+const _ = require("lodash");
+const { SCHEMA_TYPES } = require("../../constants");
 
 class ComplexSchemaParser extends MonoSchemaParser {
   parse() {
@@ -23,8 +23,8 @@ class ComplexSchemaParser extends MonoSchemaParser {
       name: this.typeName,
       description: this.schemaFormatters.formatDescription(
         this.schema.description ||
-          _.compact(_.map(this.schema[complexType], 'description'))[0] ||
-          '',
+          _.compact(_.map(this.schema[complexType], "description"))[0] ||
+          "",
       ),
       content:
         this.config.Ts.IntersectionType(

package/src/schema-parser/base-schema-parsers/discriminator.js

@@ -1,6 +1,6 @@
-const _ = require('lodash');
-const { SCHEMA_TYPES } = require('../../constants');
-const { MonoSchemaParser } = require('../mono-schema-parser');
+const _ = require("lodash");
+const { SCHEMA_TYPES } = require("../../constants");
+const { MonoSchemaParser } = require("../mono-schema-parser");
 
 class DiscriminatorSchemaParser extends MonoSchemaParser {
   parse() {
@@ -54,8 +54,8 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
     const ts = this.config.Ts;
 
     const refPath = this.schemaComponentsMap.createRef([
-      'components',
-      'schemas',
+      "components",
+      "schemas",
       this.typeName,
     ]);
     const { discriminator } = this.schema;
@@ -85,18 +85,18 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
         ts.ObjectWrapper(
           ts.TypeField({
             key: ts.StringValue(discriminator.propertyName),
-            value: 'Key',
+            value: "Key",
           }),
         ),
-        'Type',
+        "Type",
       ]);
 
       const component = this.schemaParserFabric.createParsedComponent({
         typeName: generatedTypeName,
         schema: {
-          type: 'object',
+          type: "object",
           properties: {},
-          genericArgs: [{ name: 'Key' }, { name: 'Type' }],
+          genericArgs: [{ name: "Key" }, { name: "Type" }],
           internal: true,
         },
       });
@@ -138,7 +138,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
 
     for (const [mappingKey, schema] of mappingEntries) {
       const mappingSchema =
-        typeof schema === 'string' ? { $ref: schema } : schema;
+        typeof schema === "string" ? { $ref: schema } : schema;
 
       this.mutateMappingDependentSchema({
         discPropertyName: discriminator.propertyName,
@@ -169,7 +169,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
     let mappingPropertySchemaEnumKeysMap = {};
     let mappingPropertySchema = _.get(
       abstractSchemaStruct?.component?.rawTypeData,
-      ['properties', discPropertyName],
+      ["properties", discPropertyName],
     );
     if (this.schemaUtils.isRefSchema(mappingPropertySchema)) {
       mappingPropertySchema = this.schemaUtils.getSchemaRefType(
@@ -271,7 +271,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
       resolver: this.config.extractingOptions.discriminatorAbstractResolver,
     });
     const component = this.schemaComponentsMap.createComponent(
-      this.schemaComponentsMap.createRef(['components', 'schemas', typeName]),
+      this.schemaComponentsMap.createRef(["components", "schemas", typeName]),
       {
         ...schema,
         internal: true,

package/src/schema-parser/base-schema-parsers/enum.js

@@ -1,7 +1,7 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
-const _ = require('lodash');
-const { SCHEMA_TYPES } = require('../../constants');
-const { EnumKeyResolver } = require('../util/enum-key-resolver');
+const { MonoSchemaParser } = require("../mono-schema-parser");
+const _ = require("lodash");
+const { SCHEMA_TYPES } = require("../../constants");
+const { EnumKeyResolver } = require("../util/enum-key-resolver");
 
 class EnumSchemaParser extends MonoSchemaParser {
   /** @type {EnumKeyResolver} */
@@ -19,8 +19,8 @@ class EnumSchemaParser extends MonoSchemaParser {
     });
     const customComponent = this.schemaComponentsMap.createComponent(
       this.schemaComponentsMap.createRef([
-        'components',
-        'schemas',
+        "components",
+        "schemas",
         generatedTypeName,
       ]),
       {
@@ -49,9 +49,9 @@ class EnumSchemaParser extends MonoSchemaParser {
       return this.schemaParserFabric.parseSchema(
         {
           oneOf: this.schema.enum.map((enumNames) => ({
-            type: 'array',
+            type: "array",
             items: enumNames.map((enumName) => ({
-              type: 'string',
+              type: "string",
               enum: [enumName],
             })),
           })),
@@ -70,12 +70,12 @@ class EnumSchemaParser extends MonoSchemaParser {
         return this.config.Ts.NullValue(value);
       }
       if (
-        _.includes(keyType, this.schemaUtils.getSchemaType({ type: 'number' }))
+        _.includes(keyType, this.schemaUtils.getSchemaType({ type: "number" }))
       ) {
         return this.config.Ts.NumberValue(value);
       }
       if (
-        _.includes(keyType, this.schemaUtils.getSchemaType({ type: 'boolean' }))
+        _.includes(keyType, this.schemaUtils.getSchemaType({ type: "boolean" }))
       ) {
         return this.config.Ts.BooleanValue(value);
       }
@@ -139,13 +139,13 @@ class EnumSchemaParser extends MonoSchemaParser {
 
     if (key) {
       formatted = this.typeNameFormatter.format(key, {
-        type: 'enum-key',
+        type: "enum-key",
       });
     }
 
     if (!formatted) {
       formatted = this.typeNameFormatter.format(`${value}`, {
-        type: 'enum-key',
+        type: "enum-key",
       });
     }