swagger-typescript-api 13.0.2 → 13.0.4

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",
       });
     }
 

package/src/schema-parser/base-schema-parsers/object.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 ObjectSchemaParser extends MonoSchemaParser {
   parse() {
@@ -36,7 +36,7 @@ class ObjectSchemaParser extends MonoSchemaParser {
       );
       const rawTypeData = _.get(
         this.schemaUtils.getSchemaRefType(property),
-        'rawTypeData',
+        "rawTypeData",
         {},
       );
       const nullable = !!(rawTypeData.nullable || property.nullable);
@@ -60,17 +60,17 @@ class ObjectSchemaParser extends MonoSchemaParser {
           _.compact(
             _.map(
               property[this.schemaUtils.getComplexType(property)],
-              'description',
+              "description",
             ),
           )[0] ||
           rawTypeData.description ||
           _.compact(
             _.map(
               rawTypeData[this.schemaUtils.getComplexType(rawTypeData)],
-              'description',
+              "description",
             ),
           )[0] ||
-          '',
+          "",
         isRequired: required,
         isNullable: nullable,
         name: fieldName,
@@ -87,7 +87,7 @@ class ObjectSchemaParser extends MonoSchemaParser {
     if (additionalProperties) {
       propertiesContent.push({
         $$raw: { additionalProperties },
-        description: '',
+        description: "",
         isRequired: false,
         field: this.config.Ts.InterfaceDynamicField(
           this.config.Ts.Keyword.String,

package/src/schema-parser/base-schema-parsers/primitive.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 PrimitiveSchemaParser extends MonoSchemaParser {
   parse() {

package/src/schema-parser/complex-schema-parsers/all-of.js

@@ -1,5 +1,5 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
-const _ = require('lodash');
+const { MonoSchemaParser } = require("../mono-schema-parser");
+const _ = require("lodash");
 
 // T1 & T2
 class AllOfSchemaParser extends MonoSchemaParser {

package/src/schema-parser/complex-schema-parsers/any-of.js

@@ -1,5 +1,5 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
-const _ = require('lodash');
+const { MonoSchemaParser } = require("../mono-schema-parser");
+const _ = require("lodash");
 
 // T1 | T2
 class AnyOfSchemaParser extends MonoSchemaParser {

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

@@ -1,4 +1,4 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
+const { MonoSchemaParser } = require("../mono-schema-parser");
 
 class NotSchemaParser extends MonoSchemaParser {
   parse() {

package/src/schema-parser/complex-schema-parsers/one-of.js

@@ -1,5 +1,5 @@
-const { MonoSchemaParser } = require('../mono-schema-parser');
-const _ = require('lodash');
+const { MonoSchemaParser } = require("../mono-schema-parser");
+const _ = require("lodash");
 
 // T1 | T2
 class OneOfSchemaParser extends MonoSchemaParser {

package/src/schema-parser/mono-schema-parser.js

@@ -35,7 +35,7 @@ class MonoSchemaParser {
   }
 
   parse() {
-    throw new Error('not implemented');
+    throw new Error("not implemented");
   }
 
   buildTypeNameFromPath = () => {

package/src/schema-parser/schema-formatters.js

@@ -1,5 +1,5 @@
-const { SCHEMA_TYPES } = require('../constants');
-const _ = require('lodash');
+const { SCHEMA_TYPES } = require("../constants");
+const _ = require("lodash");
 
 class SchemaFormatters {
   /** @type {CodeGenConfig} */
@@ -100,22 +100,22 @@ class SchemaFormatters {
    * @param parsedSchema {Record<string, any>}
    * @param formatType {"base" | "inline"}
    */
-  formatSchema = (parsedSchema, formatType = 'base') => {
+  formatSchema = (parsedSchema, formatType = "base") => {
     const schemaType =
-      _.get(parsedSchema, ['schemaType']) ||
-      _.get(parsedSchema, ['$parsed', 'schemaType']);
+      _.get(parsedSchema, ["schemaType"]) ||
+      _.get(parsedSchema, ["$parsed", "schemaType"]);
     const formatterFn = _.get(this, [formatType, schemaType]);
     return (formatterFn && formatterFn(parsedSchema)) || parsedSchema;
   };
 
   formatDescription = (description, inline) => {
-    if (!description) return '';
+    if (!description) return "";
 
     let prettified = description;
 
-    prettified = _.replace(prettified, /\*\//g, '*/');
+    prettified = _.replace(prettified, /\*\//g, "*/");
 
-    const hasMultipleLines = _.includes(prettified, '\n');
+    const hasMultipleLines = _.includes(prettified, "\n");
 
     if (!hasMultipleLines) return prettified;
 
@@ -124,18 +124,18 @@ class SchemaFormatters {
         .split(/\n/g)
         .map((part) => _.trim(part))
         .compact()
-        .join(' ')
+        .join(" ")
         .valueOf();
     }
 
-    return _.replace(prettified, /\n$/g, '');
+    return _.replace(prettified, /\n$/g, "");
   };
 
   formatObjectContent = (content) => {
     const fields = [];
 
     for (const part of content) {
-      const extraSpace = '  ';
+      const extraSpace = "  ";
       const result = `${extraSpace}${part.field},\n`;
 
       const renderedJsDoc = this.templatesWorker.renderTemplate(
@@ -146,9 +146,9 @@ class SchemaFormatters {
       );
 
       const routeNameFromTemplate = renderedJsDoc
-        .split('\n')
+        .split("\n")
         .map((c) => `${extraSpace}${c}`)
-        .join('\n');
+        .join("\n");
 
       if (routeNameFromTemplate) {
         fields.push(`${routeNameFromTemplate}${result}`);
@@ -157,7 +157,7 @@ class SchemaFormatters {
       }
     }
 
-    return fields.join('');
+    return fields.join("");
   };
 }
 

package/src/schema-parser/schema-parser-fabric.js

@@ -1,7 +1,7 @@
-const _ = require('lodash');
-const { SchemaFormatters } = require('./schema-formatters');
-const { SchemaUtils } = require('./schema-utils');
-const { SchemaParser } = require('./schema-parser');
+const _ = require("lodash");
+const { SchemaFormatters } = require("./schema-formatters");
+const { SchemaUtils } = require("./schema-utils");
+const { SchemaParser } = require("./schema-parser");
 
 class SchemaParserFabric {
   /** @type {CodeGenConfig} */
@@ -75,7 +75,7 @@ class SchemaParserFabric {
   createParsedComponent = ({ typeName, schema, schemaPath }) => {
     const schemaCopy = _.cloneDeep(schema);
     const customComponent = this.schemaComponentsMap.createComponent(
-      this.schemaComponentsMap.createRef(['components', 'schemas', typeName]),
+      this.schemaComponentsMap.createRef(["components", "schemas", typeName]),
       schemaCopy,
     );
     const parsed = this.parseSchema(schemaCopy, null, schemaPath);

package/src/schema-parser/schema-parser.js

@@ -1,21 +1,21 @@
 /* eslint-disable no-unused-vars */
-const { SCHEMA_TYPES } = require('../constants.js');
-const _ = require('lodash');
-const { SchemaFormatters } = require('./schema-formatters');
-const { SchemaUtils } = require('./schema-utils');
+const { SCHEMA_TYPES } = require("../constants.js");
+const _ = require("lodash");
+const { SchemaFormatters } = require("./schema-formatters");
+const { SchemaUtils } = require("./schema-utils");
 const {
   DiscriminatorSchemaParser,
-} = require('./base-schema-parsers/discriminator');
-const { EnumSchemaParser } = require('./base-schema-parsers/enum');
-const { ObjectSchemaParser } = require('./base-schema-parsers/object');
-const { PrimitiveSchemaParser } = require('./base-schema-parsers/primitive');
-const { ComplexSchemaParser } = require('./base-schema-parsers/complex');
-const { OneOfSchemaParser } = require('./complex-schema-parsers/one-of');
-const { AllOfSchemaParser } = require('./complex-schema-parsers/all-of');
-const { AnyOfSchemaParser } = require('./complex-schema-parsers/any-of');
-const { NotSchemaParser } = require('./complex-schema-parsers/not');
-const { ArraySchemaParser } = require('./base-schema-parsers/array');
-const { sortByProperty } = require('../util/sort-by-property');
+} = require("./base-schema-parsers/discriminator");
+const { EnumSchemaParser } = require("./base-schema-parsers/enum");
+const { ObjectSchemaParser } = require("./base-schema-parsers/object");
+const { PrimitiveSchemaParser } = require("./base-schema-parsers/primitive");
+const { ComplexSchemaParser } = require("./base-schema-parsers/complex");
+const { OneOfSchemaParser } = require("./complex-schema-parsers/one-of");
+const { AllOfSchemaParser } = require("./complex-schema-parsers/all-of");
+const { AnyOfSchemaParser } = require("./complex-schema-parsers/any-of");
+const { NotSchemaParser } = require("./complex-schema-parsers/not");
+const { ArraySchemaParser } = require("./base-schema-parsers/array");
+const { sortByProperty } = require("../util/sort-by-property");
 
 class SchemaParser {
   /** @type {SchemaParserFabric} */
@@ -184,7 +184,7 @@ class SchemaParser {
     let schemaType = null;
     let parsedSchema = null;
 
-    if (typeof this.schema === 'string') {
+    if (typeof this.schema === "string") {
       return this.schema;
     }
 
@@ -209,13 +209,13 @@ class SchemaParser {
         this.schema.enum.length === 1 &&
         this.schema.enum[0] == null
       ) {
-        this.logger.debug('invalid enum schema', this.schema);
+        this.logger.debug("invalid enum schema", this.schema);
         this.schema = { type: this.config.Ts.Keyword.Null };
       }
       // schema is response schema
       if (
-        'content' in this.schema &&
-        typeof this.schema['content'] === 'object'
+        "content" in this.schema &&
+        typeof this.schema["content"] === "object"
       ) {
         const schema = this.extractSchemaFromResponseStruct(this.schema);
         const schemaParser = this.schemaParserFabric.createSchemaParser({
@@ -254,7 +254,7 @@ class SchemaParser {
         Array.isArray(this.schema.$parsed?.content)
       ) {
         this.schema.$parsed.content = this.schema.$parsed.content.sort(
-          sortByProperty('name'),
+          sortByProperty("name"),
         );
       }
     }
@@ -268,7 +268,7 @@ class SchemaParser {
     const parsedSchema = this.parseSchema();
     const formattedSchema = this.schemaFormatters.formatSchema(
       parsedSchema,
-      'inline',
+      "inline",
     );
     return formattedSchema.content;
   };
@@ -277,7 +277,7 @@ class SchemaParser {
     const parsedSchema = this.parseSchema();
     const formattedSchema = this.schemaFormatters.formatSchema(
       parsedSchema,
-      'base',
+      "base",
     );
     return formattedSchema.content;
   };
@@ -286,13 +286,13 @@ class SchemaParser {
     const { content, ...extras } = responseStruct;
 
     const firstResponse = _.first(_.values(content));
-    const firstSchema = _.get(firstResponse, 'schema');
+    const firstSchema = _.get(firstResponse, "schema");
 
     if (!firstSchema) return;
 
     return {
       ...extras,
-      ..._.omit(firstResponse, 'schema'),
+      ..._.omit(firstResponse, "schema"),
       ...firstSchema,
     };
   };

package/src/schema-parser/schema-utils.js

@@ -1,8 +1,8 @@
-const _ = require('lodash');
-const { SCHEMA_TYPES } = require('../constants');
-const { internalCase } = require('../util/internal-case');
-const { pascalCase } = require('../util/pascal-case');
-const { camelCase } = require('lodash');
+const _ = require("lodash");
+const { SCHEMA_TYPES } = require("../constants");
+const { internalCase } = require("../util/internal-case");
+const { pascalCase } = require("../util/pascal-case");
+const { camelCase } = require("lodash");
 
 class SchemaUtils {
   /** @type {CodeGenConfig} */
@@ -33,15 +33,15 @@ class SchemaUtils {
   };
 
   isRefSchema = (schema) => {
-    return !!(schema && schema['$ref']);
+    return !!(schema && schema["$ref"]);
   };
 
   getEnumNames = (schema) => {
     return (
-      schema['x-enumNames'] ||
-      schema['xEnumNames'] ||
-      schema['x-enumnames'] ||
-      schema['x-enum-varnames']
+      schema["x-enumNames"] ||
+      schema["xEnumNames"] ||
+      schema["x-enumnames"] ||
+      schema["x-enum-varnames"]
     );
   };
 
@@ -52,15 +52,15 @@ class SchemaUtils {
   };
 
   isPropertyRequired = (name, propertySchema, rootSchema) => {
-    if (propertySchema['x-omitempty'] === false) {
+    if (propertySchema["x-omitempty"] === false) {
       return true;
     }
 
     const isRequired = _.isBoolean(propertySchema.required)
       ? !!propertySchema.required
       : _.isArray(rootSchema.required)
-      ? rootSchema.required.includes(name)
-      : !!rootSchema.required;
+        ? rootSchema.required.includes(name)
+        : !!rootSchema.required;
 
     if (this.config.convertedFromSwagger2) {
       return typeof propertySchema.nullable === this.config.Ts.Keyword.Undefined
@@ -74,7 +74,7 @@ class SchemaUtils {
     const { nullable, type: schemaType } = schema || {};
     return (
       (nullable ||
-        !!_.get(schema, 'x-nullable') ||
+        !!_.get(schema, "x-nullable") ||
         schemaType === this.config.Ts.Keyword.Null) &&
       _.isString(type) &&
       !type.includes(` ${this.config.Ts.Keyword.Null}`) &&
@@ -112,7 +112,7 @@ class SchemaUtils {
   };
 
   checkAndAddRequiredKeys = (schema, resultType) => {
-    if ('$$requiredKeys' in schema && schema.$$requiredKeys.length) {
+    if ("$$requiredKeys" in schema && schema.$$requiredKeys.length) {
       this.config.update({
         internalTemplateOptions: {
           addUtilRequiredKeysType: true,
@@ -261,7 +261,7 @@ class SchemaUtils {
 
       const typeAlias =
         _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
-        _.get(this.config.primitiveTypes, [primitiveType, '$default']) ||
+        _.get(this.config.primitiveTypes, [primitiveType, "$default"]) ||
         this.config.primitiveTypes[primitiveType];
 
       if (_.isFunction(typeAlias)) {
@@ -288,24 +288,24 @@ class SchemaUtils {
 
     return pascalCase(
       camelCase(
-        _.uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join('_'),
+        _.uniq([schemaPath[0], schemaPath[schemaPath.length - 1]]).join("_"),
       ),
     );
   };
 
   isConstantSchema(schema) {
-    return 'const' in schema;
+    return "const" in schema;
   }
 
   formatJsValue = (value) => {
     switch (typeof value) {
-      case 'string': {
+      case "string": {
         return this.config.Ts.StringValue(value);
       }
-      case 'boolean': {
+      case "boolean": {
         return this.config.Ts.BooleanValue(value);
       }
-      case 'number': {
+      case "number": {
         return this.config.Ts.NumberValue(value);
       }
       default: {

package/src/schema-parser/util/enum-key-resolver.js

@@ -1,4 +1,4 @@
-const { NameResolver } = require('../../util/name-resolver');
+const { NameResolver } = require("../../util/name-resolver");
 
 class EnumKeyResolver extends NameResolver {
   counter = 1;
@@ -13,7 +13,7 @@ class EnumKeyResolver extends NameResolver {
         (variants[0] && `${variants[0]}${this.counter++}`) ||
         `${this.config.enumKeyResolverName}${this.counter++}`;
       this.logger.debug(
-        'generated fallback type name for enum key - ',
+        "generated fallback type name for enum key - ",
         generatedVariant,
       );
       return generatedVariant;