swagger-typescript-api 13.0.1 → 13.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-typescript-api",
-  "version": "13.0.1",
+  "version": "13.0.3",
   "description": "Generate typescript/javascript api from swagger schema",
   "scripts": {
     "update-deps-to-latest": "npx --yes npm-check-updates && npm i",

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

@@ -74,36 +74,36 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
       });
 
     if (ableToCreateMappingType) {
-      const mappingTypeNameRef = this.schemaComponentsMap.createRef([
-        'components',
-        'schemas',
-        this.schemaUtils.resolveTypeName(
-          `${abstractSchemaStruct.typeName} ${discriminator.propertyName}`,
-          {
-            suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
-            resolver:
-              this.config.extractingOptions.discriminatorMappingNameResolver,
-          },
+      const rawTypeName = `${abstractSchemaStruct.typeName}_${discriminator.propertyName}`;
+      const generatedTypeName = this.schemaUtils.resolveTypeName(rawTypeName, {
+        suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
+        resolver:
+          this.config.extractingOptions.discriminatorMappingNameResolver,
+      });
+
+      const content = ts.IntersectionType([
+        ts.ObjectWrapper(
+          ts.TypeField({
+            key: ts.StringValue(discriminator.propertyName),
+            value: 'Key',
+          }),
         ),
+        'Type',
       ]);
-      const mappingTypeNameComponent =
-        this.schemaComponentsMap.createComponent(mappingTypeNameRef);
-      const mappingTypeNameSchema = this.schemaParserFabric.createSchema({
-        linkedComponent: mappingTypeNameComponent,
-        content: ts.IntersectionType([
-          ts.ObjectWrapper(
-            ts.TypeField({
-              key: ts.StringValue(discriminator.propertyName),
-              value: 'Key',
-            }),
-          ),
-          'Type',
-        ]),
-        genericArgs: [{ name: 'Key' }, { name: 'Type' }],
-        internal: true,
+
+      const component = this.schemaParserFabric.createParsedComponent({
+        typeName: generatedTypeName,
+        schema: {
+          type: 'object',
+          properties: {},
+          genericArgs: [{ name: 'Key' }, { name: 'Type' }],
+          internal: true,
+        },
       });
 
-      mappingTypeName = mappingTypeNameSchema.typeData.name;
+      component.typeData.content = content;
+
+      mappingTypeName = this.typeNameFormatter.format(component.typeName);
     }
 
     /** returns (GenericType<"mapping_key", MappingType>) or ({ discriminatorProperty: "mapping_key" } & MappingType) */
@@ -259,9 +259,12 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
     const { discriminator, ...noDiscriminatorSchema } = this.schema;
     const complexSchemaKeys = _.keys(this.schemaParser._complexSchemaParsers);
     const schema = _.omit(_.clone(noDiscriminatorSchema), complexSchemaKeys);
+    const schemaIsAny =
+      this.schemaParserFabric.getInlineParseContent(_.cloneDeep(schema)) ===
+      this.config.Ts.Keyword.Any;
     const schemaIsEmpty = !_.keys(schema).length;
 
-    if (schemaIsEmpty) return null;
+    if (schemaIsEmpty || schemaIsAny) return null;
 
     const typeName = this.schemaUtils.resolveTypeName(this.typeName, {
       prefixes: this.config.extractingOptions.discriminatorAbstractPrefix,

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

@@ -79,6 +79,7 @@ class SchemaParserFabric {
       schemaCopy,
     );
     const parsed = this.parseSchema(schemaCopy, null, schemaPath);
+
     parsed.name = typeName;
     customComponent.typeData = parsed;
 

package/src/type-name-formatter.js

@@ -41,13 +41,7 @@ class TypeNameFormatter {
         ? this.config.enumKeySuffix
         : this.config.typeSuffix;
 
-    const existedFormattedEntry = Array.from(
-      this.formattedModelNamesMap.entries(),
-    ).find((entry) => entry[1] === name);
-
-    const hashKey = existedFormattedEntry
-      ? existedFormattedEntry[0]
-      : `${typePrefix}_${name}_${typeSuffix}`;
+    const hashKey = `${typePrefix}_${name}_${typeSuffix}`;
 
     if (typeof name !== 'string') {
       this.logger.warn('wrong name of the model name', name);