Merge branch 'feature/extract-responses' into next

# Conflicts:
#	CHANGELOG.md

Author: js2me

CHANGELOG.md

@@ -1,6 +1,7 @@
 # next release  
 
-fix: problem with using `anyOf`    
+fix: problem with using `anyOf`  
+feat: `--extract-responses` (nodejs: `extractResponses`) option to extract all schemas from `/components/responses`    
 
 ## 13.0.0  
 

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:

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);

src/configuration.js

@@ -74,6 +74,7 @@ class CodeGenConfig {
   extractRequestBody = false;
   extractResponseBody = false;
   extractResponseError = false;
+  extractResponses = false;
   extractEnums = false;
   fileNames = {
     dataContracts: 'data-contracts',

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

src/schema-parser/schema-parser.js

@@ -193,17 +193,17 @@ 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) &&
         !this.schema.type
       ) {
         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 = {

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

tests/generate-extended.js

@@ -23,6 +23,9 @@ allSchemas.forEach(async ({ absolutePath, apiFileName, outputPath }) => {
   const input = absolutePath;
   const output = outputPath;
 
+  const typePrefix = 'IMySuperPrefix'
+  const typeSuffix = 'MySuperSuffix'
+
   await generateApiForTest({
     name: name,
     input: input,
@@ -36,25 +39,41 @@ allSchemas.forEach(async ({ absolutePath, apiFileName, outputPath }) => {
     extractEnums: true,
     extractRequestParams: true,
     extractResponseError: true,
-    typePrefix: "IMySuperPrefix",
-    typeSuffix: "MySuperSuffix",
+    extractResponses: true,
+    typePrefix: typePrefix,
+    typeSuffix: typeSuffix,
     sortTypes: true,
+    sortRoutes: true,
     debugExtras: ["generate-extended", apiFileName],
   }).then((result) => {
     result.configuration.modelTypes.forEach((modelType) => {
       if (modelType.name) {
-        if (modelType.name.startsWith("IMySuperPrefixIMySuperPrefix")) {
+        if (modelType.name.startsWith(`${typePrefix}${typePrefix}`)) {
+          throw new GenerateExtendedError(
+              `[${outputPath}][${apiFileName}] modelType has prefix/suffix duplicates - ${modelType.name}`,
+              output,
+              name,
+          );
+        }
+        if (!modelType.name.startsWith(typePrefix)) {
+          throw new GenerateExtendedError(
+              `[${outputPath}][${apiFileName}] modelType has not prefix/suffix - ${modelType.name}`,
+              output,
+              name,
+          );
+        }
+        if (modelType.name.endsWith(`${typeSuffix}${typeSuffix}`)) {
           throw new GenerateExtendedError(
-            `[${outputPath}][${apiFileName}] modelType has prefix/suffix duplicates - ${modelType.name}`,
-            output,
-            name,
+              `[${outputPath}][${apiFileName}] modelType has prefix/suffix duplicates - ${modelType.name}`,
+              output,
+              name,
           );
         }
-        if (!modelType.name.startsWith("IMySuperPrefix")) {
+        if (!modelType.name.endsWith(typeSuffix)) {
           throw new GenerateExtendedError(
-            `[${outputPath}][${apiFileName}] modelType has not prefix/suffix - ${modelType.name}`,
-            output,
-            name,
+              `[${outputPath}][${apiFileName}] modelType has not prefix/suffix - ${modelType.name}`,
+              output,
+              name,
           );
         }
       }