swagger-typescript-api 12.0.4 → 13.0.0

package/src/commands/generate-templates/configuration.js

@@ -1,5 +1,5 @@
-const { objectAssign } = require("../../util/object-assign");
-const { HTTP_CLIENT, PROJECT_VERSION } = require("../../constants");
+const { objectAssign } = require('../../util/object-assign');
+const { HTTP_CLIENT, PROJECT_VERSION } = require('../../constants');
 
 /**
  * @type {GenerateTemplatesParams}}

package/src/commands/generate-templates/index.js

@@ -6,8 +6,7 @@
 // License text available at https://opensource.org/licenses/MIT
 // Repository https://github.com/acacode/swagger-typescript-api
 
-const _ = require("lodash");
-const { TemplatesGenProcess } = require("./templates-gen-process");
+const { TemplatesGenProcess } = require('./templates-gen-process');
 
 module.exports = {
   generateTemplates: async (config) => {

package/src/commands/generate-templates/templates-gen-process.js

@@ -1,8 +1,7 @@
-const _ = require("lodash");
-const { TemplatesGenConfig } = require("./configuration");
-const { FileSystem } = require("../../util/file-system");
-const { Logger } = require("../../util/logger");
-const path = require("path");
+const { TemplatesGenConfig } = require('./configuration');
+const { FileSystem } = require('../../util/file-system');
+const { Logger } = require('../../util/logger');
+const path = require('path');
 
 class TemplatesGenProcess {
   /**
@@ -18,33 +17,35 @@ class TemplatesGenProcess {
    */
   logger;
 
-  rootDir = path.resolve(__dirname, "../../../");
+  rootDir = path.resolve(__dirname, '../../../');
 
   paths = {
-    baseTemplates: "templates/base",
-    httpClientTemplates: "templates/base/http-clients",
-    moduleApiTemplates: "templates/modular",
-    defaultApiTemplates: "templates/default",
+    baseTemplates: 'templates/base',
+    httpClientTemplates: 'templates/base/http-clients',
+    moduleApiTemplates: 'templates/modular',
+    defaultApiTemplates: 'templates/default',
   };
 
-  importTemplatePrefixes = ["@base", "@modular", "@default"];
+  importTemplatePrefixes = ['@base', '@modular', '@default'];
 
   constructor(config) {
     this.config = new TemplatesGenConfig(config);
-    this.logger = new Logger(this.config);
-    this.fileSystem = new FileSystem();
+    this.logger = new Logger(this);
+    this.fileSystem = new FileSystem(this);
   }
 
   /**
    * @return {Promise<GenerateTemplatesOutput>}
    */
   async start() {
-    this.logger.event('start generating source templates ".ejs" for code generator');
+    this.logger.event(
+      'start generating source templates ".ejs" for code generator',
+    );
 
     const templates = this.getTemplates();
 
     if (this.config.output) {
-      this.logger.log("preparing output directory for source templates");
+      this.logger.log('preparing output directory for source templates');
       const outputPath = path.resolve(process.cwd(), this.config.output);
 
       if (this.fileSystem.pathIsExist(outputPath)) {
@@ -59,8 +60,10 @@ class TemplatesGenProcess {
         const templateName = this.fileSystem.cropExtension(template.name);
         const templateEjsPath = path.resolve(outputPath, `${templateName}.ejs`);
         const templateEtaPath = path.resolve(outputPath, `${templateName}.eta`);
-        const templateEjsPathExist = this.fileSystem.pathIsExist(templateEjsPath);
-        const templateEtaPathExist = this.fileSystem.pathIsExist(templateEtaPath);
+        const templateEjsPathExist =
+          this.fileSystem.pathIsExist(templateEjsPath);
+        const templateEtaPathExist =
+          this.fileSystem.pathIsExist(templateEtaPath);
 
         const templateNotExist = !templateEjsPathExist && !templateEtaPathExist;
 
@@ -90,7 +93,9 @@ class TemplatesGenProcess {
         }
       });
 
-      this.logger.success(`source templates has been successfully created in "${outputPath}"`);
+      this.logger.success(
+        `source templates has been successfully created in "${outputPath}"`,
+      );
     }
 
     return {
@@ -102,27 +107,37 @@ class TemplatesGenProcess {
 
   getTemplates = () => {
     const outputFiles = [];
-    const baseTemplates = this.getTemplateNamesFromDir(this.paths.baseTemplates);
-    const httpClientTemplates = this.getTemplateNamesFromDir(this.paths.httpClientTemplates);
-    const apiTemplatesPath = this.config.modular ? this.paths.moduleApiTemplates : this.paths.defaultApiTemplates;
+    const baseTemplates = this.getTemplateNamesFromDir(
+      this.paths.baseTemplates,
+    );
+    const httpClientTemplates = this.getTemplateNamesFromDir(
+      this.paths.httpClientTemplates,
+    );
+    const apiTemplatesPath = this.config.modular
+      ? this.paths.moduleApiTemplates
+      : this.paths.defaultApiTemplates;
     const apiTemplates = this.getTemplateNamesFromDir(apiTemplatesPath);
 
     const usingHttpClientTemplate = httpClientTemplates.find((template) =>
       template.startsWith(`${this.config.httpClientType}-`),
     );
 
-    let httpClientTemplateContent = "";
+    let httpClientTemplateContent = '';
 
     if (usingHttpClientTemplate) {
       httpClientTemplateContent = this.fixTemplateContent(
-        this.getTemplateContent(`${this.paths.httpClientTemplates}/${usingHttpClientTemplate}`),
+        this.getTemplateContent(
+          `${this.paths.httpClientTemplates}/${usingHttpClientTemplate}`,
+        ),
       );
     }
 
     for (const fileName of baseTemplates) {
       const templateContent =
-        (fileName === "http-client.ejs" && httpClientTemplateContent) ||
-        this.fixTemplateContent(this.getTemplateContent(`${this.paths.baseTemplates}/${fileName}`));
+        (fileName === 'http-client.ejs' && httpClientTemplateContent) ||
+        this.fixTemplateContent(
+          this.getTemplateContent(`${this.paths.baseTemplates}/${fileName}`),
+        );
 
       outputFiles.push({
         name: fileName,
@@ -133,7 +148,9 @@ class TemplatesGenProcess {
     for (const fileName of apiTemplates) {
       outputFiles.push({
         name: fileName,
-        content: this.fixTemplateContent(this.getTemplateContent(`${apiTemplatesPath}/${fileName}`)),
+        content: this.fixTemplateContent(
+          this.getTemplateContent(`${apiTemplatesPath}/${fileName}`),
+        ),
       });
     }
 
@@ -143,32 +160,42 @@ class TemplatesGenProcess {
   fixTemplateContent = (content) => {
     // includeFile("@base/
     const importsRegExp1 = new RegExp(
-      `includeFile\\\("(${this.importTemplatePrefixes.map((v) => `(${v})`).join("|")})\/`,
-      "g",
+      `includeFile\\("(${this.importTemplatePrefixes
+        .map((v) => `(${v})`)
+        .join('|')})/`,
+      'g',
     );
     // includeFile(`@base/
     const importsRegExp2 = new RegExp(
-      `includeFile\\\(\`(${this.importTemplatePrefixes.map((v) => `(${v})`).join("|")})\/`,
-      "g",
+      `includeFile\\(\`(${this.importTemplatePrefixes
+        .map((v) => `(${v})`)
+        .join('|')})/`,
+      'g',
     );
     // includeFile('@base/
     const importsRegExp3 = new RegExp(
-      `includeFile\\\(\'(${this.importTemplatePrefixes.map((v) => `(${v})`).join("|")})\/`,
-      "g",
+      `includeFile\\('(${this.importTemplatePrefixes
+        .map((v) => `(${v})`)
+        .join('|')})/`,
+      'g',
     );
 
     return content
       .replace(importsRegExp1, 'includeFile("./')
-      .replace(importsRegExp2, "includeFile(`./")
+      .replace(importsRegExp2, 'includeFile(`./')
       .replace(importsRegExp3, "includeFile('./");
   };
 
   getTemplateNamesFromDir = (dir) => {
-    return this.fileSystem.readDir(path.resolve(this.rootDir, dir)).filter((file) => file.endsWith(".ejs"));
+    return this.fileSystem
+      .readDir(path.resolve(this.rootDir, dir))
+      .filter((file) => file.endsWith('.ejs'));
   };
 
   getTemplateContent = (pathToFile) => {
-    return this.fileSystem.getFileContent(path.resolve(this.rootDir, pathToFile));
+    return this.fileSystem.getFileContent(
+      path.resolve(this.rootDir, pathToFile),
+    );
   };
 }
 

package/src/component-type-name-resolver.js

@@ -0,0 +1,44 @@
+const { getRandomInt } = require('./util/random');
+const { NameResolver } = require('./util/name-resolver');
+
+class ComponentTypeNameResolver extends NameResolver {
+  counter = 1;
+  fallbackNameCounter = 1;
+  countersByVariant = new Map();
+
+  /**
+   * @param {CodeGenConfig} config;
+   * @param {Logger} logger;
+   * @param {string[]} reservedNames
+   */
+  constructor(config, logger, reservedNames) {
+    super(config, logger, reservedNames, (variants) => {
+      const randomVariant = variants[getRandomInt(0, variants.length - 1)];
+      if (randomVariant) {
+        if (!this.countersByVariant.has(randomVariant)) {
+          this.countersByVariant.set(randomVariant, 0);
+        }
+        const variantCounter = this.countersByVariant.get(randomVariant) + 1;
+        this.countersByVariant.set(randomVariant, variantCounter);
+        const dirtyResolvedName = `${randomVariant}${variantCounter}`;
+        this.logger.debug(
+          'generated dirty resolved type name for component - ',
+          dirtyResolvedName,
+        );
+        return dirtyResolvedName;
+      }
+
+      const fallbackName = `${this.config.componentTypeNameResolver}${this
+        .fallbackNameCounter++}`;
+      this.logger.debug(
+        'generated fallback type name for component - ',
+        fallbackName,
+      );
+      return fallbackName;
+    });
+  }
+}
+
+module.exports = {
+  ComponentTypeNameResolver,
+};