swagger-typescript-api 13.0.0-experimental-1 → 13.0.1

package/src/code-gen-process.js

@@ -1,57 +1,59 @@
-const { SwaggerSchemaResolver } = require("./swagger-schema-resolver.js");
-const { SchemaComponentsMap } = require("./schema-components-map.js");
-const { NameResolver } = require("./util/name-resolver");
-const { Logger } = require("./util/logger.js");
-const { TypeNameFormatter } = require("./type-name-formatter.js");
-const _ = require("lodash");
-const { SchemaProcessor } = require("./schema-parser/schema-processor.js");
-const { SchemaRoutes } = require("./schema-parser/schema-routes.js");
-const { CodeGenConfig } = require("./configuration.js");
-const { FileSystem } = require("./util/file-system");
-const { Templates } = require("./templates");
-const { translate: translateToJS } = require("./translators/JavaScript");
-const ts = require("typescript");
-const { CodeFormatter } = require("./code-formatter");
-const { pascalCase } = require("./util/pascal-case");
-const { internalCase } = require("./util/internal-case");
+const { SwaggerSchemaResolver } = require('./swagger-schema-resolver.js');
+const { SchemaComponentsMap } = require('./schema-components-map.js');
+const { NameResolver } = require('./util/name-resolver');
+const { Logger } = require('./util/logger.js');
+const { TypeNameFormatter } = require('./type-name-formatter.js');
+const _ = require('lodash');
+const { SchemaParserFabric } = require('./schema-parser/schema-parser-fabric');
+const { SchemaRoutes } = require('./schema-routes/schema-routes.js');
+const { CodeGenConfig } = require('./configuration.js');
+const { SchemaWalker } = require('./schema-walker');
+const { FileSystem } = require('./util/file-system');
+const { TemplatesWorker } = require('./templates-worker');
+const { JavascriptTranslator } = require('./translators/javascript');
+const ts = require('typescript');
+const { CodeFormatter } = require('./code-formatter');
+const { pascalCase } = require('./util/pascal-case');
+const { internalCase } = require('./util/internal-case');
+const { sortByProperty } = require('./util/sort-by-property');
+
+const PATCHABLE_INSTANCES = [
+  'schemaWalker',
+  'swaggerSchemaResolver',
+  'schemaComponentsMap',
+  'typeNameFormatter',
+  'templatesWorker',
+  'codeFormatter',
+  'schemaParserFabric',
+  'schemaRoutes',
+  'javascriptTranslator',
+];
 
 class CodeGenProcess {
-  /**
-   * @type {CodeGenConfig}
-   */
+  /** @type {CodeGenConfig} */
   config;
-  /**
-   * @type {SwaggerSchemaResolver}
-   */
+  /** @type {SwaggerSchemaResolver} */
   swaggerSchemaResolver;
-  /**
-   * @type {SchemaComponentsMap}
-   */
-  schemaComponentMap;
-  /**
-   * @type {Logger}
-   */
+  /** @type {SchemaComponentsMap} */
+  schemaComponentsMap;
+  /** @type {Logger} */
   logger;
-  /**
-   * @type {TypeNameFormatter}
-   */
-  typeName;
-  /**
-   * @type {SchemaProcessor}
-   */
-  schemaParser;
-  /**
-   * @type {SchemaRoutes}
-   */
+  /** @type {TypeNameFormatter} */
+  typeNameFormatter;
+  /** @type {SchemaParserFabric} */
+  schemaParserFabric;
+  /** @type {SchemaRoutes} */
   schemaRoutes;
-  /**
-   * @type {FileSystem}
-   */
+  /** @type {FileSystem} */
   fileSystem;
-  /**
-   * @type {CodeFormatter}
-   */
+  /** @type {CodeFormatter} */
   codeFormatter;
+  /** type {TemplatesWorker} */
+  templatesWorker;
+  /** @type {SchemaWalker} */
+  schemaWalker;
+  /** @type {JavascriptTranslator} */
+  javascriptTranslator;
 
   /**
    *
@@ -59,35 +61,27 @@ class CodeGenProcess {
    */
   constructor(config) {
     this.config = new CodeGenConfig(config);
-    this.logger = new Logger(this.config);
-    this.fileSystem = new FileSystem();
-    this.swaggerSchemaResolver = new SwaggerSchemaResolver(this.config, this.logger, this.fileSystem);
-    this.schemaComponentMap = new SchemaComponentsMap(this.config);
-    this.typeName = new TypeNameFormatter(this.config, this.logger);
-    this.templates = new Templates(this.config, this.logger, this.fileSystem, this.getRenderTemplateData);
-    this.codeFormatter = new CodeFormatter(this.config);
-    this.schemaParser = new SchemaProcessor(
-      this.config,
-      this.logger,
-      this.templates,
-      this.schemaComponentMap,
-      this.typeName,
-    );
-    this.schemaRoutes = new SchemaRoutes(
-      this.config,
-      this.schemaParser,
-      this.schemaComponentMap,
-      this.logger,
-      this.templates,
-      this.typeName,
-    );
+    this.logger = new Logger(this);
+    this.fileSystem = new FileSystem(this);
+    this.schemaWalker = new SchemaWalker(this);
+    this.swaggerSchemaResolver = new SwaggerSchemaResolver(this);
+    this.schemaComponentsMap = new SchemaComponentsMap(this);
+    this.typeNameFormatter = new TypeNameFormatter(this);
+    this.templatesWorker = new TemplatesWorker(this);
+    this.codeFormatter = new CodeFormatter(this);
+    this.schemaParserFabric = new SchemaParserFabric(this);
+    this.schemaRoutes = new SchemaRoutes(this);
+    this.javascriptTranslator = new JavascriptTranslator(this);
     this.config.componentTypeNameResolver.logger = this.logger;
   }
 
   async start() {
-    await this.schemaRoutes.init();
-    this.config.update({ templatePaths: this.templates.getTemplatePaths(this.config) });
-    this.config.update({ templatesToRender: this.templates.getTemplates(this.config) });
+    this.config.update({
+      templatePaths: this.templatesWorker.getTemplatePaths(this.config),
+    });
+    this.config.update({
+      templatesToRender: this.templatesWorker.getTemplates(this.config),
+    });
 
     const swagger = await this.swaggerSchemaResolver.create();
 
@@ -98,70 +92,55 @@ class CodeGenProcess {
       originalSchema: swagger.originalSchema,
     });
 
-    this.logger.event("start generating your typescript api");
+    this.schemaWalker.addSchema('$usage', swagger.usageSchema);
+    this.schemaWalker.addSchema('$original', swagger.originalSchema);
 
-    this.config.update(this.config.hooks.onInit(this.config) || this.config);
+    this.logger.event('start generating your typescript api');
 
-    this.schemaComponentMap.processSchema(swagger.usageSchema);
-
-    const componentSchemaNames = this.schemaComponentMap.filter("schemas").map((c) => c.typeName);
+    this.config.update(
+      this.config.hooks.onInit(this.config, this) || this.config,
+    );
 
-    this.config.componentTypeNameResolver.reserve(componentSchemaNames);
+    this.schemaComponentsMap.clear();
+
+    _.each(swagger.usageSchema.components, (component, componentName) =>
+      _.each(component, (rawTypeData, typeName) => {
+        this.schemaComponentsMap.createComponent(
+          this.schemaComponentsMap.createRef([
+            'components',
+            componentName,
+            typeName,
+          ]),
+          rawTypeData,
+        );
+      }),
+    );
 
-    const parsedSchemas = await Promise.all(
-      _.map(_.get(swagger.usageSchema.components, "schemas"), (schema, typeName) =>
-        this.schemaParser.parseSchema(schema, typeName),
-      ),
+    /**
+     * @type {SchemaComponent[]}
+     */
+    const componentsToParse = this.schemaComponentsMap.filter(
+      _.compact(['schemas', this.config.extractResponses && 'responses']),
     );
 
-    await this.schemaRoutes.attachSchema({
+    const parsedSchemas = componentsToParse.map((schemaComponent) => {
+      const parsed = this.schemaParserFabric.parseSchema(
+        schemaComponent.rawTypeData,
+        schemaComponent.typeName,
+      );
+      schemaComponent.typeData = parsed;
+      return parsed;
+    });
+
+    this.schemaRoutes.attachSchema({
       usageSchema: swagger.usageSchema,
       parsedSchemas,
     });
 
-    const usageComponentSchemas = this.schemaComponentMap.filter("schemas");
-    const sortByProperty = (propertyName) => (o1, o2) => {
-      if (o1[propertyName] > o2[propertyName]) {
-        return 1;
-      }
-      if (o1[propertyName] < o2[propertyName]) {
-        return -1;
-      }
-      return 0;
-    };
-
-    const sortSchemas = (schemas) => {
-      if (this.config.sortTypes) {
-        return schemas.sort(sortByProperty("typeName")).map((schema) => {
-          if (schema.rawTypeData?.properties) {
-            return {
-              ...schema,
-              rawTypeData: {
-                ...schema.rawTypeData,
-                $parsed: schema.rawTypeData["$parsed"] && {
-                  ...schema.rawTypeData["$parsed"],
-                  content: Array.isArray(schema.rawTypeData["$parsed"].content)
-                    ? schema.rawTypeData["$parsed"].content.sort(sortByProperty("name"))
-                    : schema.rawTypeData["$parsed"].content,
-                },
-              },
-            };
-          }
-          return schema;
-        });
-      }
-      return schemas;
-    };
-
-    const modelTypes = (await Promise.all(_.map(sortSchemas(usageComponentSchemas), this.prepareModelType))).filter(
-      Boolean,
-    );
-
     const rawConfiguration = {
       apiConfig: this.createApiConfig(swagger.usageSchema),
       config: this.config,
-      modelTypes: modelTypes,
-      rawModelTypes: usageComponentSchemas,
+      modelTypes: this.collectModelTypes(),
       hasSecurityRoutes: this.schemaRoutes.hasSecurityRoutes,
       hasQueryRoutes: this.schemaRoutes.hasQueryRoutes,
       hasFormDataRoutes: this.schemaRoutes.hasFormDataRoutes,
@@ -170,10 +149,14 @@ class CodeGenProcess {
       extraTemplates: this.config.extraTemplates,
       fileName: this.config.fileName,
       translateToJavaScript: this.config.toJS,
+      customTranslator: this.config.customTranslator
+        ? new this.config.customTranslator(this)
+        : null,
       utils: this.getRenderTemplateData().utils,
     };
 
-    const configuration = this.config.hooks.onPrepareConfig(rawConfiguration) || rawConfiguration;
+    const configuration =
+      this.config.hooks.onPrepareConfig(rawConfiguration) || rawConfiguration;
 
     if (this.fileSystem.pathIsExist(this.config.output)) {
       if (this.config.cleanOutput) {
@@ -181,7 +164,9 @@ class CodeGenProcess {
         this.fileSystem.cleanDir(this.config.output);
       }
     } else {
-      this.logger.debug(`path ${this.config.output} is not exist. creating dir by this path`);
+      this.logger.debug(
+        `path ${this.config.output} is not exist. creating dir by this path`,
+      );
       this.fileSystem.createDir(this.config.output);
     }
 
@@ -191,41 +176,28 @@ class CodeGenProcess {
 
     const isDirPath = this.fileSystem.pathIsDir(this.config.output);
 
-    const generatedFiles = files.map((file) => {
-      if (!isDirPath) return file;
-
-      if (this.config.toJS) {
+    if (isDirPath) {
+      files.forEach((file) => {
         this.fileSystem.createFile({
           path: this.config.output,
-          fileName: file.name,
-          content: file.content,
+          fileName: `${file.fileName}${file.fileExtension}`,
+          content: file.fileContent,
           withPrefix: true,
         });
-        this.fileSystem.createFile({
-          path: this.config.output,
-          fileName: file.declaration.name,
-          content: file.declaration.content,
-          withPrefix: true,
-        });
-        this.logger.success(`javascript api file`, file.name, `created in ${this.config.output}`);
-      } else {
-        this.fileSystem.createFile({
-          path: this.config.output,
-          fileName: file.name,
-          content: file.content,
-          withPrefix: true,
-        });
-        this.logger.success(`typescript api file`, file.name, `created in ${this.config.output}`);
-      }
 
-      return file;
-    });
+        this.logger.success(
+          `api file`,
+          `"${file.fileName}${file.fileExtension}"`,
+          `created in ${this.config.output}`,
+        );
+      });
+    }
 
     return {
-      files: generatedFiles,
+      files,
       configuration,
-      getTemplate: this.templates.getTemplate,
-      renderTemplate: await this.templates.renderTemplate,
+      getTemplate: this.templatesWorker.getTemplate,
+      renderTemplate: this.templatesWorker.renderTemplate,
       createFile: this.fileSystem.createFile,
       formatTSContent: this.codeFormatter.formatCode,
     };
@@ -235,57 +207,114 @@ class CodeGenProcess {
     return {
       utils: {
         Ts: this.config.Ts,
-        formatDescription: this.schemaParser.schemaFormatters.formatDescription,
+        formatDescription:
+          this.schemaParserFabric.schemaFormatters.formatDescription,
         internalCase: internalCase,
         classNameCase: pascalCase,
         pascalCase: pascalCase,
-        getInlineParseContent: this.schemaParser.getInlineParseContent,
-        getParseContent: this.schemaParser.getParseContent,
-        getComponentByRef: this.schemaComponentMap.get,
-        parseSchema: this.schemaParser.parseSchema,
-        checkAndAddNull: this.schemaParser.schemaUtils.safeAddNullToType,
-        safeAddNullToType: this.schemaParser.schemaUtils.safeAddNullToType,
-        isNeedToAddNull: this.schemaParser.schemaUtils.isNullMissingInType,
-        inlineExtraFormatters: this.schemaParser.schemaFormatters.inline,
-        formatters: this.schemaParser.schemaFormatters.base,
-        formatModelName: this.typeName.format,
+        getInlineParseContent: this.schemaParserFabric.getInlineParseContent,
+        getParseContent: this.schemaParserFabric.getParseContent,
+        getComponentByRef: this.schemaComponentsMap.get,
+        parseSchema: this.schemaParserFabric.parseSchema,
+        checkAndAddNull: this.schemaParserFabric.schemaUtils.safeAddNullToType,
+        safeAddNullToType:
+          this.schemaParserFabric.schemaUtils.safeAddNullToType,
+        isNeedToAddNull:
+          this.schemaParserFabric.schemaUtils.isNullMissingInType,
+        inlineExtraFormatters: this.schemaParserFabric.schemaFormatters.inline,
+        formatters: this.schemaParserFabric.schemaFormatters.base,
+        formatModelName: this.typeNameFormatter.format,
         fmtToJSDocLine: function fmtToJSDocLine(line, { eol = true }) {
-          return ` * ${line}${eol ? "\n" : ""}`;
+          return ` * ${line}${eol ? '\n' : ''}`;
         },
         NameResolver: NameResolver,
         _,
-        require: this.templates.requireFnFromTemplate,
+        require: this.templatesWorker.requireFnFromTemplate,
       },
       config: this.config,
     };
   };
 
-  prepareModelType = async (typeInfo) => {
-    if (!typeInfo.typeData) {
-      typeInfo.typeData = await this.schemaParser.parseSchema(typeInfo.rawTypeData, typeInfo.typeName);
+  collectModelTypes = () => {
+    const components = this.schemaComponentsMap.getComponents();
+    let modelTypes = [];
+
+    const modelTypeComponents = _.compact([
+      'schemas',
+      this.config.extractResponses && 'responses',
+    ]);
+
+    const getSchemaComponentsCount = () =>
+      this.schemaComponentsMap.filter(...modelTypeComponents).length;
+
+    let schemaComponentsCount = getSchemaComponentsCount();
+    let processedCount = 0;
+
+    while (processedCount < schemaComponentsCount) {
+      modelTypes = [];
+      processedCount = 0;
+      for (const component of components) {
+        if (modelTypeComponents.includes(component.componentName)) {
+          const modelType = this.prepareModelType(component);
+          if (modelType) {
+            modelTypes.push(modelType);
+          }
+          processedCount++;
+        }
+      }
+      schemaComponentsCount = getSchemaComponentsCount();
     }
-    const typeData = await this.schemaParser.schemaFormatters.formatSchema(typeInfo.typeData, {
-      formatType: "base",
-      schemaType: typeInfo.typeData.type,
-    });
 
+    if (this.config.sortTypes) {
+      return modelTypes.sort(sortByProperty('name'));
+    }
+
+    return modelTypes;
+  };
+
+  prepareModelType = (typeInfo) => {
+    if (typeInfo.$prepared) return typeInfo.$prepared;
+
+    if (!typeInfo.typeData) {
+      typeInfo.typeData = this.schemaParserFabric.parseSchema(
+        typeInfo.rawTypeData,
+        typeInfo.typeName,
+      );
+    }
+    const rawTypeData = typeInfo.typeData;
+    const typeData = this.schemaParserFabric.schemaFormatters.base[
+      rawTypeData.type
+    ]
+      ? this.schemaParserFabric.schemaFormatters.base[rawTypeData.type](
+          rawTypeData,
+        )
+      : rawTypeData;
     let { typeIdentifier, name: originalName, content, description } = typeData;
-    const name = this.typeName.format(originalName);
+    const name = this.typeNameFormatter.format(originalName);
 
     if (name === null) return null;
 
-    return {
+    const preparedModelType = {
       ...typeData,
       typeIdentifier,
       name,
       description,
-      $content: typeInfo.typeData.content,
-      rawContent: typeInfo.typeData.content,
+      $content: rawTypeData.content,
+      rawContent: rawTypeData.content,
       content: content,
       typeData,
     };
+
+    typeInfo.$prepared = preparedModelType;
+
+    return preparedModelType;
   };
 
+  /**
+   *
+   * @param configuration
+   * @returns {Promise<TranslatorIO[]>}
+   */
   generateOutputFiles = async ({ configuration }) => {
     const { modular, templatesToRender } = this.config;
 
@@ -294,148 +323,218 @@ class CodeGenProcess {
       : await this.createSingleFileInfo(templatesToRender, configuration);
 
     if (!_.isEmpty(configuration.extraTemplates)) {
-      output.push(
-        ...(await Promise.all(
-          _.map(configuration.extraTemplates, async (extraTemplate) => {
-            return this.createOutputFileInfo(
-              configuration,
-              extraTemplate.name,
-              await await this.templates.renderTemplate(
-                this.fileSystem.getFileContent(extraTemplate.path),
-                configuration,
-              ),
-            );
-          }),
-        )),
-      );
+      for (const extraTemplate of configuration.extraTemplates) {
+        const content = this.templatesWorker.renderTemplate(
+          this.fileSystem.getFileContent(extraTemplate.path),
+          configuration,
+        );
+        output.push(
+          ...(await this.createOutputFileInfo(
+            configuration,
+            extraTemplate.name,
+            content,
+          )),
+        );
+      }
     }
 
-    return output.filter((fileInfo) => !!fileInfo && !!fileInfo.content);
+    return output.filter((fileInfo) => !!fileInfo && !!fileInfo.fileContent);
   };
 
+  /**
+   * @param templatesToRender
+   * @param configuration
+   * @returns {Promise<TranslatorIO[]>}
+   */
   createMultipleFileInfos = async (templatesToRender, configuration) => {
     const { routes } = configuration;
-    const { fileNames, generateRouteTypes, generateClient } = configuration.config;
+    const { fileNames, generateRouteTypes, generateClient } =
+      configuration.config;
+    /**
+     * @type {TranslatorIO[]}
+     */
     const modularApiFileInfos = [];
 
     if (routes.$outOfModule) {
       if (generateRouteTypes) {
-        const outOfModuleRouteContent = await this.templates.renderTemplate(templatesToRender.routeTypes, {
-          ...configuration,
-          route: configuration.routes.$outOfModule,
-        });
+        const outOfModuleRouteContent = this.templatesWorker.renderTemplate(
+          templatesToRender.routeTypes,
+          {
+            ...configuration,
+            route: configuration.routes.$outOfModule,
+          },
+        );
 
         modularApiFileInfos.push(
-          this.createOutputFileInfo(configuration, fileNames.outOfModuleApi, outOfModuleRouteContent),
+          ...(await this.createOutputFileInfo(
+            configuration,
+            fileNames.outOfModuleApi,
+            outOfModuleRouteContent,
+          )),
         );
       }
       if (generateClient) {
-        const outOfModuleApiContent = await this.templates.renderTemplate(templatesToRender.api, {
-          ...configuration,
-          route: configuration.routes.$outOfModule,
-        });
+        const outOfModuleApiContent = this.templatesWorker.renderTemplate(
+          templatesToRender.api,
+          {
+            ...configuration,
+            route: configuration.routes.$outOfModule,
+          },
+        );
 
         modularApiFileInfos.push(
-          this.createOutputFileInfo(configuration, fileNames.outOfModuleApi, outOfModuleApiContent),
+          ...(await this.createOutputFileInfo(
+            configuration,
+            fileNames.outOfModuleApi,
+            outOfModuleApiContent,
+          )),
         );
       }
     }
 
     if (routes.combined) {
-      for await (const route of routes.combined) {
+      for (const route of routes.combined) {
         if (generateRouteTypes) {
-          const routeModuleContent = await this.templates.renderTemplate(templatesToRender.routeTypes, {
-            ...configuration,
-            route,
-          });
+          const routeModuleContent = this.templatesWorker.renderTemplate(
+            templatesToRender.routeTypes,
+            {
+              ...configuration,
+              route,
+            },
+          );
 
           modularApiFileInfos.push(
-            this.createOutputFileInfo(configuration, pascalCase(`${route.moduleName}_Route`), routeModuleContent),
+            ...(await this.createOutputFileInfo(
+              configuration,
+              pascalCase(`${route.moduleName}_Route`),
+              routeModuleContent,
+            )),
           );
         }
 
         if (generateClient) {
-          const apiModuleContent = await this.templates.renderTemplate(templatesToRender.api, {
-            ...configuration,
-            route,
-          });
+          const apiModuleContent = this.templatesWorker.renderTemplate(
+            templatesToRender.api,
+            {
+              ...configuration,
+              route,
+            },
+          );
 
           modularApiFileInfos.push(
-            this.createOutputFileInfo(configuration, pascalCase(route.moduleName), apiModuleContent),
+            ...(await this.createOutputFileInfo(
+              configuration,
+              pascalCase(route.moduleName),
+              apiModuleContent,
+            )),
           );
         }
       }
     }
 
     return [
-      this.createOutputFileInfo(
+      ...(await this.createOutputFileInfo(
         configuration,
         fileNames.dataContracts,
-        await this.templates.renderTemplate(templatesToRender.dataContracts, configuration),
-      ),
-      generateClient &&
-        this.createOutputFileInfo(
+        this.templatesWorker.renderTemplate(
+          templatesToRender.dataContracts,
           configuration,
-          fileNames.httpClient,
-          await this.templates.renderTemplate(templatesToRender.httpClient, configuration),
         ),
+      )),
+      ...(generateClient
+        ? await this.createOutputFileInfo(
+            configuration,
+            fileNames.httpClient,
+            this.templatesWorker.renderTemplate(
+              templatesToRender.httpClient,
+              configuration,
+            ),
+          )
+        : []),
       ...modularApiFileInfos,
     ];
   };
 
+  /**
+   *
+   * @param templatesToRender
+   * @param configuration
+   * @returns {Promise<TranslatorIO[]>}
+   */
   createSingleFileInfo = async (templatesToRender, configuration) => {
     const { generateRouteTypes, generateClient } = configuration.config;
 
-    return [
-      this.createOutputFileInfo(
-        configuration,
-        configuration.fileName,
-        _.compact([
-          await this.templates.renderTemplate(templatesToRender.dataContracts, configuration),
-          generateRouteTypes && (await this.templates.renderTemplate(templatesToRender.routeTypes, configuration)),
-          generateClient && (await this.templates.renderTemplate(templatesToRender.httpClient, configuration)),
-          generateClient && (await this.templates.renderTemplate(templatesToRender.api, configuration)),
-        ]).join("\n"),
-      ),
-    ];
+    return await this.createOutputFileInfo(
+      configuration,
+      configuration.fileName,
+      _.compact([
+        this.templatesWorker.renderTemplate(
+          templatesToRender.dataContracts,
+          configuration,
+        ),
+        generateRouteTypes &&
+          this.templatesWorker.renderTemplate(
+            templatesToRender.routeTypes,
+            configuration,
+          ),
+        generateClient &&
+          this.templatesWorker.renderTemplate(
+            templatesToRender.httpClient,
+            configuration,
+          ),
+        generateClient &&
+          this.templatesWorker.renderTemplate(
+            templatesToRender.api,
+            configuration,
+          ),
+      ]).join('\n'),
+    );
   };
 
-  createOutputFileInfo = (configuration, fileName, content) => {
-    const fixedFileName = this.fileSystem.cropExtension(fileName);
+  /**
+   *
+   * @param configuration
+   * @param fileNameFull
+   * @param content
+   * @returns {Promise<TranslatorIO[]>}
+   */
+  createOutputFileInfo = async (configuration, fileNameFull, content) => {
+    const fileName = this.fileSystem.cropExtension(fileNameFull);
+    const fileExtension = ts.Extension.Ts;
 
     if (configuration.translateToJavaScript) {
-      const { sourceContent, declarationContent } = translateToJS(`${fixedFileName}${ts.Extension.Ts}`, content);
-
-      this.logger.debug("generating output for", `${fixedFileName}${ts.Extension.Js}`);
-      this.logger.debug(sourceContent);
-
-      this.logger.debug("generating output for", `${fixedFileName}${ts.Extension.Js}`);
-      this.logger.debug(declarationContent);
+      this.logger.debug('using js translator for', fileName);
+      return await this.javascriptTranslator.translate({
+        fileName: fileName,
+        fileExtension: fileExtension,
+        fileContent: content,
+      });
+    }
 
-      return {
-        name: `${fixedFileName}${ts.Extension.Js}`,
-        content: this.codeFormatter.formatCode(sourceContent),
-        declaration: {
-          name: `${fixedFileName}${ts.Extension.Dts}`,
-          content: this.codeFormatter.formatCode(declarationContent),
-        },
-      };
+    if (configuration.customTranslator) {
+      this.logger.debug('using custom translator for', fileName);
+      return await configuration.customTranslator.translate({
+        fileName: fileName,
+        fileExtension: fileExtension,
+        fileContent: content,
+      });
     }
 
-    this.logger.debug("generating output for", `${fixedFileName}${ts.Extension.Js}`);
-    this.logger.debug(content);
+    this.logger.debug('generating output for', `${fileName}${fileExtension}`);
 
-    return {
-      name: `${fixedFileName}${ts.Extension.Ts}`,
-      content: this.codeFormatter.formatCode(content),
-      declaration: null,
-    };
+    return [
+      {
+        fileName,
+        fileExtension: fileExtension,
+        fileContent: await this.codeFormatter.formatCode(content),
+      },
+    ];
   };
 
   createApiConfig = (swaggerSchema) => {
     const { info, servers, host, basePath, externalDocs, tags } = swaggerSchema;
-    const server = (servers && servers[0]) || { url: "" };
-    const { title = "No title", version, description: schemaDescription = "" } = info || {};
+    const server = (servers && servers[0]) || { url: '' };
+    const { title = 'No title', version } = info || {};
     const { url: serverUrl } = server;
 
     return {
@@ -445,8 +544,8 @@ class CodeGenProcess {
       host,
       externalDocs: _.merge(
         {
-          url: "",
-          description: "",
+          url: '',
+          description: '',
         },
         externalDocs,
       ),
@@ -456,6 +555,15 @@ class CodeGenProcess {
       version,
     };
   };
+
+  injectClassInstance = (key, value) => {
+    this[key] = value;
+    PATCHABLE_INSTANCES.forEach((instanceKey) => {
+      if (instanceKey !== key && key in this[instanceKey]) {
+        this[instanceKey][key] = value;
+      }
+    });
+  };
 }
 
 module.exports = {