swagger-typescript-api 12.0.4 → 13.0.0

package/src/{schema-parser → schema-routes}/schema-routes.js

@@ -1,22 +1,24 @@
-const _ = require("lodash");
-const { generateId } = require("../util/id.js");
-const { SpecificArgNameResolver } = require("../util/name-resolver.js");
+const _ = require('lodash');
+const { generateId } = require('../util/id.js');
+const {
+  SpecificArgNameResolver,
+} = require('./util/specific-arg-name-resolver');
 const {
   DEFAULT_BODY_ARG_NAME,
   RESERVED_BODY_ARG_NAMES,
   RESERVED_HEADER_ARG_NAMES,
   RESERVED_PATH_ARG_NAMES,
   RESERVED_QUERY_ARG_NAMES,
-} = require("../constants.js");
-const { pascalCase } = require("../util/pascal-case");
+} = require('../constants.js');
+const { camelCase } = require('lodash');
 
 const CONTENT_KIND = {
-  JSON: "JSON",
-  URL_ENCODED: "URL_ENCODED",
-  FORM_DATA: "FORM_DATA",
-  IMAGE: "IMAGE",
-  OTHER: "OTHER",
-  TEXT: "TEXT",
+  JSON: 'JSON',
+  URL_ENCODED: 'URL_ENCODED',
+  FORM_DATA: 'FORM_DATA',
+  IMAGE: 'IMAGE',
+  OTHER: 'OTHER',
+  TEXT: 'TEXT',
 };
 
 class SchemaRoutes {
@@ -25,29 +27,29 @@ class SchemaRoutes {
    */
   config;
   /**
-   * @type {SchemaParser}
+   * @type {SchemaParserFabric}
    */
-  schemaParser;
+  schemaParserFabric;
   /**
    * @type {SchemaUtils}
    */
   schemaUtils;
   /**
-   * @type {TypeName}
+   * @type {TypeNameFormatter}
    */
-  typeName;
+  typeNameFormatter;
   /**
    * @type {SchemaComponentsMap}
    */
-  schemaComponentMap;
+  schemaComponentsMap;
   /**
    * @type {Logger}
    */
   logger;
   /**
-   * @type {Templates}
+   * @type {TemplatesWorker}
    */
-  templates;
+  templatesWorker;
 
   FORM_DATA_TYPES = [];
 
@@ -56,28 +58,38 @@ class SchemaRoutes {
   hasQueryRoutes = false;
   hasFormDataRoutes = false;
 
-  constructor(config, schemaParser, schemaComponentMap, logger, templates, typeName) {
+  constructor({
+    config,
+    schemaParserFabric,
+    schemaComponentsMap,
+    logger,
+    templatesWorker,
+    typeNameFormatter,
+  }) {
     this.config = config;
-    this.schemaParser = schemaParser;
-    this.schemaUtils = this.schemaParser.schemaUtils;
-    this.typeName = typeName;
-    this.schemaComponentMap = schemaComponentMap;
+    this.schemaParserFabric = schemaParserFabric;
+    this.schemaUtils = this.schemaParserFabric.schemaUtils;
+    this.typeNameFormatter = typeNameFormatter;
+    this.schemaComponentsMap = schemaComponentsMap;
     this.logger = logger;
-    this.templates = templates;
+    this.templatesWorker = templatesWorker;
 
     this.FORM_DATA_TYPES = _.uniq([
-      this.schemaParser.getSchemaType({ type: "string", format: "file" }),
-      this.schemaParser.getSchemaType({ type: "string", format: "binary" }),
+      this.schemaUtils.getSchemaType({ type: 'string', format: 'file' }),
+      this.schemaUtils.getSchemaType({ type: 'string', format: 'binary' }),
     ]);
   }
 
   createRequestsMap = (routeInfoByMethodsMap) => {
-    const parameters = _.get(routeInfoByMethodsMap, "parameters");
+    const parameters = _.get(routeInfoByMethodsMap, 'parameters');
 
     return _.reduce(
       routeInfoByMethodsMap,
       (acc, requestInfo, method) => {
-        if (_.startsWith(method, "x-") || ["parameters", "$ref"].includes(method)) {
+        if (
+          _.startsWith(method, 'x-') ||
+          ['parameters', '$ref'].includes(method)
+        ) {
           return acc;
         }
 
@@ -93,34 +105,36 @@ class SchemaRoutes {
   };
 
   parseRouteName = (originalRouteName) => {
-    const routeName = this.config.hooks.onPreBuildRoutePath(originalRouteName) || originalRouteName;
+    const routeName =
+      this.config.hooks.onPreBuildRoutePath(originalRouteName) ||
+      originalRouteName;
 
-    const pathParamMatches = (routeName || "").match(
-      /({(([a-zA-Z]-?_?\.?){1,})([0-9]{1,})?})|(:(([a-zA-Z]-?_?\.?){1,})([0-9]{1,})?:?)/g,
+    const pathParamMatches = (routeName || '').match(
+      /({(([A-z]){1}([a-zA-Z0-9]-?_?\.?)+)([0-9]+)?})|(:(([A-z]){1}([a-zA-Z0-9]-?_?\.?)+)([0-9]+)?:?)/g,
     );
 
     // used in case when path parameters is not declared in requestInfo.parameters ("in": "path")
     const pathParams = _.reduce(
       pathParamMatches,
       (pathParams, match) => {
-        const paramName = _.replace(match, /\{|\}|\:/g, "");
+        const paramName = _.replace(match, /\{|\}|:/g, '');
 
         if (!paramName) return pathParams;
 
-        if (_.includes(paramName, "-")) {
-          this.logger.warn("wrong path param name", paramName);
+        if (_.includes(paramName, '-')) {
+          this.logger.warn('wrong path param name', paramName);
         }
 
         pathParams.push({
           $match: match,
           name: _.camelCase(paramName),
           required: true,
-          type: "string",
-          description: "",
+          type: 'string',
+          description: '',
           schema: {
-            type: "string",
+            type: 'string',
           },
-          in: "path",
+          in: 'path',
         });
 
         return pathParams;
@@ -131,10 +145,16 @@ class SchemaRoutes {
     let fixedRoute = _.reduce(
       pathParams,
       (fixedRoute, pathParam, i, arr) => {
-        const insertion = this.config.hooks.onInsertPathParam(pathParam.name, i, arr, fixedRoute) || pathParam.name;
+        const insertion =
+          this.config.hooks.onInsertPathParam(
+            pathParam.name,
+            i,
+            arr,
+            fixedRoute,
+          ) || pathParam.name;
         return _.replace(fixedRoute, pathParam.$match, `\${${insertion}}`);
       },
-      routeName || "",
+      routeName || '',
     );
 
     const queryParamMatches = fixedRoute.match(/(\{\?.*\})/g);
@@ -142,35 +162,35 @@ class SchemaRoutes {
 
     if (queryParamMatches && queryParamMatches.length) {
       queryParamMatches.forEach((match) => {
-        fixedRoute = fixedRoute.replace(match, "");
+        fixedRoute = fixedRoute.replace(match, '');
       });
 
       _.uniq(
         queryParamMatches
-          .join(",")
-          .replace(/(\{\?)|(\})|\s/g, "")
-          .split(","),
+          .join(',')
+          .replace(/(\{\?)|(\})|\s/g, '')
+          .split(','),
       ).forEach((paramName) => {
-        if (_.includes(paramName, "-")) {
-          this.logger.warn("wrong query param name", paramName);
+        if (_.includes(paramName, '-')) {
+          this.logger.warn('wrong query param name', paramName);
         }
 
         queryParams.push({
           $match: paramName,
           name: _.camelCase(paramName),
           required: true,
-          type: "string",
-          description: "",
+          type: 'string',
+          description: '',
           schema: {
-            type: "string",
+            type: 'string',
           },
-          in: "query",
+          in: 'query',
         });
       });
     }
 
     const result = {
-      originalRoute: originalRouteName || "",
+      originalRoute: originalRouteName || '',
       route: fixedRoute,
       pathParams,
       queryParams,
@@ -179,7 +199,11 @@ class SchemaRoutes {
     return this.config.hooks.onBuildRoutePath(result) || result;
   };
 
-  getRouteParams = (routeInfo, pathParamsFromRouteName, queryParamsFromRouteName) => {
+  getRouteParams = (
+    routeInfo,
+    pathParamsFromRouteName,
+    queryParamsFromRouteName,
+  ) => {
     const { parameters } = routeInfo;
 
     const routeParams = {
@@ -192,10 +216,15 @@ class SchemaRoutes {
     };
 
     _.each(parameters, (parameter) => {
-      const refTypeInfo = this.schemaParser.schemaUtils.getSchemaRefType(parameter);
+      const refTypeInfo =
+        this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
       let routeParam = null;
 
-      if (refTypeInfo && refTypeInfo.rawTypeData.in && refTypeInfo.rawTypeData) {
+      if (
+        refTypeInfo &&
+        refTypeInfo.rawTypeData.in &&
+        refTypeInfo.rawTypeData
+      ) {
         if (!routeParams[refTypeInfo.rawTypeData.in]) {
           routeParams[refTypeInfo.rawTypeData.in] = [];
         }
@@ -217,7 +246,7 @@ class SchemaRoutes {
         };
       }
 
-      if (routeParam.in === "path") {
+      if (routeParam.in === 'path') {
         if (!routeParam.name) return;
 
         routeParam.name = _.camelCase(routeParam.name);
@@ -230,7 +259,10 @@ class SchemaRoutes {
 
     // used in case when path parameters is not declared in requestInfo.parameters ("in": "path")
     _.each(pathParamsFromRouteName, (pathParam) => {
-      const alreadyExist = _.some(routeParams.path, (parameter) => parameter.name === pathParam.name);
+      const alreadyExist = _.some(
+        routeParams.path,
+        (parameter) => parameter.name === pathParam.name,
+      );
 
       if (!alreadyExist) {
         routeParams.path.push(pathParam);
@@ -238,7 +270,10 @@ class SchemaRoutes {
     });
     // used in case when path parameters is not declared in requestInfo.parameters ("in": "path")
     _.each(queryParamsFromRouteName, (queryParam) => {
-      const alreadyExist = _.some(routeParams.query, (parameter) => parameter.name === queryParam.name);
+      const alreadyExist = _.some(
+        routeParams.query,
+        (parameter) => parameter.name === queryParam.name,
+      );
 
       if (!alreadyExist) {
         routeParams.query.push(queryParam);
@@ -252,31 +287,43 @@ class SchemaRoutes {
     _.uniq(
       _.compact([
         ...(extraContentTypes || []),
-        ..._.flatten(_.map(requestInfo, (requestInfoData) => requestInfoData && _.keys(requestInfoData.content))),
+        ..._.flatten(
+          _.map(
+            requestInfo,
+            (requestInfoData) =>
+              requestInfoData && _.keys(requestInfoData.content),
+          ),
+        ),
       ]),
     );
 
   getContentKind = (contentTypes) => {
     if (
-      _.some(contentTypes, (contentType) => _.startsWith(contentType, "application/json")) ||
-      _.some(contentTypes, (contentType) => _.endsWith(contentType, "+json"))
+      _.some(contentTypes, (contentType) =>
+        _.startsWith(contentType, 'application/json'),
+      ) ||
+      _.some(contentTypes, (contentType) => _.endsWith(contentType, '+json'))
     ) {
       return CONTENT_KIND.JSON;
     }
 
-    if (contentTypes.includes("application/x-www-form-urlencoded")) {
+    if (contentTypes.includes('application/x-www-form-urlencoded')) {
       return CONTENT_KIND.URL_ENCODED;
     }
 
-    if (contentTypes.includes("multipart/form-data")) {
+    if (contentTypes.includes('multipart/form-data')) {
       return CONTENT_KIND.FORM_DATA;
     }
 
-    if (_.some(contentTypes, (contentType) => _.includes(contentType, "image/"))) {
+    if (
+      _.some(contentTypes, (contentType) => _.includes(contentType, 'image/'))
+    ) {
       return CONTENT_KIND.IMAGE;
     }
 
-    if (_.some(contentTypes, (contentType) => _.startsWith(contentType, "text/"))) {
+    if (
+      _.some(contentTypes, (contentType) => _.startsWith(contentType, 'text/'))
+    ) {
       return CONTENT_KIND.TEXT;
     }
 
@@ -284,12 +331,13 @@ class SchemaRoutes {
   };
 
   isSuccessStatus = (status) =>
-    (this.config.defaultResponseAsSuccess && status === "default") ||
-    (+status >= this.config.successResponseStatusRange[0] && +status <= this.config.successResponseStatusRange[1]) ||
-    status === "2xx";
+    (this.config.defaultResponseAsSuccess && status === 'default') ||
+    (+status >= this.config.successResponseStatusRange[0] &&
+      +status <= this.config.successResponseStatusRange[1]) ||
+    status === '2xx';
 
   getSchemaFromRequestType = (requestInfo) => {
-    const content = _.get(requestInfo, "content");
+    const content = _.get(requestInfo, 'content');
 
     if (!content) return null;
 
@@ -308,22 +356,38 @@ class SchemaRoutes {
     return null;
   };
 
-  getTypeFromRequestInfo = ({ requestInfo, parsedSchemas, operationId, defaultType, typeName }) => {
+  getTypeFromRequestInfo = ({
+    requestInfo,
+    parsedSchemas,
+    operationId,
+    defaultType,
+    typeName,
+  }) => {
     // TODO: make more flexible pick schema without content type
     const schema = this.getSchemaFromRequestType(requestInfo);
-    const refTypeInfo = this.schemaParser.schemaUtils.getSchemaRefType(requestInfo);
+    const refTypeInfo =
+      this.schemaParserFabric.schemaUtils.getSchemaRefType(requestInfo);
 
     if (schema) {
-      const content = this.schemaParser.getInlineParseContent(schema, typeName);
+      const content = this.schemaParserFabric.getInlineParseContent(
+        schema,
+        typeName,
+        [operationId],
+      );
       const foundedSchemaByName = _.find(
         parsedSchemas,
-        (parsedSchema) => this.typeName.format(parsedSchema.name) === content,
+        (parsedSchema) =>
+          this.typeNameFormatter.format(parsedSchema.name) === content,
+      );
+      const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) =>
+        _.isEqual(parsedSchema.content, content),
       );
-      const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) => _.isEqual(parsedSchema.content, content));
 
       const foundSchema = foundedSchemaByName || foundSchemaByContent;
 
-      return foundSchema ? this.typeName.format(foundSchema.name) : content;
+      return foundSchema
+        ? this.typeNameFormatter.format(foundSchema.name)
+        : content;
     }
 
     if (refTypeInfo) {
@@ -331,29 +395,45 @@ class SchemaRoutes {
       // const foundedSchemaByName = _.find(parsedSchemas, ({ name }) => name === refType || name === refTypeWithoutOpId)
 
       // TODO:HACK fix problem of swagger2opeanpi
-      const typeNameWithoutOpId = _.replace(refTypeInfo.typeName, operationId, "");
-      if (_.find(parsedSchemas, (schema) => schema.name === typeNameWithoutOpId)) {
-        return this.typeName.format(typeNameWithoutOpId);
+      const typeNameWithoutOpId = _.replace(
+        refTypeInfo.typeName,
+        operationId,
+        '',
+      );
+      if (
+        _.find(parsedSchemas, (schema) => schema.name === typeNameWithoutOpId)
+      ) {
+        return this.typeNameFormatter.format(typeNameWithoutOpId);
       }
 
       switch (refTypeInfo.componentName) {
-        case "schemas":
-          return this.typeName.format(refTypeInfo.typeName);
-        case "responses":
-        case "requestBodies":
-          return this.schemaParser.getInlineParseContent(
+        case 'schemas':
+          return this.typeNameFormatter.format(refTypeInfo.typeName);
+        case 'responses':
+        case 'requestBodies':
+          return this.schemaParserFabric.getInlineParseContent(
             this.getSchemaFromRequestType(refTypeInfo.rawTypeData),
             refTypeInfo.typeName || null,
+            [operationId],
           );
         default:
-          return this.schemaParser.getInlineParseContent(refTypeInfo.rawTypeData, refTypeInfo.typeName || null);
+          return this.schemaParserFabric.getInlineParseContent(
+            refTypeInfo.rawTypeData,
+            refTypeInfo.typeName || null,
+            [operationId],
+          );
       }
     }
 
     return defaultType || this.config.Ts.Keyword.Any;
   };
 
-  getRequestInfoTypes = ({ requestInfos, parsedSchemas, operationId, defaultType }) =>
+  getRequestInfoTypes = ({
+    requestInfos,
+    parsedSchemas,
+    operationId,
+    defaultType,
+  }) =>
     _.reduce(
       requestInfos,
       (acc, requestInfo, status) => {
@@ -365,7 +445,7 @@ class SchemaRoutes {
             ...(requestInfo || {}),
             contentTypes: contentTypes,
             contentKind: this.getContentKind(contentTypes),
-            type: this.schemaParser.schemaUtils.safeAddNullToType(
+            type: this.schemaParserFabric.schemaUtils.safeAddNullToType(
               requestInfo,
               this.getTypeFromRequestInfo({
                 requestInfo,
@@ -374,7 +454,11 @@ class SchemaRoutes {
                 defaultType,
               }),
             ),
-            description: this.schemaParser.schemaFormatters.formatDescription(requestInfo.description || "", true),
+            description:
+              this.schemaParserFabric.schemaFormatters.formatDescription(
+                requestInfo.description || '',
+                true,
+              ),
             status: _.isNaN(+status) ? status : +status,
             isSuccess: this.isSuccessStatus(status),
           },
@@ -386,7 +470,10 @@ class SchemaRoutes {
   getResponseBodyInfo = (routeInfo, parsedSchemas) => {
     const { produces, operationId, responses } = routeInfo;
 
-    const contentTypes = this.getContentTypes(responses, [...(produces || []), routeInfo["x-accepts"]]);
+    const contentTypes = this.getContentTypes(responses, [
+      ...(produces || []),
+      routeInfo['x-accepts'],
+    ]);
 
     const responseInfos = this.getRequestInfoTypes({
       requestInfos: responses,
@@ -395,23 +482,26 @@ class SchemaRoutes {
       defaultType: this.config.defaultResponseType,
     });
 
-    const successResponse = responseInfos.find((response) => response.isSuccess);
+    const successResponse = responseInfos.find(
+      (response) => response.isSuccess,
+    );
     const errorResponses = responseInfos.filter(
-      (response) => !response.isSuccess && response.type !== this.config.Ts.Keyword.Any,
+      (response) =>
+        !response.isSuccess && response.type !== this.config.Ts.Keyword.Any,
     );
 
     const handleResponseHeaders = (src) => {
       if (!src) {
-        return "headers: {},";
+        return 'headers: {},';
       }
       const headerTypes = Object.fromEntries(
         Object.entries(src).map(([k, v]) => {
-          return [k, this.schemaParser.getSchemaType(v)];
+          return [k, this.schemaUtils.getSchemaType(v)];
         }),
       );
       const r = `headers: { ${Object.entries(headerTypes)
         .map(([k, v]) => `"${k}": ${v}`)
-        .join(",")} },`;
+        .join(',')} },`;
       return r;
     };
 
@@ -420,20 +510,27 @@ class SchemaRoutes {
       responses: responseInfos,
       success: {
         schema: successResponse,
-        type: (successResponse && successResponse.type) || this.config.Ts.Keyword.Any,
+        type:
+          (successResponse && successResponse.type) ||
+          this.config.Ts.Keyword.Any,
       },
       error: {
         schemas: errorResponses,
-        type: this.config.Ts.UnionType(errorResponses.map((response) => response.type)) || this.config.Ts.Keyword.Any,
+        type:
+          this.config.Ts.UnionType(
+            errorResponses.map((response) => response.type),
+          ) || this.config.Ts.Keyword.Any,
       },
       full: {
         types:
           this.config.Ts.UnionType(
             responseInfos.map(
               (response) => `{
-      data: ${response.type}, status: ${response.status}, statusCode: ${response.status}, statusText: "${
-                response.description
-              }", ${handleResponseHeaders(response.headers)} config: {} }`,
+      data: ${response.type}, status: ${response.status}, statusCode: ${
+        response.status
+      }, statusText: "${response.description}", ${handleResponseHeaders(
+        response.headers,
+      )} config: {} }`,
             ),
           ) || this.config.Ts.Keyword.Any,
       },
@@ -446,20 +543,28 @@ class SchemaRoutes {
       (objectSchema, schemaPart) => {
         if (!schemaPart || !schemaPart.name) return objectSchema;
 
+        let usageName = `${schemaPart.name}`;
+
+        if (usageName.includes('.')) {
+          usageName = camelCase(usageName);
+        }
+
         return {
           ...objectSchema,
           properties: {
             ...objectSchema.properties,
-            [schemaPart.name]: {
+            [usageName]: {
               ...schemaPart,
               ...(schemaPart.schema || {}),
+              $origName: schemaPart.name,
+              name: usageName,
             },
           },
         };
       },
       {
         properties: {},
-        type: "object",
+        type: 'object',
       },
     );
   };
@@ -467,31 +572,41 @@ class SchemaRoutes {
   getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) => {
     const { requestBody, consumes, requestBodyName, operationId } = routeInfo;
     let schema = null;
-    let type = null;
+    let content = null;
 
-    const contentTypes = this.getContentTypes([requestBody], [...(consumes || []), routeInfo["x-contentType"]]);
+    const contentTypes = this.getContentTypes(
+      [requestBody],
+      [...(consumes || []), routeInfo['x-contentType']],
+    );
     let contentKind = this.getContentKind(contentTypes);
 
     let typeName = null;
 
     if (this.config.extractRequestBody) {
-      typeName = this.schemaUtils.resolveTypeName(
-        routeName.usage,
-        this.config.extractingOptions.requestBodySuffix,
-        this.config.extractingOptions.requestBodyNameResolver,
-      );
+      typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
+        suffixes: this.config.extractingOptions.requestBodySuffix,
+        resolver: this.config.extractingOptions.requestBodyNameResolver,
+      });
     }
 
     if (routeParams.formData.length) {
       contentKind = CONTENT_KIND.FORM_DATA;
       schema = this.convertRouteParamsIntoObject(routeParams.formData);
-      type = this.schemaParser.getInlineParseContent(schema, typeName);
+      content = this.schemaParserFabric.getInlineParseContent(
+        schema,
+        typeName,
+        [operationId],
+      );
     } else if (contentKind === CONTENT_KIND.FORM_DATA) {
       schema = this.getSchemaFromRequestType(requestBody);
-      type = this.schemaParser.getInlineParseContent(schema, typeName);
+      content = this.schemaParserFabric.getInlineParseContent(
+        schema,
+        typeName,
+        [operationId],
+      );
     } else if (requestBody) {
       schema = this.getSchemaFromRequestType(requestBody);
-      type = this.schemaParser.schemaUtils.safeAddNullToType(
+      content = this.schemaParserFabric.schemaUtils.safeAddNullToType(
         requestBody,
         this.getTypeFromRequestInfo({
           requestInfo: requestBody,
@@ -504,23 +619,38 @@ class SchemaRoutes {
       // TODO: Refactor that.
       // It needed for cases when swagger schema is not declared request body type as form data
       // but request body data type contains form data types like File
-      if (this.FORM_DATA_TYPES.some((dataType) => _.includes(type, `: ${dataType}`))) {
+      if (
+        this.FORM_DATA_TYPES.some((dataType) =>
+          _.includes(content, `: ${dataType}`),
+        )
+      ) {
         contentKind = CONTENT_KIND.FORM_DATA;
       }
     }
 
     if (schema && !schema.$ref && this.config.extractRequestBody) {
-      schema = this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
-      type = this.schemaParser.getInlineParseContent(schema);
+      schema = this.schemaParserFabric.createParsedComponent({
+        schema,
+        typeName,
+        schemaPath: [operationId],
+      });
+      content = this.schemaParserFabric.getInlineParseContent({
+        $ref: schema.$ref,
+      });
     }
 
     return {
-      paramName: requestBodyName || (requestBody && requestBody.name) || DEFAULT_BODY_ARG_NAME,
+      paramName:
+        requestBodyName ||
+        (requestBody && requestBody.name) ||
+        DEFAULT_BODY_ARG_NAME,
       contentTypes,
       contentKind,
       schema,
-      type,
-      required: requestBody && (typeof requestBody.required === "undefined" || !!requestBody.required),
+      type: content,
+      required:
+        requestBody &&
+        (typeof requestBody.required === 'undefined' || !!requestBody.required),
     };
   };
 
@@ -539,7 +669,7 @@ class SchemaRoutes {
         if (pathArgSchema.name) {
           acc[pathArgSchema.name] = {
             ...pathArgSchema,
-            in: "path",
+            in: 'path',
           };
         }
 
@@ -549,12 +679,12 @@ class SchemaRoutes {
     );
 
     const fixedQueryParams = _.reduce(
-      _.get(queryObjectSchema, "properties", {}),
+      _.get(queryObjectSchema, 'properties', {}),
       (acc, property, name) => {
         if (name && _.isObject(property)) {
           acc[name] = {
             ...property,
-            in: "query",
+            in: 'query',
           };
         }
 
@@ -576,34 +706,50 @@ class SchemaRoutes {
     if (fixedSchema) return fixedSchema;
 
     if (extractRequestParams) {
-      const typeName = this.schemaUtils.resolveTypeName(
+      const generatedTypeName = this.schemaUtils.resolveTypeName(
         routeName.usage,
-        this.config.extractingOptions.requestParamsSuffix,
-        this.config.extractingOptions.requestParamsNameResolver,
+        {
+          suffixes: this.config.extractingOptions.requestParamsSuffix,
+          resolver: this.config.extractingOptions.requestParamsNameResolver,
+        },
       );
 
-      return this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
+      return this.schemaParserFabric.createParsedComponent({
+        typeName: generatedTypeName,
+        schema: schema,
+      });
     }
 
     return schema;
   };
 
   extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
-    if (responseBodyInfo.responses.length && responseBodyInfo.success && responseBodyInfo.success.schema) {
-      const typeName = this.schemaUtils.resolveTypeName(
-        routeName.usage,
-        this.config.extractingOptions.responseBodySuffix,
-        this.config.extractingOptions.responseBodyNameResolver,
-      );
+    if (
+      responseBodyInfo.responses.length &&
+      responseBodyInfo.success &&
+      responseBodyInfo.success.schema
+    ) {
+      const typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
+        suffixes: this.config.extractingOptions.responseBodySuffix,
+        resolver: this.config.extractingOptions.responseBodyNameResolver,
+      });
 
-      const idx = responseBodyInfo.responses.indexOf(responseBodyInfo.success.schema);
+      const idx = responseBodyInfo.responses.indexOf(
+        responseBodyInfo.success.schema,
+      );
 
       let successResponse = responseBodyInfo.success;
 
       if (successResponse.schema && !successResponse.schema.$ref) {
         const schema = this.getSchemaFromRequestType(successResponse.schema);
-        successResponse.schema = this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
-        successResponse.type = this.schemaParser.getInlineParseContent(successResponse.schema);
+        successResponse.schema = this.schemaParserFabric.createParsedComponent({
+          schema,
+          typeName,
+          schemaPath: [routeInfo.operationId],
+        });
+        successResponse.type = this.schemaParserFabric.getInlineParseContent({
+          $ref: successResponse.schema.$ref,
+        });
 
         if (idx > -1) {
           _.assign(responseBodyInfo.responses[idx], {
@@ -616,31 +762,45 @@ class SchemaRoutes {
   };
 
   extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
-    if (responseBodyInfo.responses.length && responseBodyInfo.error.schemas && responseBodyInfo.error.schemas.length) {
-      const typeName = this.schemaUtils.resolveTypeName(
-        routeName.usage,
-        this.config.extractingOptions.responseErrorSuffix,
-        this.config.extractingOptions.responseErrorNameResolver,
-      );
+    if (
+      responseBodyInfo.responses.length &&
+      responseBodyInfo.error.schemas &&
+      responseBodyInfo.error.schemas.length
+    ) {
+      const typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
+        suffixes: this.config.extractingOptions.responseErrorSuffix,
+        resolver: this.config.extractingOptions.responseErrorNameResolver,
+      });
 
-      const errorSchemas = responseBodyInfo.error.schemas.map(this.getSchemaFromRequestType).filter(Boolean);
+      const errorSchemas = responseBodyInfo.error.schemas
+        .map(this.getSchemaFromRequestType)
+        .filter(Boolean);
 
       if (!errorSchemas.length) return;
 
-      const schema = this.schemaParser.parseSchema({
-        oneOf: errorSchemas,
-        title: errorSchemas
-          .map((schema) => schema.title)
-          .filter(Boolean)
-          .join(" "),
-        description: errorSchemas
-          .map((schema) => schema.description)
-          .filter(Boolean)
-          .join("\n"),
-      });
-      const component = this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
+      const schema = this.schemaParserFabric.parseSchema(
+        {
+          oneOf: errorSchemas,
+          title: errorSchemas
+            .map((schema) => schema.title)
+            .filter(Boolean)
+            .join(' '),
+          description: errorSchemas
+            .map((schema) => schema.description)
+            .filter(Boolean)
+            .join('\n'),
+        },
+        null,
+        [routeInfo.operationId],
+      );
+      const component = this.schemaComponentsMap.createComponent(
+        this.schemaComponentsMap.createRef(['components', 'schemas', typeName]),
+        { ...schema },
+      );
       responseBodyInfo.error.schemas = [component];
-      responseBodyInfo.error.type = this.typeName.format(component.typeName);
+      responseBodyInfo.error.type = this.typeNameFormatter.format(
+        component.typeName,
+      );
     }
   };
 
@@ -649,16 +809,26 @@ class SchemaRoutes {
     const { routeNameDuplicatesMap, templatesToRender } = this.config;
     const routeNameTemplate = templatesToRender.routeName;
 
-    const routeNameFromTemplate = this.templates.renderTemplate(routeNameTemplate, {
-      routeInfo: rawRouteInfo,
-    });
+    const routeNameFromTemplate = this.templatesWorker.renderTemplate(
+      routeNameTemplate,
+      {
+        routeInfo: rawRouteInfo,
+      },
+    );
 
-    const routeName = this.config.hooks.onFormatRouteName(rawRouteInfo, routeNameFromTemplate) || routeNameFromTemplate;
+    const routeName =
+      this.config.hooks.onFormatRouteName(
+        rawRouteInfo,
+        routeNameFromTemplate,
+      ) || routeNameFromTemplate;
 
     const duplicateIdentifier = `${moduleName}|${routeName}`;
 
     if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
-      routeNameDuplicatesMap.set(duplicateIdentifier, routeNameDuplicatesMap.get(duplicateIdentifier) + 1);
+      routeNameDuplicatesMap.set(
+        duplicateIdentifier,
+        routeNameDuplicatesMap.get(duplicateIdentifier) + 1,
+      );
 
       this.logger.warn(
         `Module "${moduleName}" already has method "${routeName}()"`,
@@ -673,26 +843,38 @@ class SchemaRoutes {
     const duplicates = routeNameDuplicatesMap.get(duplicateIdentifier);
 
     const routeNameInfo = {
-      usage: routeName + (duplicates > 1 ? duplicates : ""),
+      usage: routeName + (duplicates > 1 ? duplicates : ''),
       original: routeName,
       duplicate: duplicates > 1,
     };
 
-    return this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) || routeNameInfo;
+    return (
+      this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) ||
+      routeNameInfo
+    );
   };
 
-  parseRouteInfo = (rawRouteName, routeInfo, method, usageSchema, parsedSchemas) => {
+  parseRouteInfo = (
+    rawRouteName,
+    routeInfo,
+    method,
+    usageSchema,
+    parsedSchemas,
+  ) => {
     const { security: globalSecurity } = usageSchema;
-    const { moduleNameIndex, moduleNameFirstTag, extractRequestParams } = this.config;
+    const { moduleNameIndex, moduleNameFirstTag, extractRequestParams } =
+      this.config;
     const {
       operationId,
       requestBody,
       security,
+      // eslint-disable-next-line no-unused-vars
       parameters,
       summary,
       description,
       tags,
       responses,
+      // eslint-disable-next-line no-unused-vars
       requestBodyName,
       produces,
       consumes,
@@ -709,13 +891,17 @@ class SchemaRoutes {
     const moduleName =
       moduleNameFirstTag && firstTag
         ? _.camelCase(firstTag)
-        : _.camelCase(_.compact(_.split(route, "/"))[moduleNameIndex]);
+        : _.camelCase(_.compact(_.split(route, '/'))[moduleNameIndex]);
     let hasSecurity = !!(globalSecurity && globalSecurity.length);
     if (security) {
       hasSecurity = security.length > 0;
     }
 
-    const routeParams = this.getRouteParams(routeInfo, pathParamsFromRouteName, queryParamsFromRouteName);
+    const routeParams = this.getRouteParams(
+      routeInfo,
+      pathParamsFromRouteName,
+      queryParamsFromRouteName,
+    );
 
     const pathArgs = routeParams.path.map((pathArgSchema) => ({
       name: pathArgSchema.name,
@@ -745,13 +931,24 @@ class SchemaRoutes {
       consumes,
     };
 
-    const queryObjectSchema = this.convertRouteParamsIntoObject(routeParams.query);
-    const pathObjectSchema = this.convertRouteParamsIntoObject(routeParams.path);
-    const headersObjectSchema = this.convertRouteParamsIntoObject(routeParams.header);
+    const queryObjectSchema = this.convertRouteParamsIntoObject(
+      routeParams.query,
+    );
+    const pathObjectSchema = this.convertRouteParamsIntoObject(
+      routeParams.path,
+    );
+    const headersObjectSchema = this.convertRouteParamsIntoObject(
+      routeParams.header,
+    );
 
     const routeName = this.getRouteName(rawRouteInfo);
 
-    const requestBodyInfo = this.getRequestBodyInfo(routeInfo, routeParams, parsedSchemas, routeName);
+    const requestBodyInfo = this.getRequestBodyInfo(
+      routeInfo,
+      routeParams,
+      parsedSchemas,
+      routeName,
+    );
 
     const requestParamsSchema = this.createRequestParamsSchema({
       queryParams: routeParams.query,
@@ -762,42 +959,68 @@ class SchemaRoutes {
     });
 
     if (this.config.extractResponseBody) {
-      this.extractResponseBodyIfItNeeded(routeInfo, responseBodyInfo, routeName);
+      this.extractResponseBodyIfItNeeded(
+        routeInfo,
+        responseBodyInfo,
+        routeName,
+      );
     }
     if (this.config.extractResponseError) {
-      this.extractResponseErrorIfItNeeded(routeInfo, responseBodyInfo, routeName);
+      this.extractResponseErrorIfItNeeded(
+        routeInfo,
+        responseBodyInfo,
+        routeName,
+      );
     }
 
-    const typeName = this.schemaUtils.resolveTypeName(
-      routeName.usage,
-      this.config.extractingOptions.requestParamsSuffix,
-      this.config.extractingOptions.requestParamsNameResolver,
-      false,
-    );
+    const typeName = this.schemaUtils.resolveTypeName(routeName.usage, {
+      suffixes: this.config.extractingOptions.requestParamsSuffix,
+      resolver: this.config.extractingOptions.requestParamsNameResolver,
+      shouldReserve: false,
+    });
 
     const queryType = routeParams.query.length
-      ? this.schemaParser.getInlineParseContent(queryObjectSchema, typeName)
+      ? this.schemaParserFabric.getInlineParseContent(queryObjectSchema, null, [
+          typeName,
+        ])
       : null;
     const pathType = routeParams.path.length
-      ? this.schemaParser.getInlineParseContent(pathObjectSchema, typeName)
+      ? this.schemaParserFabric.getInlineParseContent(pathObjectSchema, null, [
+          typeName,
+        ])
       : null;
     const headersType = routeParams.header.length
-      ? this.schemaParser.getInlineParseContent(headersObjectSchema, typeName)
+      ? this.schemaParserFabric.getInlineParseContent(
+          headersObjectSchema,
+          null,
+          [typeName],
+        )
       : null;
 
-    const nameResolver = new SpecificArgNameResolver(this.logger, pathArgsNames);
+    const nameResolver = new SpecificArgNameResolver(
+      this.config,
+      this.logger,
+      pathArgsNames,
+    );
 
     const specificArgs = {
       query: queryType
         ? {
             name: nameResolver.resolve(RESERVED_QUERY_ARG_NAMES),
-            optional: this.schemaParser.parseSchema(queryObjectSchema).allFieldsAreOptional,
+            optional: this.schemaParserFabric.parseSchema(
+              queryObjectSchema,
+              null,
+              [routeName.usage],
+            ).allFieldsAreOptional,
             type: queryType,
           }
         : void 0,
       body: requestBodyInfo.type
         ? {
-            name: nameResolver.resolve([requestBodyInfo.paramName, ...RESERVED_BODY_ARG_NAMES]),
+            name: nameResolver.resolve([
+              requestBodyInfo.paramName,
+              ...RESERVED_BODY_ARG_NAMES,
+            ]),
             optional: !requestBodyInfo.required,
             type: requestBodyInfo.type,
           }
@@ -805,26 +1028,38 @@ class SchemaRoutes {
       pathParams: pathType
         ? {
             name: nameResolver.resolve(RESERVED_PATH_ARG_NAMES),
-            optional: this.schemaParser.parseSchema(pathObjectSchema).allFieldsAreOptional,
+            optional: this.schemaParserFabric.parseSchema(
+              pathObjectSchema,
+              null,
+              [routeName.usage],
+            ).allFieldsAreOptional,
             type: pathType,
           }
         : void 0,
       headers: headersType
         ? {
             name: nameResolver.resolve(RESERVED_HEADER_ARG_NAMES),
-            optional: this.schemaParser.parseSchema(headersObjectSchema).allFieldsAreOptional,
+            optional: this.schemaParserFabric.parseSchema(
+              headersObjectSchema,
+              null,
+              [routeName.usage],
+            ).allFieldsAreOptional,
             type: headersType,
           }
         : void 0,
     };
 
     pathArgs.forEach((pathArg, i) => {
-      pathArg.type = this.schemaParser.getInlineParseContent(routeParams.path[i].schema, typeName);
+      pathArg.type = this.schemaParserFabric.getInlineParseContent(
+        routeParams.path[i].schema,
+        null,
+        [typeName],
+      );
     });
 
     return {
       id: routeId,
-      namespace: _.replace(moduleName, /^(\d)/, "v$1"),
+      namespace: _.replace(moduleName, /^(\d)/, 'v$1'),
       routeName,
       routeParams,
       requestBodyInfo,
@@ -870,22 +1105,29 @@ class SchemaRoutes {
       const routeInfosMap = this.createRequestsMap(routeInfoByMethodsMap);
 
       _.forEach(routeInfosMap, (routeInfo, method) => {
-        const parsedRouteInfo = this.parseRouteInfo(rawRouteName, routeInfo, method, usageSchema, parsedSchemas);
-        const processedRouteInfo = this.config.hooks.onCreateRoute(parsedRouteInfo);
+        const parsedRouteInfo = this.parseRouteInfo(
+          rawRouteName,
+          routeInfo,
+          method,
+          usageSchema,
+          parsedSchemas,
+        );
+        const processedRouteInfo =
+          this.config.hooks.onCreateRoute(parsedRouteInfo);
         if (processedRouteInfo !== false) {
-            const route = processedRouteInfo || parsedRouteInfo;
-
-            if (!this.hasSecurityRoutes && route.security) {
-                this.hasSecurityRoutes = route.security;
-            }
-            if (!this.hasQueryRoutes && route.hasQuery) {
-                this.hasQueryRoutes = route.hasQuery;
-            }
-            if (!this.hasFormDataRoutes && route.hasFormDataParams) {
-                this.hasFormDataRoutes = route.hasFormDataParams;
-            }
-
-            this.routes.push(route);
+          const route = processedRouteInfo || parsedRouteInfo;
+
+          if (!this.hasSecurityRoutes && route.security) {
+            this.hasSecurityRoutes = route.security;
+          }
+          if (!this.hasQueryRoutes && route.hasQuery) {
+            this.hasQueryRoutes = route.hasQuery;
+          }
+          if (!this.hasFormDataRoutes && route.hasFormDataParams) {
+            this.hasFormDataRoutes = route.hasFormDataParams;
+          }
+
+          this.routes.push(route);
         }
       });
     });
@@ -911,10 +1153,10 @@ class SchemaRoutes {
       },
     );
 
-    return _.reduce(
+    const routeGroups = _.reduce(
       groupedRoutes,
       (acc, routesGroup, moduleName) => {
-        if (moduleName === "$outOfModule") {
+        if (moduleName === '$outOfModule') {
           acc.outOfModule = routesGroup;
         } else {
           if (!acc.combined) acc.combined = [];
@@ -922,14 +1164,19 @@ class SchemaRoutes {
           acc.combined.push({
             moduleName,
             routes: _.map(routesGroup, (route) => {
-              const { original: originalName, usage: usageName } = route.routeName;
+              const { original: originalName, usage: usageName } =
+                route.routeName;
 
               // TODO: https://github.com/acacode/swagger-typescript-api/issues/152
               // TODO: refactor
               if (
                 routesGroup.length > 1 &&
                 usageName !== originalName &&
-                !_.some(routesGroup, ({ routeName, id }) => id !== route.id && originalName === routeName.original)
+                !_.some(
+                  routesGroup,
+                  ({ routeName, id }) =>
+                    id !== route.id && originalName === routeName.original,
+                )
               ) {
                 return {
                   ...route,
@@ -948,6 +1195,28 @@ class SchemaRoutes {
       },
       {},
     );
+
+    if (this.config.sortRoutes) {
+      if (routeGroups.outOfModule) {
+        routeGroups.outOfModule = this.sortRoutes(routeGroups.outOfModule);
+      }
+      if (routeGroups.combined) {
+        routeGroups.combined = this.sortRoutes(routeGroups.combined);
+      }
+    }
+
+    return routeGroups;
+  };
+
+  sortRoutes = (routeInfo) => {
+    if (routeInfo) {
+      routeInfo.forEach((routeInfo) => {
+        routeInfo.routes.sort((routeA, routeB) =>
+          routeA.routeName.usage.localeCompare(routeB.routeName.usage),
+        );
+      });
+    }
+    return routeInfo;
   };
 }