feature: ability to customize resolving process of the extracting type names (extractingOptions nodejs option)

docs: update docs for `extraTemplates` option
fix: problem with default name of single api file (Api.ts)
fix: problem based with tuple types (#445)
fix: problem with `defaultResponseType` declaration type

Author: js2me

CHANGELOG.md

@@ -22,7 +22,31 @@ typeSuffix?: string;
 enumKeyPrefix?: string;
 enumKeySuffix?: string;
 ```
+feature: ability to customize resolving process of the extracting type names (`extractingOptions` nodejs option)  
+```ts
+extractingOptions = {
+  // requestBodySuffix: ["Payload", "Body", "Input"],
+  // or
+  // requestBodyNameResolver: (typeName, reservedNames) => string;
+
+  // requestParamsSuffix: ["Params"],
+  // or
+  // requestParamsNameResolver: (typeName, reservedNames) => string;
+
+  // responseBodySuffix: ["Data", "Result", "Output"],
+  // or
+  // responseBodyNameResolver: (typeName, reservedNames) => string;
+
+  // responseErrorSuffix: ["Error", "Fail", "Fails", "ErrorData", "HttpError", "BadResponse"],
+  // or
+  // responseErrorNameResolver: (typeName, reservedNames) => string;
+}
+```
 docs: update docs for `extraTemplates` option  
+fix: problem with default name of single api file (Api.ts)  
+fix: problem based with tuple types (#445)  
+fix: problem with `defaultResponseType` declaration type  
+
 
 # 11.1.3  
 

README.md

@@ -139,7 +139,15 @@ generateApi({
   generateUnionEnums: false,
   typePrefix: '',
   typeSuffix: '',
+  enumKeyPrefix: '',
+  enumKeySuffix: '',
   addReadonly: false,
+  extractingOptions: {
+    requestBodySuffix: ["Payload", "Body", "Input"],
+    requestParamsSuffix: ["Params"],
+    responseBodySuffix: ["Data", "Result", "Output"],
+    responseErrorSuffix: ["Error", "Fail", "Fails", "ErrorData", "HttpError", "BadResponse"],
+  },
   /** allow to generate extra files based with this extra templates, see more below */
   extraTemplates: [],
   anotherArrayType: false,

index.d.ts

@@ -106,7 +106,7 @@ interface GenerateApiParamsBase {
   /**
    * default type for empty response schema (default: "void")
    */
-  defaultResponseType?: boolean;
+  defaultResponseType?: string;
   /**
    * Ability to send HttpClient instance to Api constructor
    */
@@ -151,6 +151,7 @@ interface GenerateApiParamsBase {
   typePrefix?: string;
   /** suffix string value for type names */
   typeSuffix?: string;
+  extractingOptions?: Partial<ExtractingOptions>;
 }
 
 type CodeGenConstruct = {
@@ -421,6 +422,17 @@ export enum SCHEMA_TYPES {
 
 type MAIN_SCHEMA_TYPES = SCHEMA_TYPES.PRIMITIVE | SCHEMA_TYPES.OBJECT | SCHEMA_TYPES.ENUM;
 
+type ExtractingOptions = {
+  requestBodySuffix: string[];
+  responseBodySuffix: string[];
+  responseErrorSuffix: string[];
+  requestParamsSuffix: string[];
+  requestBodyNameResolver: (name: string, reservedNames: string) => string | undefined;
+  responseBodyNameResolver: (name: string, reservedNames: string) => string | undefined;
+  responseErrorNameResolver: (name: string, reservedNames: string) => string | undefined;
+  requestParamsNameResolver: (name: string, reservedNames: string) => string | undefined;
+};
+
 export interface GenerateApiConfiguration {
   apiConfig: {
     baseUrl: string;
@@ -470,7 +482,7 @@ export interface GenerateApiConfiguration {
     extractEnums: boolean;
     fixInvalidTypeNamePrefix: string;
     fixInvalidEnumKeyPrefix: string;
-    defaultResponseType: boolean;
+    defaultResponseType: string;
     toJS: boolean;
     disableThrowOnError: boolean;
     silent: boolean;
@@ -502,6 +514,7 @@ export interface GenerateApiConfiguration {
     routeNameDuplicatesMap: Map<string, string>;
     apiClassName: string;
     requestOptions?: import("node-fetch").RequestInit;
+    extractingOptions: ExtractingOptions;
   };
   modelTypes: ModelType[];
   rawModelTypes: SchemaComponent[];

index.js

@@ -37,7 +37,7 @@ const program = cli({
     {
       flags: "-n, --name <string>",
       description: "name of output typescript api file",
-      default: `${codeGenBaseConfig.apiClassName}.ts`,
+      default: codeGenBaseConfig.fileName,
     },
     {
       flags: "-t, --templates <string>",

src/code-gen-process.js

@@ -81,6 +81,7 @@ class CodeGenProcess {
       this.templates,
       this.typeName,
     );
+    this.config.componentTypeNameResolver.logger = this.logger;
   }
 
   async start() {
@@ -169,9 +170,11 @@ class CodeGenProcess {
 
     if (this.fileSystem.pathIsExist(this.config.output)) {
       if (this.config.cleanOutput) {
+        this.logger.debug(`cleaning dir ${this.config.output}`);
         this.fileSystem.cleanDir(this.config.output);
       }
     } else {
+      this.logger.debug(`path ${this.config.output} is not exist. creating dir by this path`);
       this.fileSystem.createDir(this.config.output);
     }
 
@@ -398,15 +401,11 @@ class CodeGenProcess {
     if (configuration.translateToJavaScript) {
       const { sourceContent, declarationContent } = translateToJS(`${fixedFileName}${ts.Extension.Ts}`, content);
 
-      if (this.config.debug) {
-        console.info("generating output for", `${fixedFileName}${ts.Extension.Js}`);
-        console.info(sourceContent);
-      }
+      this.logger.debug("generating output for", `${fixedFileName}${ts.Extension.Js}`);
+      this.logger.debug(sourceContent);
 
-      if (this.config.debug) {
-        console.info("generating output for", `${fixedFileName}${ts.Extension.Dts}`);
-        console.info(declarationContent);
-      }
+      this.logger.debug("generating output for", `${fixedFileName}${ts.Extension.Js}`);
+      this.logger.debug(declarationContent);
 
       return {
         name: `${fixedFileName}${ts.Extension.Js}`,
@@ -418,10 +417,8 @@ class CodeGenProcess {
       };
     }
 
-    if (this.config.debug) {
-      console.info("generating output for", `${fixedFileName}${ts.Extension.Ts}`);
-      console.info(content);
-    }
+    this.logger.debug("generating output for", `${fixedFileName}${ts.Extension.Js}`);
+    this.logger.debug(content);
 
     return {
       name: `${fixedFileName}${ts.Extension.Ts}`,

src/configuration.js

@@ -134,7 +134,7 @@ class CodeGenConfig {
   enumKeyPrefix = "";
   enumKeySuffix = "";
   patch = false;
-  componentTypeNameResolver = new ComponentTypeNameResolver([]);
+  componentTypeNameResolver = new ComponentTypeNameResolver(null, []);
   /** name of the main exported class */
   apiClassName = "Api";
   debug = false;
@@ -149,7 +149,7 @@ class CodeGenConfig {
   url = "";
   cleanOutput = false;
   spec = null;
-  fileName = "";
+  fileName = "Api.ts";
   authorizationToken = void 0;
   requestOptions = null;
 
@@ -160,6 +160,14 @@ class CodeGenConfig {
 
   successResponseStatusRange = [200, 299];
 
+  /** @type {ExtractingOptions} */
+  extractingOptions = {
+    requestBodySuffix: ["Payload", "Body", "Input"],
+    requestParamsSuffix: ["Params"],
+    responseBodySuffix: ["Data", "Result", "Output"],
+    responseErrorSuffix: ["Error", "Fail", "Fails", "ErrorData", "HttpError", "BadResponse"],
+  };
+
   Ts = {
     Keyword: _.cloneDeep(TsKeyword),
     CodeGenKeyword: _.cloneDeep(TsCodeGenKeyword),
@@ -244,6 +252,12 @@ class CodeGenConfig {
     TypeWithGeneric: (typeName, genericArgs) => {
       return `${typeName}${genericArgs.length ? `<${genericArgs.join(",")}>` : ""}`;
     },
+    /**
+     * [$A1, $A2, ...$AN]
+     */
+    Tuple: (values) => {
+      return `[${values.join(", ")}]`;
+    },
   };
 
   /**

src/schema-parser/schema-parser.js

@@ -99,6 +99,19 @@ class SchemaParser {
 
       const refType = this.schemaUtils.getSchemaRefType(schema);
       const $ref = (refType && refType.$ref) || null;
+
+      if (Array.isArray(schema.enum) && Array.isArray(schema.enum[0])) {
+        return this.parseSchema(
+          {
+            oneOf: schema.enum.map((enumNames) => ({
+              type: "array",
+              items: enumNames.map((enumName) => ({ type: "string", enum: [enumName] })),
+            })),
+          },
+          typeName,
+        );
+      }
+
       const keyType = this.getSchemaType(schema);
       const enumNames = this.schemaUtils.getEnumNames(schema);
       let content = null;
@@ -211,7 +224,7 @@ class SchemaParser {
     },
     [SCHEMA_TYPES.PRIMITIVE]: (schema, typeName) => {
       let contentType = null;
-      const { additionalProperties, type, description, $$requiredKeys } = schema || {};
+      const { additionalProperties, type, description, items } = schema || {};
 
       if (type === this.config.Ts.Keyword.Object && additionalProperties) {
         const fieldType = _.isObject(additionalProperties)
@@ -227,6 +240,10 @@ class SchemaParser {
         });
       }
 
+      if (_.isArray(items) && type === SCHEMA_TYPES.ARRAY) {
+        contentType = this.config.Ts.Tuple(items.map((item) => this.getInlineParseContent(item)));
+      }
+
       return {
         ...(_.isObject(schema) ? schema : {}),
         $parsedSchema: true,
@@ -364,7 +381,7 @@ class SchemaParser {
         typeName = this.getSchemaType(schema);
       }
 
-      if (schema.items && !schema.type) {
+      if (schema.items && !Array.isArray(schema.items) && !schema.type) {
         schema.type = SCHEMA_TYPES.ARRAY;
       }
       schemaType = this.getInternalSchemaType(schema);

src/schema-parser/schema-routes.js

@@ -28,6 +28,10 @@ class SchemaRoutes {
    * @type {SchemaParser}
    */
   schemaParser;
+  /**
+   * @type {SchemaUtils}
+   */
+  schemaUtils;
   /**
    * @type {TypeName}
    */
@@ -55,6 +59,7 @@ class SchemaRoutes {
   constructor(config, schemaParser, schemaComponentMap, logger, templates, typeName) {
     this.config = config;
     this.schemaParser = schemaParser;
+    this.schemaUtils = this.schemaParser.schemaUtils;
     this.typeName = typeName;
     this.schemaComponentMap = schemaComponentMap;
     this.logger = logger;
@@ -470,11 +475,11 @@ class SchemaRoutes {
     let typeName = null;
 
     if (this.config.extractRequestBody) {
-      typeName = this.config.componentTypeNameResolver.resolve([
-        pascalCase(`${routeName.usage} Payload`),
-        pascalCase(`${routeName.usage} Body`),
-        pascalCase(`${routeName.usage} Input`),
-      ]);
+      typeName = this.schemaUtils.resolveTypeName(
+        routeName.usage,
+        this.config.extractingOptions.requestBodySuffix,
+        this.config.extractingOptions.requestBodyNameResolver,
+      );
     }
 
     if (routeParams.formData.length) {
@@ -571,7 +576,11 @@ class SchemaRoutes {
     if (fixedSchema) return fixedSchema;
 
     if (extractRequestParams) {
-      const typeName = this.config.componentTypeNameResolver.resolve([pascalCase(`${routeName.usage} Params`)]);
+      const typeName = this.schemaUtils.resolveTypeName(
+        routeName.usage,
+        this.config.extractingOptions.requestParamsSuffix,
+        this.config.extractingOptions.requestParamsNameResolver,
+      );
 
       return this.schemaComponentMap.createComponent("schemas", typeName, { ...schema });
     }
@@ -581,11 +590,11 @@ class SchemaRoutes {
 
   extractResponseBodyIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
     if (responseBodyInfo.responses.length && responseBodyInfo.success && responseBodyInfo.success.schema) {
-      const typeName = this.config.componentTypeNameResolver.resolve([
-        pascalCase(`${routeName.usage} Data`),
-        pascalCase(`${routeName.usage} Result`),
-        pascalCase(`${routeName.usage} Output`),
-      ]);
+      const typeName = this.schemaUtils.resolveTypeName(
+        routeName.usage,
+        this.config.extractingOptions.responseBodySuffix,
+        this.config.extractingOptions.responseBodyNameResolver,
+      );
 
       const idx = responseBodyInfo.responses.indexOf(responseBodyInfo.success.schema);
 
@@ -608,14 +617,11 @@ class SchemaRoutes {
 
   extractResponseErrorIfItNeeded = (routeInfo, responseBodyInfo, routeName) => {
     if (responseBodyInfo.responses.length && responseBodyInfo.error.schemas && responseBodyInfo.error.schemas.length) {
-      const typeName = this.config.componentTypeNameResolver.resolve([
-        pascalCase(`${routeName.usage} Error`),
-        pascalCase(`${routeName.usage} Fail`),
-        pascalCase(`${routeName.usage} Fails`),
-        pascalCase(`${routeName.usage} ErrorData`),
-        pascalCase(`${routeName.usage} HttpError`),
-        pascalCase(`${routeName.usage} BadResponse`),
-      ]);
+      const typeName = this.schemaUtils.resolveTypeName(
+        routeName.usage,
+        this.config.extractingOptions.responseErrorSuffix,
+        this.config.extractingOptions.responseErrorNameResolver,
+      );
 
       const errorSchemas = responseBodyInfo.error.schemas.map(this.getSchemaFromRequestType).filter(Boolean);
 
@@ -765,7 +771,7 @@ class SchemaRoutes {
     const pathType = routeParams.path.length ? this.schemaParser.getInlineParseContent(pathObjectSchema) : null;
     const headersType = routeParams.header.length ? this.schemaParser.getInlineParseContent(headersObjectSchema) : null;
 
-    const nameResolver = new SpecificArgNameResolver(pathArgsNames);
+    const nameResolver = new SpecificArgNameResolver(this.logger, pathArgsNames);
 
     const specificArgs = {
       query: queryType

src/schema-parser/schema-utils.js

@@ -1,6 +1,7 @@
 const _ = require("lodash");
 const { SCHEMA_TYPES } = require("../constants");
 const { internalCase } = require("../util/internal-case");
+const { pascalCase } = require("../util/pascal-case");
 
 class SchemaUtils {
   /**
@@ -143,6 +144,20 @@ class SchemaUtils {
   filterSchemaContents = (contents, filterFn) => {
     return _.uniq(_.filter(contents, (type) => filterFn(type)));
   };
+
+  resolveTypeName = (typeName, suffixes, resolver) => {
+    if (resolver) {
+      return this.config.componentTypeNameResolver.resolve((reserved) => {
+        const variant = resolver(pascalCase(typeName), reserved);
+        if (variant == null) return variant;
+        return pascalCase(variant);
+      });
+    } else {
+      return this.config.componentTypeNameResolver.resolve(
+        suffixes.map((suffix) => pascalCase(`${typeName} ${suffix}`)),
+      );
+    }
+  };
 }
 
 module.exports = {

src/templates.js

@@ -164,8 +164,8 @@ class Templates {
       {
         async: false,
         ...(options || {}),
-        includeFile: (path, payload, options) => {
-          return this.renderTemplate(this.getTemplateContent(path), payload, options);
+        includeFile: (path, configuration, options) => {
+          return this.renderTemplate(this.getTemplateContent(path), configuration, options);
         },
       },
     );