swagger-typescript-api 13.0.0 → 13.0.2

package/README.md

@@ -81,6 +81,8 @@ Options:
   --debug                       additional information about processes inside this tool (default: false)
   --another-array-type          generate array types as Array<Type> (by default Type[]) (default: false)
   --sort-types                  sort fields and types (default: false)
+  --sort-routes                 sort routes in alphabetical order (default: false)
+  --custom-config <string>      custom config: primitiveTypeConstructs, hooks, ...  (default: "")
   --extract-enums               extract all enums from inline interface\type content to typescript enum construction (default: false)
   -h, --help                    display help for command
 
@@ -149,6 +151,8 @@ generateApi({
   enumKeyPrefix: '',
   enumKeySuffix: '',
   addReadonly: false,
+  sortTypes: false,
+  sortRouters: false,
   extractingOptions: {
     requestBodySuffix: ["Payload", "Body", "Input"],
     requestParamsSuffix: ["Params"],

package/index.js

@@ -114,6 +114,12 @@ const program = cli({
       default: codeGenBaseConfig.extractResponseError,
       internal: { formatter: Boolean },
     },
+    {
+      flags: '--extract-responses',
+      description: 'extract all responses described in /components/responses',
+      default: codeGenBaseConfig.extractResponses,
+      internal: { formatter: Boolean },
+    },
     {
       flags: '--modular',
       description:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-typescript-api",
-  "version": "13.0.0",
+  "version": "13.0.2",
   "description": "Generate typescript/javascript api from swagger schema",
   "scripts": {
     "update-deps-to-latest": "npx --yes npm-check-updates && npm i",
@@ -40,6 +40,7 @@
     "test:--extract-response-error": "node tests/spec/extractResponseError/test.js",
     "test:--enum-names-as-values": "node tests/spec/enumNamesAsValues/test.js",
     "test:--default-response": "node tests/spec/defaultResponse/test.js",
+    "test:const-keyword": "node tests/spec/const-keyword/test.js",
     "test:--js": "node tests/spec/js/test.js",
     "test:jsSingleHttpClientModular": "node tests/spec/jsSingleHttpClientModular/test.js",
     "test:--js--axios": "node tests/spec/jsAxios/test.js",

package/src/code-gen-process.js

@@ -116,9 +116,14 @@ class CodeGenProcess {
       }),
     );
 
-    const schemaComponents = this.schemaComponentsMap.filter('schemas');
+    /**
+     * @type {SchemaComponent[]}
+     */
+    const componentsToParse = this.schemaComponentsMap.filter(
+      _.compact(['schemas', this.config.extractResponses && 'responses']),
+    );
 
-    const parsedSchemas = schemaComponents.map((schemaComponent) => {
+    const parsedSchemas = componentsToParse.map((schemaComponent) => {
       const parsed = this.schemaParserFabric.parseSchema(
         schemaComponent.rawTypeData,
         schemaComponent.typeName,
@@ -234,8 +239,13 @@ class CodeGenProcess {
     const components = this.schemaComponentsMap.getComponents();
     let modelTypes = [];
 
+    const modelTypeComponents = _.compact([
+      'schemas',
+      this.config.extractResponses && 'responses',
+    ]);
+
     const getSchemaComponentsCount = () =>
-      components.filter((c) => c.componentName === 'schemas').length;
+      this.schemaComponentsMap.filter(...modelTypeComponents).length;
 
     let schemaComponentsCount = getSchemaComponentsCount();
     let processedCount = 0;
@@ -244,7 +254,7 @@ class CodeGenProcess {
       modelTypes = [];
       processedCount = 0;
       for (const component of components) {
-        if (component.componentName === 'schemas') {
+        if (modelTypeComponents.includes(component.componentName)) {
           const modelType = this.prepareModelType(component);
           if (modelType) {
             modelTypes.push(modelType);

package/src/configuration.js

@@ -74,6 +74,7 @@ class CodeGenConfig {
   extractRequestBody = false;
   extractResponseBody = false;
   extractResponseError = false;
+  extractResponses = false;
   extractEnums = false;
   fileNames = {
     dataContracts: 'data-contracts',
@@ -240,7 +241,7 @@ class CodeGenConfig {
     /**
      * $A
      */
-    NullValue: (content) => content,
+    NullValue: (content) => `null`,
     /**
      * $A1 | $A2
      */
@@ -276,6 +277,9 @@ class CodeGenConfig {
      */
     InterfaceDynamicField: (key, value) => `[key: ${key}]: ${value}`,
 
+    /**
+     * EnumName.EnumKey
+     */
     EnumUsageKey: (enumStruct, key) => `${enumStruct}.${key}`,
     /**
      * $A1 = $A2

package/src/schema-components-map.js

@@ -57,12 +57,14 @@ class SchemaComponentsMap {
   }
 
   /**
-   * @param componentName {string}
+   * @params {...string[]} componentNames
    * @returns {SchemaComponent[]}
    */
-  filter(componentName) {
-    return _.filter(this._data, (v) =>
-      _.startsWith(v.$ref, `#/components/${componentName}`),
+  filter(...componentNames) {
+    return _.filter(this._data, (it) =>
+      componentNames.some((componentName) =>
+        _.startsWith(it.$ref, `#/components/${componentName}`),
+      ),
     );
   }
 

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

@@ -4,6 +4,7 @@ const { MonoSchemaParser } = require('../mono-schema-parser');
 
 class DiscriminatorSchemaParser extends MonoSchemaParser {
   parse() {
+    const ts = this.config.Ts;
     const { discriminator, ...noDiscriminatorSchema } = this.schema;
 
     if (!discriminator.mapping) {
@@ -27,7 +28,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
       abstractSchemaStruct,
     });
 
-    const schemaContent = this.config.Ts.IntersectionType(
+    const schemaContent = ts.IntersectionType(
       [
         abstractSchemaStruct?.content,
         discriminatorSchemaStruct?.content,
@@ -40,7 +41,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
       $parsedSchema: true,
       schemaType: SCHEMA_TYPES.COMPLEX,
       type: SCHEMA_TYPES.PRIMITIVE,
-      typeIdentifier: this.config.Ts.Keyword.Type,
+      typeIdentifier: ts.Keyword.Type,
       name: this.typeName,
       description: this.schemaFormatters.formatDescription(
         this.schema.description,
@@ -50,6 +51,8 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
   }
 
   createDiscriminatorSchema = ({ skipMappingType, abstractSchemaStruct }) => {
+    const ts = this.config.Ts;
+
     const refPath = this.schemaComponentsMap.createRef([
       'components',
       'schemas',
@@ -71,34 +74,36 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
       });
 
     if (ableToCreateMappingType) {
-      mappingTypeName = this.schemaUtils.resolveTypeName(
-        `${abstractSchemaStruct.typeName} ${discriminator.propertyName}`,
-        {
-          suffixes: this.config.extractingOptions.discriminatorMappingSuffix,
-          resolver:
-            this.config.extractingOptions.discriminatorMappingNameResolver,
-        },
-      );
-      this.schemaParserFabric.createSchema({
-        linkedComponent: this.schemaComponentsMap.createComponent(
-          this.schemaComponentsMap.createRef([
-            'components',
-            'schemas',
-            mappingTypeName,
-          ]),
+      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',
+          }),
         ),
-        content: this.config.Ts.IntersectionType([
-          this.config.Ts.ObjectWrapper(
-            this.config.Ts.TypeField({
-              key: discriminator.propertyName,
-              value: 'Key',
-            }),
-          ),
-          'Type',
-        ]),
-        genericArgs: [{ name: 'Key' }, { name: 'Type' }],
-        internal: true,
+        'Type',
+      ]);
+
+      const component = this.schemaParserFabric.createParsedComponent({
+        typeName: generatedTypeName,
+        schema: {
+          type: 'object',
+          properties: {},
+          genericArgs: [{ name: 'Key' }, { name: 'Type' }],
+          internal: true,
+        },
       });
+
+      component.typeData.content = content;
+
+      mappingTypeName = this.typeNameFormatter.format(component.typeName);
     }
 
     /** returns (GenericType<"mapping_key", MappingType>) or ({ discriminatorProperty: "mapping_key" } & MappingType) */
@@ -112,18 +117,15 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
 
       const mappingUsageKey =
         mappingPropertySchemaEnumKeysMap[mappingKey] ||
-        this.config.Ts.StringValue(mappingKey);
+        ts.StringValue(mappingKey);
 
       if (ableToCreateMappingType) {
-        return this.config.Ts.TypeWithGeneric(mappingTypeName, [
-          mappingUsageKey,
-          content,
-        ]);
+        return ts.TypeWithGeneric(mappingTypeName, [mappingUsageKey, content]);
       } else {
-        return this.config.Ts.ExpressionGroup(
-          this.config.Ts.IntersectionType([
-            this.config.Ts.ObjectWrapper(
-              this.config.Ts.TypeField({
+        return ts.ExpressionGroup(
+          ts.IntersectionType([
+            ts.ObjectWrapper(
+              ts.TypeField({
                 key: discriminator.propertyName,
                 value: mappingUsageKey,
               }),
@@ -151,9 +153,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
 
     if (skipMappingType) return null;
 
-    const content = this.config.Ts.ExpressionGroup(
-      this.config.Ts.UnionType(mappingContents),
-    );
+    const content = ts.ExpressionGroup(ts.UnionType(mappingContents));
 
     return {
       content,
@@ -164,6 +164,8 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
     abstractSchemaStruct,
     discPropertyName,
   }) => {
+    const ts = this.config.Ts;
+
     let mappingPropertySchemaEnumKeysMap = {};
     let mappingPropertySchema = _.get(
       abstractSchemaStruct?.component?.rawTypeData,
@@ -183,7 +185,7 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
         (acc, key, index) => {
           const enumKey =
             mappingPropertySchema.rawTypeData.$parsed.content[index].key;
-          acc[key] = this.config.Ts.EnumUsageKey(
+          acc[key] = ts.EnumUsageKey(
             mappingPropertySchema.rawTypeData.$parsed.typeName,
             enumKey,
           );
@@ -284,12 +286,13 @@ class DiscriminatorSchemaParser extends MonoSchemaParser {
   };
 
   createComplexSchemaStruct = () => {
+    const ts = this.config.Ts;
     const complexType = this.schemaUtils.getComplexType(this.schema);
 
     if (complexType === SCHEMA_TYPES.COMPLEX_UNKNOWN) return null;
 
     return {
-      content: this.config.Ts.ExpressionGroup(
+      content: ts.ExpressionGroup(
         this.schemaParser._complexSchemaParsers[complexType](this.schema),
       ),
     };

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

@@ -1,7 +1,7 @@
 const { MonoSchemaParser } = require('../mono-schema-parser');
 const _ = require('lodash');
 
-// T1 | T2 | (T1 & T2)
+// T1 | T2
 class AnyOfSchemaParser extends MonoSchemaParser {
   parse() {
     const ignoreTypes = [this.config.Ts.Keyword.Any];
@@ -12,20 +12,13 @@ class AnyOfSchemaParser extends MonoSchemaParser {
         this.schemaPath,
       ),
     );
+
     const filtered = this.schemaUtils.filterSchemaContents(
       combined,
       (content) => !ignoreTypes.includes(content),
     );
 
-    const type = this.config.Ts.UnionType(
-      _.compact([
-        ...filtered,
-        filtered.length > 1 &&
-          this.config.Ts.ExpressionGroup(
-            this.config.Ts.IntersectionType(filtered),
-          ),
-      ]),
-    );
+    const type = this.config.Ts.UnionType(filtered);
 
     return this.schemaUtils.safeAddNullToType(this.schema, type);
   }

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/schema-parser/schema-parser.js

@@ -193,10 +193,9 @@ class SchemaParser {
         this.typeName = this.schemaUtils.getSchemaType(this.schema);
       }
 
-      /**
-       * swagger schemas fixes
-       * ---->
-       */
+      //#region swagger schemas fixes
+
+      // schema has items but don't have array type
       if (
         this.schema.items &&
         !Array.isArray(this.schema.items) &&
@@ -204,6 +203,7 @@ class SchemaParser {
       ) {
         this.schema.type = SCHEMA_TYPES.ARRAY;
       }
+      // schema is enum with one null value
       if (
         Array.isArray(this.schema.enum) &&
         this.schema.enum.length === 1 &&
@@ -212,9 +212,22 @@ class SchemaParser {
         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'
+      ) {
+        const schema = this.extractSchemaFromResponseStruct(this.schema);
+        const schemaParser = this.schemaParserFabric.createSchemaParser({
+          schema,
+          typeName: this.typeName,
+          schemaPath: this.schemaPath,
+        });
+        this.schema.$parsed = schemaParser.parseSchema();
+        return this.schema.$parsed;
+      }
+
+      //#endregion
 
       schemaType = this.schemaUtils.getInternalSchemaType(this.schema);
 
@@ -268,6 +281,21 @@ class SchemaParser {
     );
     return formattedSchema.content;
   };
+
+  extractSchemaFromResponseStruct = (responseStruct) => {
+    const { content, ...extras } = responseStruct;
+
+    const firstResponse = _.first(_.values(content));
+    const firstSchema = _.get(firstResponse, 'schema');
+
+    if (!firstSchema) return;
+
+    return {
+      ...extras,
+      ..._.omit(firstResponse, 'schema'),
+      ...firstSchema,
+    };
+  };
 }
 
 module.exports = {

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

@@ -248,24 +248,32 @@ class SchemaUtils {
       );
     }
 
-    const primitiveType = this.getSchemaPrimitiveType(schema);
-
-    if (primitiveType == null) return this.config.Ts.Keyword.Any;
-
     let resultType;
 
-    const typeAlias =
-      _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
-      _.get(this.config.primitiveTypes, [primitiveType, '$default']) ||
-      this.config.primitiveTypes[primitiveType];
-
-    if (_.isFunction(typeAlias)) {
-      resultType = typeAlias(schema, this);
+    if (this.isConstantSchema(schema)) {
+      resultType = this.formatJsValue(schema.const);
     } else {
-      resultType = typeAlias || primitiveType;
+      const primitiveType = this.getSchemaPrimitiveType(schema);
+
+      if (primitiveType == null) {
+        return this.config.Ts.Keyword.Any;
+      }
+
+      const typeAlias =
+        _.get(this.config.primitiveTypes, [primitiveType, schema.format]) ||
+        _.get(this.config.primitiveTypes, [primitiveType, '$default']) ||
+        this.config.primitiveTypes[primitiveType];
+
+      if (_.isFunction(typeAlias)) {
+        resultType = typeAlias(schema, this);
+      } else {
+        resultType = typeAlias || primitiveType;
+      }
     }
 
-    if (!resultType) return this.config.Ts.Keyword.Any;
+    if (!resultType) {
+      return this.config.Ts.Keyword.Any;
+    }
 
     return this.checkAndAddRequiredKeys(
       schema,
@@ -284,6 +292,31 @@ class SchemaUtils {
       ),
     );
   };
+
+  isConstantSchema(schema) {
+    return 'const' in schema;
+  }
+
+  formatJsValue = (value) => {
+    switch (typeof value) {
+      case 'string': {
+        return this.config.Ts.StringValue(value);
+      }
+      case 'boolean': {
+        return this.config.Ts.BooleanValue(value);
+      }
+      case 'number': {
+        return this.config.Ts.NumberValue(value);
+      }
+      default: {
+        if (value === null) {
+          return this.config.Ts.NullValue(value);
+        }
+
+        return this.config.Ts.Keyword.Any;
+      }
+    }
+  };
 }
 
 module.exports = {

package/src/schema-routes/schema-routes.js

@@ -1201,22 +1201,19 @@ class SchemaRoutes {
         routeGroups.outOfModule = this.sortRoutes(routeGroups.outOfModule);
       }
       if (routeGroups.combined) {
-        routeGroups.combined = this.sortRoutes(routeGroups.combined);
+        _.each(routeGroups.combined, (routeGroup) => {
+          routeGroup.routes = this.sortRoutes(routeGroup.routes);
+        });
       }
     }
 
     return routeGroups;
   };
 
-  sortRoutes = (routeInfo) => {
-    if (routeInfo) {
-      routeInfo.forEach((routeInfo) => {
-        routeInfo.routes.sort((routeA, routeB) =>
-          routeA.routeName.usage.localeCompare(routeB.routeName.usage),
-        );
-      });
-    }
-    return routeInfo;
+  sortRoutes = (routes) => {
+    return _.slice(routes).sort((routeA, routeB) =>
+      routeA.routeName.usage.localeCompare(routeB.routeName.usage),
+    );
   };
 }