internal: reorganize name-resolver util

js2me · js2me · commit fb20a04655e5 · 2022-11-22T00:32:17.000+06:00
diff --git a/index.d.ts b/index.d.ts
@@ -199,6 +199,12 @@ interface GenerateApiParamsBase {
    * ```
    */
   customTranslator?: new () => typeof import("./src/translators/translator").Translator;
+  /** fallback name for enum key resolver */
+  enumKeyResolverName?: string;
+  /** fallback name for type name resolver */
+  typeNameResolverName?: string;
+  /** fallback name for specific arg name resolver */
+  specificArgNameResolverName?: string;
 }
 
 type CodeGenConstruct = {
@@ -549,12 +555,15 @@ export interface GenerateApiConfiguration {
     enumNamesAsValues: boolean;
     version: string;
     compilerTsConfig: Record<string, any>;
+    enumKeyResolverName: string;
+    typeNameResolverName: string;
+    specificArgNameResolverName: string;
     /** do not use constructor args, it can break functionality of this property, just send class reference */
     customTranslator?: new (...args: never[]) => typeof import("./src/translators/translator").Translator;
     internalTemplateOptions: {
       addUtilRequiredKeysType: boolean;
     };
-    componentTypeNameResolver: typeof import("./src/util/name-resolver").ComponentTypeNameResolver;
+    componentTypeNameResolver: typeof import("./src/component-type-name-resolver").ComponentTypeNameResolver;
     fileNames: {
       dataContracts: string;
       routeTypes: string;
diff --git a/src/code-gen-process.js b/src/code-gen-process.js
@@ -5,7 +5,7 @@ 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-parser/schema-routes.js");
+const { SchemaRoutes } = require("./schema-routes/schema-routes.js");
 const { CodeGenConfig } = require("./configuration.js");
 const { SchemaWalker } = require("./schema-walker");
 const { FileSystem } = require("./util/file-system");
diff --git a/src/component-type-name-resolver.js b/src/component-type-name-resolver.js
@@ -0,0 +1,29 @@
+const { getRandomInt } = require("./util/random");
+const { pascalCase } = require("./util/pascal-case");
+const { NameResolver } = require("./util/name-resolver");
+
+class ComponentTypeNameResolver extends NameResolver {
+  counter = 1;
+  fallbackNameCounter = 1;
+
+  /**
+   * @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)];
+      const generatedVariant = pascalCase(
+        (randomVariant && `${randomVariant}${this.counter++}`) ||
+          `${this.config.componentTypeNameResolver}${this.fallbackNameCounter++}`,
+      );
+      this.logger.debug("generated fallback type name for component - ", generatedVariant);
+      return generatedVariant;
+    });
+  }
+}
+
+module.exports = {
+  ComponentTypeNameResolver,
+};
diff --git a/src/configuration.js b/src/configuration.js
@@ -1,7 +1,7 @@
 const { objectAssign } = require("./util/object-assign");
 const _ = require("lodash");
 const CONSTANTS = require("./constants");
-const { ComponentTypeNameResolver } = require("./util/name-resolver");
+const { ComponentTypeNameResolver } = require("./component-type-name-resolver");
 const { cosmiconfigSync } = require("cosmiconfig");
 const ts = require("typescript");
 
@@ -36,7 +36,7 @@ const TsCodeGenKeyword = {
 class CodeGenConfig {
   version = CONSTANTS.PROJECT_VERSION;
   /** CLI flag */
-  templates = "../templates/default";
+  templates = "";
   /** CLI flag */
   generateResponses = false;
   /** CLI flag */
@@ -135,7 +135,8 @@ class CodeGenConfig {
   enumKeyPrefix = "";
   enumKeySuffix = "";
   patch = false;
-  componentTypeNameResolver = new ComponentTypeNameResolver(null, []);
+  /** @type {ComponentTypeNameResolver} */
+  componentTypeNameResolver;
   /** name of the main exported class */
   apiClassName = "Api";
   debug = false;
@@ -159,6 +160,10 @@ class CodeGenConfig {
   fixInvalidTypeNamePrefix = "Type";
   fixInvalidEnumKeyPrefix = "Value";
 
+  enumKeyResolverName = "Value";
+  typeNameResolverName = "ComponentType";
+  specificArgNameResolverName = "arg";
+
   successResponseStatusRange = [200, 299];
 
   /** @type {ExtractingOptions} */
@@ -360,6 +365,7 @@ class CodeGenConfig {
 
     this.jsPrimitiveTypes = [this.Ts.Keyword.Number, this.Ts.Keyword.String, this.Ts.Keyword.Boolean];
     this.jsEmptyTypes = [this.Ts.Keyword.Null, this.Ts.Keyword.Undefined];
+    this.componentTypeNameResolver = new ComponentTypeNameResolver(this, null, []);
   }
 
   /**
diff --git a/src/schema-parser/base-schema-parsers/enum.js b/src/schema-parser/base-schema-parsers/enum.js
@@ -2,8 +2,17 @@ const { MonoSchemaParser } = require("../mono-schema-parser");
 const { pascalCase } = require("../../util/pascal-case");
 const _ = require("lodash");
 const { SCHEMA_TYPES } = require("../../constants");
+const { EnumKeyResolver } = require("../util/enum-key-resolver");
 
 class EnumSchemaParser extends MonoSchemaParser {
+  /** @type {EnumKeyResolver} */
+  enumKeyResolver;
+
+  constructor(...args) {
+    super(...args);
+    this.enumKeyResolver = new EnumKeyResolver(this.config, this.logger, []);
+  }
+
   parse() {
     const pathTypeName = this.buildTypeNameFromPath();
 
@@ -113,12 +122,13 @@ class EnumSchemaParser extends MonoSchemaParser {
       });
     }
 
-    return (
-      formatted ||
-      this.typeNameFormatter.format(`${value}`, {
+    if (!formatted) {
+      formatted = this.typeNameFormatter.format(`${value}`, {
         type: "enum-key",
-      })
-    );
+      });
+    }
+
+    return this.enumKeyResolver.resolve([formatted]);
   };
 }
 
diff --git a/src/schema-parser/util/enum-key-resolver.js b/src/schema-parser/util/enum-key-resolver.js
@@ -0,0 +1,22 @@
+const { NameResolver } = require("../../util/name-resolver");
+
+class EnumKeyResolver extends NameResolver {
+  counter = 1;
+  /**
+   * @param {CodeGenConfig} config;
+   * @param {Logger} logger;
+   * @param {string[]} reservedNames
+   */
+  constructor(config, logger, reservedNames) {
+    super(config, logger, reservedNames, (variants) => {
+      const generatedVariant =
+        (variants[0] && `${variants[0]}${this.counter++}`) || `${this.config.enumKeyResolverName}${this.counter++}`;
+      this.logger.debug("generated fallback type name for enum key - ", generatedVariant);
+      return generatedVariant;
+    });
+  }
+}
+
+module.exports = {
+  EnumKeyResolver,
+};
diff --git a/src/schema-routes/schema-routes.js b/src/schema-routes/schema-routes.js
@@ -1,6 +1,6 @@
 const _ = require("lodash");
 const { generateId } = require("../util/id.js");
-const { SpecificArgNameResolver } = require("../util/name-resolver.js");
+const { SpecificArgNameResolver } = require("./util/specific-arg-name-resolver");
 const {
   DEFAULT_BODY_ARG_NAME,
   RESERVED_BODY_ARG_NAMES,
@@ -810,7 +810,7 @@ class SchemaRoutes {
       ? this.schemaParserFabric.getInlineParseContent(headersObjectSchema, null, [routeName])
       : null;
 
-    const nameResolver = new SpecificArgNameResolver(this.logger, pathArgsNames);
+    const nameResolver = new SpecificArgNameResolver(this.config, this.logger, pathArgsNames);
 
     const specificArgs = {
       query: queryType
diff --git a/src/schema-routes/util/specific-arg-name-resolver.js b/src/schema-routes/util/specific-arg-name-resolver.js
@@ -0,0 +1,23 @@
+const { NameResolver } = require("../../util/name-resolver");
+
+class SpecificArgNameResolver extends NameResolver {
+  counter = 1;
+  /**
+   * @param {CodeGenConfig} config;
+   * @param {Logger} logger;
+   * @param {string[]} reservedNames
+   */
+  constructor(config, logger, reservedNames) {
+    super(config, logger, reservedNames, (variants) => {
+      const generatedVariant =
+        (variants[0] && `${variants[0]}${this.counter++}`) ||
+        `${this.config.specificArgNameResolverName}${this.counter++}`;
+      this.logger.debug("generated fallback type name for specific arg - ", generatedVariant);
+      return generatedVariant;
+    });
+  }
+}
+
+module.exports = {
+  SpecificArgNameResolver,
+};
diff --git a/src/templates-worker.js b/src/templates-worker.js
@@ -28,12 +28,17 @@ class TemplatesWorker {
     this.getRenderTemplateData = getRenderTemplateData;
   }
 
-  getTemplatePaths = ({ templates, modular }) => {
+  /**
+   *
+   * @param config {CodeGenConfig}
+   * @returns {CodeGenConfig.templatePaths}
+   */
+  getTemplatePaths = (config) => {
     const baseTemplatesPath = resolve(__dirname, "../templates/base");
     const defaultTemplatesPath = resolve(__dirname, "../templates/default");
     const modularTemplatesPath = resolve(__dirname, "../templates/modular");
-    const originalTemplatesPath = modular ? modularTemplatesPath : defaultTemplatesPath;
-    const customTemplatesPath = (templates && resolve(process.cwd(), templates)) || null;
+    const originalTemplatesPath = config.modular ? modularTemplatesPath : defaultTemplatesPath;
+    const customTemplatesPath = (config.templates && resolve(process.cwd(), config.templates)) || null;
 
     return {
       /** `templates/base` */
@@ -63,7 +68,10 @@ class TemplatesWorker {
     const isPath = _.startsWith(packageOrPath, "./") || _.startsWith(packageOrPath, "../");
 
     if (isPath) {
-      return require(path.resolve(this.config.templates, packageOrPath));
+      return require(path.resolve(
+        this.config.templatePaths.custom || this.config.templatePaths.original,
+        packageOrPath,
+      ));
     }
 
     return require(packageOrPath);
diff --git a/src/type-name-formatter.js b/src/type-name-formatter.js
@@ -70,10 +70,6 @@ class TypeNameFormatter {
   fixModelName = (name, options) => {
     const { type } = options || {};
 
-    if (type === "enum-key") {
-      name = name.replace("+", "Plus").replace("-", "Minus");
-    }
-
     if (!this.isValidName(name)) {
       if (!/^[a-zA-Z_$]/g.test(name)) {
         const fixPrefix =
diff --git a/src/util/name-resolver.js b/src/util/name-resolver.js
@@ -1,21 +1,21 @@
 const _ = require("lodash");
-const { getRandomInt } = require("./random.js");
-const { pascalCase } = require("./pascal-case");
 
 class NameResolver {
   reservedNames = [];
   getFallbackName = null;
 
-  /**
-   * @type {Logger}
-   */
+  /** @type {CodeGenConfig} */
+  config;
+  /** @type {Logger} */
   logger;
 
   /**
+   * @param {CodeGenConfig} config;
    * @param {Logger} logger;
    * @param {string[]} reservedNames
    */
-  constructor(logger, reservedNames, getFallbackName) {
+  constructor(config, logger, reservedNames, getFallbackName) {
+    this.config = config;
     this.logger = logger;
     this.getFallbackName = getFallbackName;
     this.reserve(reservedNames);
@@ -48,7 +48,6 @@ class NameResolver {
    * @returns {string | null}
    */
   resolve(variants, resolver) {
-    this.logger.debug("resolving name with using", variants);
     if (typeof resolver === "function") {
       let usageName = null;
       while (usageName === null) {
@@ -89,42 +88,6 @@ class NameResolver {
   }
 }
 
-class SpecificArgNameResolver extends NameResolver {
-  counter = 1;
-  /**
-   * @param {Logger} logger;
-   * @param {string[]} reservedNames
-   */
-  constructor(logger, reservedNames) {
-    super(logger, reservedNames, (variants) => {
-      const generatedVariant = (variants[0] && `${variants[0]}${this.counter++}`) || `arg${this.counter++}`;
-      this.logger.debug("generated fallback type name for specific arg - ", generatedVariant);
-      return generatedVariant;
-    });
-  }
-}
-
-class ComponentTypeNameResolver extends NameResolver {
-  counter = 1;
-  fallbackNameCounter = 1;
-
-  /**
-   * @param {Logger} logger;
-   * @param {string[]} reservedNames
-   */
-  constructor(logger, reservedNames) {
-    super(logger, reservedNames, (variants) => {
-      const randomVariant = variants[getRandomInt(0, variants.length - 1)];
-      const generatedVariant = pascalCase(
-        (randomVariant && `${randomVariant}${this.counter++}`) || `ComponentType${this.fallbackNameCounter++}`,
-      );
-      this.logger.debug("generated fallback type name for component - ", generatedVariant);
-      return generatedVariant;
-    });
-  }
-}
-
 module.exports = {
-  SpecificArgNameResolver,
-  ComponentTypeNameResolver,
+  NameResolver,
 };
