swagger-typescript-api 13.0.9 → 13.0.10

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

@@ -1,1208 +0,0 @@
-import _ from "lodash";
-import {
-  DEFAULT_BODY_ARG_NAME,
-  RESERVED_BODY_ARG_NAMES,
-  RESERVED_HEADER_ARG_NAMES,
-  RESERVED_PATH_ARG_NAMES,
-  RESERVED_QUERY_ARG_NAMES,
-} from "../constants.js";
-import { generateId } from "../util/id.js";
-import { SpecificArgNameResolver } from "./util/specific-arg-name-resolver.js";
-
-const CONTENT_KIND = {
-  JSON: "JSON",
-  URL_ENCODED: "URL_ENCODED",
-  FORM_DATA: "FORM_DATA",
-  IMAGE: "IMAGE",
-  OTHER: "OTHER",
-  TEXT: "TEXT",
-};
-
-class SchemaRoutes {
-  /**
-   * @type {CodeGenConfig}
-   */
-  config;
-  /**
-   * @type {SchemaParserFabric}
-   */
-  schemaParserFabric;
-  /**
-   * @type {SchemaUtils}
-   */
-  schemaUtils;
-  /**
-   * @type {TypeNameFormatter}
-   */
-  typeNameFormatter;
-  /**
-   * @type {SchemaComponentsMap}
-   */
-  schemaComponentsMap;
-  /**
-   * @type {Logger}
-   */
-  logger;
-  /**
-   * @type {TemplatesWorker}
-   */
-  templatesWorker;
-
-  FORM_DATA_TYPES = [];
-
-  routes = [];
-  hasSecurityRoutes = false;
-  hasQueryRoutes = false;
-  hasFormDataRoutes = false;
-
-  constructor({
-    config,
-    schemaParserFabric,
-    schemaComponentsMap,
-    logger,
-    templatesWorker,
-    typeNameFormatter,
-  }) {
-    this.config = config;
-    this.schemaParserFabric = schemaParserFabric;
-    this.schemaUtils = this.schemaParserFabric.schemaUtils;
-    this.typeNameFormatter = typeNameFormatter;
-    this.schemaComponentsMap = schemaComponentsMap;
-    this.logger = logger;
-    this.templatesWorker = templatesWorker;
-
-    this.FORM_DATA_TYPES = _.uniq([
-      this.schemaUtils.getSchemaType({ type: "string", format: "file" }),
-      this.schemaUtils.getSchemaType({ type: "string", format: "binary" }),
-    ]);
-  }
-
-  createRequestsMap = (routeInfoByMethodsMap) => {
-    const parameters = _.get(routeInfoByMethodsMap, "parameters");
-
-    return _.reduce(
-      routeInfoByMethodsMap,
-      (acc, requestInfo, method) => {
-        if (
-          _.startsWith(method, "x-") ||
-          ["parameters", "$ref"].includes(method)
-        ) {
-          return acc;
-        }
-
-        acc[method] = {
-          ...requestInfo,
-          parameters: _.compact(_.concat(parameters, requestInfo.parameters)),
-        };
-
-        return acc;
-      },
-      {},
-    );
-  };
-
-  parseRouteName = (originalRouteName) => {
-    const routeName =
-      this.config.hooks.onPreBuildRoutePath(originalRouteName) ||
-      originalRouteName;
-
-    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, "");
-
-        if (!paramName) return pathParams;
-
-        if (_.includes(paramName, "-")) {
-          this.logger.warn("wrong path param name", paramName);
-        }
-
-        pathParams.push({
-          $match: match,
-          name: _.camelCase(paramName),
-          required: true,
-          type: "string",
-          description: "",
-          schema: {
-            type: "string",
-          },
-          in: "path",
-        });
-
-        return pathParams;
-      },
-      [],
-    );
-
-    let fixedRoute = _.reduce(
-      pathParams,
-      (fixedRoute, pathParam, i, arr) => {
-        const insertion =
-          this.config.hooks.onInsertPathParam(
-            pathParam.name,
-            i,
-            arr,
-            fixedRoute,
-          ) || pathParam.name;
-        return _.replace(fixedRoute, pathParam.$match, `\${${insertion}}`);
-      },
-      routeName || "",
-    );
-
-    const queryParamMatches = fixedRoute.match(/(\{\?.*\})/g);
-    const queryParams = [];
-
-    if (queryParamMatches?.length) {
-      queryParamMatches.forEach((match) => {
-        fixedRoute = fixedRoute.replace(match, "");
-      });
-
-      _.uniq(
-        queryParamMatches
-          .join(",")
-          .replace(/(\{\?)|(\})|\s/g, "")
-          .split(","),
-      ).forEach((paramName) => {
-        if (_.includes(paramName, "-")) {
-          this.logger.warn("wrong query param name", paramName);
-        }
-
-        queryParams.push({
-          $match: paramName,
-          name: _.camelCase(paramName),
-          required: true,
-          type: "string",
-          description: "",
-          schema: {
-            type: "string",
-          },
-          in: "query",
-        });
-      });
-    }
-
-    const result = {
-      originalRoute: originalRouteName || "",
-      route: fixedRoute,
-      pathParams,
-      queryParams,
-    };
-
-    return this.config.hooks.onBuildRoutePath(result) || result;
-  };
-
-  getRouteParams = (
-    routeInfo,
-    pathParamsFromRouteName,
-    queryParamsFromRouteName,
-  ) => {
-    const { parameters } = routeInfo;
-
-    const routeParams = {
-      path: [],
-      header: [],
-      body: [],
-      query: [],
-      formData: [],
-      cookie: [],
-    };
-
-    _.each(parameters, (parameter) => {
-      const refTypeInfo =
-        this.schemaParserFabric.schemaUtils.getSchemaRefType(parameter);
-      let routeParam = null;
-
-      if (refTypeInfo?.rawTypeData.in && refTypeInfo.rawTypeData) {
-        if (!routeParams[refTypeInfo.rawTypeData.in]) {
-          routeParams[refTypeInfo.rawTypeData.in] = [];
-        }
-
-        routeParam = {
-          ...refTypeInfo.rawTypeData,
-          ...(refTypeInfo.rawTypeData.schema || {}),
-        };
-      } else {
-        if (!parameter.in) return;
-
-        if (!routeParams[parameter.in]) {
-          routeParams[parameter.in] = [];
-        }
-
-        routeParam = {
-          ...parameter,
-          ...(parameter.schema || {}),
-        };
-      }
-
-      if (routeParam.in === "path") {
-        if (!routeParam.name) return;
-
-        routeParam.name = _.camelCase(routeParam.name);
-      }
-
-      if (routeParam) {
-        routeParams[routeParam.in].push(routeParam);
-      }
-    });
-
-    // 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,
-      );
-
-      if (!alreadyExist) {
-        routeParams.path.push(pathParam);
-      }
-    });
-    // 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,
-      );
-
-      if (!alreadyExist) {
-        routeParams.query.push(queryParam);
-      }
-    });
-
-    return routeParams;
-  };
-
-  getContentTypes = (requestInfo, extraContentTypes) =>
-    _.uniq(
-      _.compact([
-        ...(extraContentTypes || []),
-        ..._.flatten(
-          _.map(
-            requestInfo,
-            (requestInfoData) =>
-              requestInfoData && _.keys(requestInfoData.content),
-          ),
-        ),
-      ]),
-    );
-
-  getContentKind = (contentTypes) => {
-    if (
-      _.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")) {
-      return CONTENT_KIND.URL_ENCODED;
-    }
-
-    if (contentTypes.includes("multipart/form-data")) {
-      return CONTENT_KIND.FORM_DATA;
-    }
-
-    if (
-      _.some(contentTypes, (contentType) => _.includes(contentType, "image/"))
-    ) {
-      return CONTENT_KIND.IMAGE;
-    }
-
-    if (
-      _.some(contentTypes, (contentType) => _.startsWith(contentType, "text/"))
-    ) {
-      return CONTENT_KIND.TEXT;
-    }
-
-    return CONTENT_KIND.OTHER;
-  };
-
-  isSuccessStatus = (status) =>
-    (this.config.defaultResponseAsSuccess && status === "default") ||
-    (+status >= this.config.successResponseStatusRange[0] &&
-      +status <= this.config.successResponseStatusRange[1]) ||
-    status === "2xx";
-
-  getSchemaFromRequestType = (requestInfo) => {
-    const content = _.get(requestInfo, "content");
-
-    if (!content) return null;
-
-    /* content: { "multipart/form-data": { schema: {...} }, "application/json": { schema: {...} } } */
-
-    /* for example: dataType = "multipart/form-data" */
-    for (const dataType in content) {
-      if (content[dataType]?.schema) {
-        return {
-          ...content[dataType].schema,
-          dataType,
-        };
-      }
-    }
-
-    return null;
-  };
-
-  getTypeFromRequestInfo = ({
-    requestInfo,
-    parsedSchemas,
-    operationId,
-    defaultType,
-    typeName,
-  }) => {
-    // TODO: make more flexible pick schema without content type
-    const schema = this.getSchemaFromRequestType(requestInfo);
-    const refTypeInfo =
-      this.schemaParserFabric.schemaUtils.getSchemaRefType(requestInfo);
-
-    if (schema) {
-      const content = this.schemaParserFabric.getInlineParseContent(
-        schema,
-        typeName,
-        [operationId],
-      );
-      const foundedSchemaByName = _.find(
-        parsedSchemas,
-        (parsedSchema) =>
-          this.typeNameFormatter.format(parsedSchema.name) === content,
-      );
-      const foundSchemaByContent = _.find(parsedSchemas, (parsedSchema) =>
-        _.isEqual(parsedSchema.content, content),
-      );
-
-      const foundSchema = foundedSchemaByName || foundSchemaByContent;
-
-      return foundSchema
-        ? this.typeNameFormatter.format(foundSchema.name)
-        : content;
-    }
-
-    if (refTypeInfo) {
-      // const refTypeWithoutOpId = refType.replace(operationId, '');
-      // 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.typeNameFormatter.format(typeNameWithoutOpId);
-      }
-
-      switch (refTypeInfo.componentName) {
-        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.schemaParserFabric.getInlineParseContent(
-            refTypeInfo.rawTypeData,
-            refTypeInfo.typeName || null,
-            [operationId],
-          );
-      }
-    }
-
-    return defaultType || this.config.Ts.Keyword.Any;
-  };
-
-  getRequestInfoTypes = ({
-    requestInfos,
-    parsedSchemas,
-    operationId,
-    defaultType,
-  }) =>
-    _.reduce(
-      requestInfos,
-      (acc, requestInfo, status) => {
-        const contentTypes = this.getContentTypes([requestInfo]);
-
-        return [
-          ...acc,
-          {
-            ...(requestInfo || {}),
-            contentTypes: contentTypes,
-            contentKind: this.getContentKind(contentTypes),
-            type: this.schemaParserFabric.schemaUtils.safeAddNullToType(
-              requestInfo,
-              this.getTypeFromRequestInfo({
-                requestInfo,
-                parsedSchemas,
-                operationId,
-                defaultType,
-              }),
-            ),
-            description:
-              this.schemaParserFabric.schemaFormatters.formatDescription(
-                requestInfo.description || "",
-                true,
-              ),
-            status: _.isNaN(+status) ? status : +status,
-            isSuccess: this.isSuccessStatus(status),
-          },
-        ];
-      },
-      [],
-    );
-
-  getResponseBodyInfo = (routeInfo, parsedSchemas) => {
-    const { produces, operationId, responses } = routeInfo;
-
-    const contentTypes = this.getContentTypes(responses, [
-      ...(produces || []),
-      routeInfo["x-accepts"],
-    ]);
-
-    const responseInfos = this.getRequestInfoTypes({
-      requestInfos: responses,
-      parsedSchemas,
-      operationId,
-      defaultType: this.config.defaultResponseType,
-    });
-
-    const successResponse = responseInfos.find(
-      (response) => response.isSuccess,
-    );
-    const errorResponses = responseInfos.filter(
-      (response) =>
-        !response.isSuccess && response.type !== this.config.Ts.Keyword.Any,
-    );
-
-    const handleResponseHeaders = (src) => {
-      if (!src) {
-        return "headers: {},";
-      }
-      const headerTypes = Object.fromEntries(
-        Object.entries(src).map(([k, v]) => {
-          return [k, this.schemaUtils.getSchemaType(v)];
-        }),
-      );
-      const r = `headers: { ${Object.entries(headerTypes)
-        .map(([k, v]) => `"${k}": ${v}`)
-        .join(",")} },`;
-      return r;
-    };
-
-    return {
-      contentTypes,
-      responses: responseInfos,
-      success: {
-        schema: successResponse,
-        type: 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,
-      },
-      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: {} }`,
-            ),
-          ) || this.config.Ts.Keyword.Any,
-      },
-    };
-  };
-
-  convertRouteParamsIntoObject = (params) => {
-    return _.reduce(
-      params,
-      (objectSchema, schemaPart) => {
-        if (!schemaPart || !schemaPart.name) return objectSchema;
-
-        let usageName = `${schemaPart.name}`;
-
-        if (usageName.includes(".")) {
-          usageName = _.camelCase(usageName);
-        }
-
-        return {
-          ...objectSchema,
-          properties: {
-            ...objectSchema.properties,
-            [usageName]: {
-              ...schemaPart,
-              ...(schemaPart.schema || {}),
-              $origName: schemaPart.name,
-              name: usageName,
-            },
-          },
-        };
-      },
-      {
-        properties: {},
-        type: "object",
-      },
-    );
-  };
-
-  getRequestBodyInfo = (routeInfo, routeParams, parsedSchemas, routeName) => {
-    const { requestBody, consumes, requestBodyName, operationId } = routeInfo;
-    let schema = null;
-    let content = null;
-
-    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, {
-        suffixes: this.config.extractingOptions.requestBodySuffix,
-        resolver: this.config.extractingOptions.requestBodyNameResolver,
-      });
-    }
-
-    if (routeParams.formData.length) {
-      contentKind = CONTENT_KIND.FORM_DATA;
-      schema = this.convertRouteParamsIntoObject(routeParams.formData);
-      content = this.schemaParserFabric.getInlineParseContent(
-        schema,
-        typeName,
-        [operationId],
-      );
-    } else if (contentKind === CONTENT_KIND.FORM_DATA) {
-      schema = this.getSchemaFromRequestType(requestBody);
-      content = this.schemaParserFabric.getInlineParseContent(
-        schema,
-        typeName,
-        [operationId],
-      );
-    } else if (requestBody) {
-      schema = this.getSchemaFromRequestType(requestBody);
-      content = this.schemaParserFabric.schemaUtils.safeAddNullToType(
-        requestBody,
-        this.getTypeFromRequestInfo({
-          requestInfo: requestBody,
-          parsedSchemas,
-          operationId,
-          typeName,
-        }),
-      );
-
-      // 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(content, `: ${dataType}`),
-        )
-      ) {
-        contentKind = CONTENT_KIND.FORM_DATA;
-      }
-    }
-
-    if (schema && !schema.$ref && this.config.extractRequestBody) {
-      schema = this.schemaParserFabric.createParsedComponent({
-        schema,
-        typeName,
-        schemaPath: [operationId],
-      });
-      content = this.schemaParserFabric.getInlineParseContent({
-        $ref: schema.$ref,
-      });
-    }
-
-    return {
-      paramName: requestBodyName || requestBody?.name || DEFAULT_BODY_ARG_NAME,
-      contentTypes,
-      contentKind,
-      schema,
-      type: content,
-      required:
-        requestBody &&
-        (typeof requestBody.required === "undefined" || !!requestBody.required),
-    };
-  };
-
-  createRequestParamsSchema = ({
-    queryParams,
-    queryObjectSchema,
-    pathArgsSchemas,
-    extractRequestParams,
-    routeName,
-  }) => {
-    if (!queryParams || !queryParams.length) return null;
-
-    const pathParams = _.reduce(
-      pathArgsSchemas,
-      (acc, pathArgSchema) => {
-        if (pathArgSchema.name) {
-          acc[pathArgSchema.name] = {
-            ...pathArgSchema,
-            in: "path",
-          };
-        }
-
-        return acc;
-      },
-      {},
-    );
-
-    const fixedQueryParams = _.reduce(
-      _.get(queryObjectSchema, "properties", {}),
-      (acc, property, name) => {
-        if (name && _.isObject(property)) {
-          acc[name] = {
-            ...property,
-            in: "query",
-          };
-        }
-
-        return acc;
-      },
-      {},
-    );
-
-    const schema = {
-      ...queryObjectSchema,
-      properties: {
-        ...fixedQueryParams,
-        ...pathParams,
-      },
-    };
-
-    const fixedSchema = this.config.hooks.onCreateRequestParams(schema);
-
-    if (fixedSchema) return fixedSchema;
-
-    if (extractRequestParams) {
-      const generatedTypeName = this.schemaUtils.resolveTypeName(
-        routeName.usage,
-        {
-          suffixes: this.config.extractingOptions.requestParamsSuffix,
-          resolver: this.config.extractingOptions.requestParamsNameResolver,
-        },
-      );
-
-      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, {
-        suffixes: this.config.extractingOptions.responseBodySuffix,
-        resolver: this.config.extractingOptions.responseBodyNameResolver,
-      });
-
-      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.schemaParserFabric.createParsedComponent({
-          schema,
-          typeName,
-          schemaPath: [routeInfo.operationId],
-        });
-        successResponse.type = this.schemaParserFabric.getInlineParseContent({
-          $ref: successResponse.schema.$ref,
-        });
-
-        if (idx > -1) {
-          _.assign(responseBodyInfo.responses[idx], {
-            ...successResponse.schema,
-            type: successResponse.type,
-          });
-        }
-      }
-    }
-  };
-
-  extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
-    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);
-
-      if (!errorSchemas.length) return;
-
-      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.typeNameFormatter.format(
-        component.typeName,
-      );
-    }
-  };
-
-  getRouteName = (rawRouteInfo) => {
-    const { moduleName } = rawRouteInfo;
-    const { routeNameDuplicatesMap, templatesToRender } = this.config;
-    const routeNameTemplate = templatesToRender.routeName;
-
-    const routeNameFromTemplate = this.templatesWorker.renderTemplate(
-      routeNameTemplate,
-      {
-        routeInfo: rawRouteInfo,
-      },
-    );
-
-    const routeName =
-      this.config.hooks.onFormatRouteName(
-        rawRouteInfo,
-        routeNameFromTemplate,
-      ) || routeNameFromTemplate;
-
-    const duplicateIdentifier = `${moduleName}|${routeName}`;
-
-    if (routeNameDuplicatesMap.has(duplicateIdentifier)) {
-      routeNameDuplicatesMap.set(
-        duplicateIdentifier,
-        routeNameDuplicatesMap.get(duplicateIdentifier) + 1,
-      );
-
-      this.logger.warn(
-        `Module "${moduleName}" already has method "${routeName}()"`,
-        `\nThis method has been renamed to "${
-          routeName + routeNameDuplicatesMap.get(duplicateIdentifier)
-        }()" to solve conflict names.`,
-      );
-    } else {
-      routeNameDuplicatesMap.set(duplicateIdentifier, 1);
-    }
-
-    const duplicates = routeNameDuplicatesMap.get(duplicateIdentifier);
-
-    const routeNameInfo = {
-      usage: routeName + (duplicates > 1 ? duplicates : ""),
-      original: routeName,
-      duplicate: duplicates > 1,
-    };
-
-    return (
-      this.config.hooks.onCreateRouteName(routeNameInfo, rawRouteInfo) ||
-      routeNameInfo
-    );
-  };
-
-  parseRouteInfo = (
-    rawRouteName,
-    routeInfo,
-    method,
-    usageSchema,
-    parsedSchemas,
-  ) => {
-    const { security: globalSecurity } = usageSchema;
-    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,
-      ...otherInfo
-    } = routeInfo;
-    const {
-      route,
-      pathParams: pathParamsFromRouteName,
-      queryParams: queryParamsFromRouteName,
-    } = this.parseRouteName(rawRouteName);
-
-    const routeId = generateId();
-    const firstTag = tags && tags.length > 0 ? tags[0] : null;
-    const moduleName =
-      moduleNameFirstTag && firstTag
-        ? _.camelCase(firstTag)
-        : _.camelCase(_.compact(_.split(route, "/"))[moduleNameIndex]);
-    let hasSecurity = !!globalSecurity?.length;
-    if (security) {
-      hasSecurity = security.length > 0;
-    }
-
-    const routeParams = this.getRouteParams(
-      routeInfo,
-      pathParamsFromRouteName,
-      queryParamsFromRouteName,
-    );
-
-    const pathArgs = routeParams.path.map((pathArgSchema) => ({
-      name: pathArgSchema.name,
-      optional: !pathArgSchema.required,
-      // mark it as any for now, because "getInlineParseContent" breaks type names of extracted enums
-      type: this.config.Ts.Keyword.Any,
-      description: pathArgSchema.description,
-    }));
-    const pathArgsNames = pathArgs.map((arg) => arg.name);
-
-    const responseBodyInfo = this.getResponseBodyInfo(routeInfo, parsedSchemas);
-
-    const rawRouteInfo = {
-      ...otherInfo,
-      pathArgs,
-      operationId,
-      method,
-      route: rawRouteName,
-      moduleName,
-      responsesTypes: responseBodyInfo.responses,
-      description,
-      tags,
-      summary,
-      responses,
-      produces,
-      requestBody,
-      consumes,
-    };
-
-    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 requestParamsSchema = this.createRequestParamsSchema({
-      queryParams: routeParams.query,
-      pathArgsSchemas: routeParams.path,
-      queryObjectSchema,
-      extractRequestParams,
-      routeName,
-    });
-
-    if (this.config.extractResponseBody) {
-      this.extractResponseBodyIfItNeeded(
-        routeInfo,
-        responseBodyInfo,
-        routeName,
-      );
-    }
-    if (this.config.extractResponseError) {
-      this.extractResponseErrorIfItNeeded(
-        routeInfo,
-        responseBodyInfo,
-        routeName,
-      );
-    }
-
-    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.schemaParserFabric.getInlineParseContent(queryObjectSchema, null, [
-          typeName,
-        ])
-      : null;
-    const pathType = routeParams.path.length
-      ? this.schemaParserFabric.getInlineParseContent(pathObjectSchema, null, [
-          typeName,
-        ])
-      : null;
-    const headersType = routeParams.header.length
-      ? this.schemaParserFabric.getInlineParseContent(
-          headersObjectSchema,
-          null,
-          [typeName],
-        )
-      : null;
-
-    const nameResolver = new SpecificArgNameResolver(
-      this.config,
-      this.logger,
-      pathArgsNames,
-    );
-
-    const specificArgs = {
-      query: queryType
-        ? {
-            name: nameResolver.resolve(RESERVED_QUERY_ARG_NAMES),
-            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,
-            ]),
-            optional: !requestBodyInfo.required,
-            type: requestBodyInfo.type,
-          }
-        : void 0,
-      pathParams: pathType
-        ? {
-            name: nameResolver.resolve(RESERVED_PATH_ARG_NAMES),
-            optional: this.schemaParserFabric.parseSchema(
-              pathObjectSchema,
-              null,
-              [routeName.usage],
-            ).allFieldsAreOptional,
-            type: pathType,
-          }
-        : void 0,
-      headers: headersType
-        ? {
-            name: nameResolver.resolve(RESERVED_HEADER_ARG_NAMES),
-            optional: this.schemaParserFabric.parseSchema(
-              headersObjectSchema,
-              null,
-              [routeName.usage],
-            ).allFieldsAreOptional,
-            type: headersType,
-          }
-        : void 0,
-    };
-
-    pathArgs.forEach((pathArg, i) => {
-      pathArg.type = this.schemaParserFabric.getInlineParseContent(
-        routeParams.path[i].schema,
-        null,
-        [typeName],
-      );
-    });
-
-    return {
-      id: routeId,
-      namespace: _.replace(moduleName, /^(\d)/, "v$1"),
-      routeName,
-      routeParams,
-      requestBodyInfo,
-      responseBodyInfo,
-      specificArgs,
-      queryObjectSchema,
-      pathObjectSchema,
-      headersObjectSchema,
-      responseBodySchema: responseBodyInfo.success.schema,
-      requestBodySchema: requestBodyInfo.schema,
-      specificArgNameResolver: nameResolver,
-      request: {
-        contentTypes: requestBodyInfo.contentTypes,
-        parameters: pathArgs,
-        path: route,
-        formData: requestBodyInfo.contentKind === CONTENT_KIND.FORM_DATA,
-        isQueryBody: requestBodyInfo.contentKind === CONTENT_KIND.URL_ENCODED,
-        security: hasSecurity,
-        method: method,
-        requestParams: requestParamsSchema,
-
-        payload: specificArgs.body,
-        query: specificArgs.query,
-        pathParams: specificArgs.pathParams,
-        headers: specificArgs.headers,
-      },
-      response: {
-        contentTypes: responseBodyInfo.contentTypes,
-        type: responseBodyInfo.success.type,
-        errorType: responseBodyInfo.error.type,
-        fullTypes: responseBodyInfo.full.types,
-      },
-      raw: rawRouteInfo,
-    };
-  };
-
-  attachSchema = ({ usageSchema, parsedSchemas }) => {
-    this.config.routeNameDuplicatesMap.clear();
-
-    const pathsEntries = _.entries(usageSchema.paths);
-
-    _.forEach(pathsEntries, ([rawRouteName, routeInfoByMethodsMap]) => {
-      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);
-        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);
-        }
-      });
-    });
-  };
-
-  getGroupedRoutes = () => {
-    const groupedRoutes = this.routes.reduce(
-      (modules, route) => {
-        if (route.namespace) {
-          if (!modules[route.namespace]) {
-            modules[route.namespace] = [];
-          }
-
-          modules[route.namespace].push(route);
-        } else {
-          modules.$outOfModule.push(route);
-        }
-
-        return modules;
-      },
-      {
-        $outOfModule: [],
-      },
-    );
-
-    const routeGroups = _.reduce(
-      groupedRoutes,
-      (acc, routesGroup, moduleName) => {
-        if (moduleName === "$outOfModule") {
-          acc.outOfModule = routesGroup;
-        } else {
-          if (!acc.combined) acc.combined = [];
-
-          acc.combined.push({
-            moduleName,
-            routes: _.map(routesGroup, (route) => {
-              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,
-                )
-              ) {
-                return {
-                  ...route,
-                  routeName: {
-                    ...route.routeName,
-                    usage: originalName,
-                  },
-                };
-              }
-
-              return route;
-            }),
-          });
-        }
-        return acc;
-      },
-      {},
-    );
-
-    if (this.config.sortRoutes) {
-      if (routeGroups.outOfModule) {
-        routeGroups.outOfModule = this.sortRoutes(routeGroups.outOfModule);
-      }
-      if (routeGroups.combined) {
-        _.each(routeGroups.combined, (routeGroup) => {
-          routeGroup.routes = this.sortRoutes(routeGroup.routes);
-        });
-      }
-    }
-
-    return routeGroups;
-  };
-
-  sortRoutes = (routes) => {
-    return _.slice(routes).sort((routeA, routeB) =>
-      routeA.routeName.usage.localeCompare(routeB.routeName.usage),
-    );
-  };
-}
-
-export { SchemaRoutes };