feat: new hook onPreParseSchema;

BREAKING_CHANGE: add ability to custom prefix for autofix invalid enum keys, invalid type names with nodejs options (`fixInvalidTypeNamePrefix: string`, `fixInvalidEnumKeyPrefix: string`); (#344)
BREAKING_CHANGE: by default all component enum schemas (even numeric) extracting as `enum` TS constructions; (#344)
feature: ability to extract all enums from nested types\interfaces to `enum` TS construction using `--extract-enums` option (#344)

Author: js2me

CHANGELOG.md

@@ -8,7 +8,12 @@ onPreBuildRoutePath: (routePath: string) => string | void;
 onBuildRoutePath: (data: BuildRoutePath) => BuildRoutePath | void;
 /** calls before insert path param name into string path interpolation */
 onInsertPathParam: (paramName: string, index: number, arr: BuildRouteParam[], resultRoute: string) => string | void;
-```
+/** calls before parse any kind of schema */
+onPreParseSchema: (originalSchema: any, typeName: string, schemaType: string) => any;
+```  
+BREAKING_CHANGE: add ability to custom prefix for autofix invalid enum keys, invalid type names with nodejs options (`fixInvalidTypeNamePrefix: string`, `fixInvalidEnumKeyPrefix: string`)  
+BREAKING_CHANGE: by default all component enum schemas (even numeric) extracting as `enum` TS constructions (#344)   
+feature: ability to extract all enums from nested types\interfaces to `enum` TS construction using `--extract-enums` option (#344)   
 feature: ability to modify route path params before insert them into string (request url, #446, with using hook `onInsertPathParam`)  
 docs: update docs for `extraTemplates` option  
 
@@ -468,7 +473,7 @@ Features:
 - `--type-suffix` option. Allows to set suffix for data contract name. (issue #191, thanks @the-ult)  
 - `--type-prefix` option. Allows to set prefix for data contract name. (issue #191, thanks @the-ult)  
   Examples [here](./spec/typeSuffixPrefix/schema.ts)  
-- `onFormatTypeName(usageTypeName, rawTypeName)` hook. Allow to format data contract names as you want.  
+- `onFormatTypeName(usageTypeName, rawTypeName, schemaType)` hook. Allow to format data contract names as you want.  
 
 Internal:  
 - rename and split `checkAndRenameModelName` -> `formatModelName`, `fixModelName`  

README.md

@@ -70,11 +70,12 @@ Options:
   --type-prefix <string>        data contract name prefix (default: "")
   --type-suffix <string>        data contract name suffix (default: "")
   --clean-output                clean output folder before generate api. WARNING: May cause data loss (default: false)
-  --api-class-name <string>     name of the api class
+  --api-class-name <string>     name of the api class (default: "Api")
   --patch                       fix up small errors in the swagger source definition (default: false)
   --debug                       additional information about processes inside this tool (default: false)
   --another-array-type          generate array types as Array<Type> (by default Type[]) (default: false)
   --sort-types                  sort fields and types (default: false)
+  --extract-enums               extract all enums from inline interface\type content to typescript enum construction (default: false)
   -h, --help                    display help for command
 
 Commands:
@@ -141,7 +142,9 @@ generateApi({
   addReadonly: false,
   /** allow to generate extra files based with this extra templates, see more below */
   extraTemplates: [],
-  anotherArrayType: false, 
+  anotherArrayType: false,
+  fixInvalidTypeNamePrefix: "Type",
+  fixInvalidEnumKeyPrefix: "Value", 
   codeGenConstructs: (constructs) => ({
     ...constructs,
     RecordType: (key, value) => `MyRecord<key, value>`
@@ -158,8 +161,9 @@ generateApi({
     onCreateRoute: (routeData) => {},
     onCreateRouteName: (routeNameInfo, rawRouteInfo) => {},
     onFormatRouteName: (routeInfo, templateRouteName) => {},
-    onFormatTypeName: (typeName, rawTypeName) => {},
+    onFormatTypeName: (typeName, rawTypeName, schemaType) => {},
     onInit: (configuration) => {},
+    onPreParseSchema: (originalSchema, typeName, schemaType) => {},
     onParseSchema: (originalSchema, parsedSchema) => {},
     onPrepareConfig: (currentConfiguration) => {},
   }

index.d.ts

@@ -136,6 +136,13 @@ interface GenerateApiParamsBase {
   primitiveTypeConstructs?: (struct: PrimitiveTypeStruct) => Partial<PrimitiveTypeStruct>;
 
   codeGenConstructs?: (struct: CodeGenConstruct) => Partial<CodeGenConstruct>;
+
+  /** extract all enums from nested types\interfaces to `enum` construction */
+  extractEnums?: boolean;
+  /** prefix string value needed to fix invalid type names (default: 'Type') */
+  fixInvalidTypeNamePrefix?: string;
+  /** prefix string value needed to fix invalid enum keys (default: 'Value') */
+  fixInvalidEnumKeyPrefix?: string;
 }
 
 type CodeGenConstruct = {
@@ -243,6 +250,8 @@ export interface Hooks {
   onInsertPathParam: (paramName: string, index: number, arr: BuildRouteParam[], resultRoute: string) => string | void;
   /** calls after parse schema component */
   onCreateComponent: (component: SchemaComponent) => SchemaComponent | void;
+  /** calls before parse any kind of schema */
+  onPreParseSchema: (originalSchema: any, typeName: string, schemaType: string) => any;
   /** calls after parse any kind of schema */
   onParseSchema: (originalSchema: any, parsedSchema: any) => any | void;
   /** calls after parse route (return type: customized route (ParsedRoute), nothing change (void), false (ignore this route)) */
@@ -256,7 +265,7 @@ export interface Hooks {
   /** customize request params (path params, query params) */
   onCreateRequestParams?: (rawType: SchemaComponent["rawTypeData"]) => SchemaComponent["rawTypeData"] | void;
   /** customize name of model type */
-  onFormatTypeName?: (typeName: string, rawTypeName?: string) => string | void;
+  onFormatTypeName?: (typeName: string, rawTypeName?: string, schemaType?: "type-name" | "enum-key") => string | void;
   /** customize name of route (operationId), you can do it with using onCreateRouteName too */
   onFormatRouteName?: (routeInfo: RawRouteInfo, templateRouteName: string) => string | void;
 }
@@ -448,6 +457,9 @@ export interface GenerateApiConfiguration {
     addReadonly: boolean;
     extractResponseBody: boolean;
     extractResponseError: boolean;
+    extractEnums: boolean;
+    fixInvalidTypeNamePrefix: string;
+    fixInvalidEnumKeyPrefix: string;
     defaultResponseType: boolean;
     toJS: boolean;
     disableThrowOnError: boolean;

index.js

@@ -202,6 +202,11 @@ const program = cli({
       description: "sort fields and types",
       default: codeGenBaseConfig.sortTypes,
     },
+    {
+      flags: "--extract-enums",
+      description: "extract all enums from inline interface\\type content to typescript enum construction",
+      default: codeGenBaseConfig.extractEnums,
+    },
   ],
 });
 

package.json

@@ -59,7 +59,8 @@
     "test:enums2.0": "node tests/spec/enums-2.0/test.js",
     "test:another-query-params": "node tests/spec/another-query-params/test.js",
     "test:on-insert-path-param": "node tests/spec/on-insert-path-param/test.js",
-    "test:extra-templates": "node tests/spec/extra-templates/test.js"
+    "test:extra-templates": "node tests/spec/extra-templates/test.js",
+    "test:extract-enums": "node tests/spec/extract-enums/test.js"
   },
   "author": "acacode",
   "license": "MIT",

src/configuration.js

@@ -72,6 +72,7 @@ class CodeGenConfig {
   extractRequestBody = false;
   extractResponseBody = false;
   extractResponseError = false;
+  extractEnums = false;
   fileNames = {
     dataContracts: "data-contracts",
     routeTypes: "route-types",
@@ -85,13 +86,14 @@ class CodeGenConfig {
     onBuildRoutePath: (routeData) => void 0,
     onInsertPathParam: (pathParam) => void 0,
     onCreateComponent: (schema) => schema,
+    onPreParseSchema: (originalSchema, typeName, schemaType) => void 0,
     onParseSchema: (originalSchema, parsedSchema) => parsedSchema,
     onCreateRoute: (routeData) => routeData,
     onInit: (config) => config,
     onPrepareConfig: (apiConfig) => apiConfig,
     onCreateRequestParams: (rawType) => {},
     onCreateRouteName: () => {},
-    onFormatTypeName: (typeName, rawTypeName) => {},
+    onFormatTypeName: (typeName, rawTypeName, schemaType) => {},
     onFormatRouteName: (routeInfo, templateRouteName) => {},
   };
   defaultResponseType;
@@ -151,6 +153,8 @@ class CodeGenConfig {
 
   jsPrimitiveTypes = [];
   jsEmptyTypes = [];
+  fixInvalidTypeNamePrefix = "Type";
+  fixInvalidEnumKeyPrefix = "Value";
 
   successResponseStatusRange = [200, 299];
 

src/schema-parser/schema-formatters.js

@@ -28,10 +28,7 @@ class SchemaFormatters {
 
   base = {
     [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-      const isNumberEnum = _.some(parsedSchema.content, (content) => typeof content.key === "number");
-      const formatAsUnionType = !!(isNumberEnum || this.config.generateUnionEnums);
-
-      if (formatAsUnionType) {
+      if (this.config.generateUnionEnums) {
         return {
           ...parsedSchema,
           $content: parsedSchema.content,
@@ -61,6 +58,19 @@ class SchemaFormatters {
     },
   };
   inline = {
+    [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
+      return {
+        ...parsedSchema,
+        content: parsedSchema.$ref
+          ? parsedSchema.typeName
+          : this.config.Ts.UnionType(
+              _.compact([
+                ..._.map(parsedSchema.content, ({ value }) => `${value}`),
+                parsedSchema.nullable && this.config.Ts.Keyword.Null,
+              ]),
+            ),
+      };
+    },
     [SCHEMA_TYPES.OBJECT]: (parsedSchema) => {
       if (_.isString(parsedSchema.content)) {
         return {
@@ -81,19 +91,6 @@ class SchemaFormatters {
         ),
       };
     },
-    [SCHEMA_TYPES.ENUM]: (parsedSchema) => {
-      return {
-        ...parsedSchema,
-        content: parsedSchema.$ref
-          ? parsedSchema.typeName
-          : this.config.Ts.UnionType(
-              _.compact([
-                ..._.map(parsedSchema.content, ({ value }) => `${value}`),
-                parsedSchema.nullable && this.config.Ts.Keyword.Null,
-              ]),
-            ),
-      };
-    },
   };
 
   /**

src/schema-parser/schema-parser.js

@@ -3,6 +3,8 @@ const _ = require("lodash");
 const { SchemaFormatters } = require("./schema-formatters");
 const { internalCase } = require("../util/internal-case");
 const { SchemaUtils } = require("./schema-utils");
+const { camelCase } = require("lodash");
+const { pascalCase } = require("../util/pascal-case");
 
 class SchemaParser {
   /**
@@ -28,6 +30,8 @@ class SchemaParser {
    */
   schemaUtils;
 
+  $processingSchemaPath = [];
+
   constructor(config, logger, templates, schemaComponentsMap, typeName) {
     this.config = config;
     this.schemaComponentsMap = schemaComponentsMap;
@@ -87,13 +91,16 @@ class SchemaParser {
 
   baseSchemaParsers = {
     [SCHEMA_TYPES.ENUM]: (schema, typeName) => {
+      if (this.config.extractEnums && !typeName) {
+        const generatedTypeName = this.config.componentTypeNameResolver.resolve([this.buildTypeNameFromPath()]);
+        const schemaComponent = this.schemaComponentsMap.createComponent("schemas", generatedTypeName, { ...schema });
+        return this.parseSchema(schemaComponent, generatedTypeName);
+      }
+
       const refType = this.schemaUtils.getSchemaRefType(schema);
       const $ref = (refType && refType.$ref) || null;
-      const enumNamesAsValues = this.config.enumNamesAsValues;
       const keyType = this.getSchemaType(schema);
       const enumNames = this.schemaUtils.getEnumNames(schema);
-      const isIntegerOrBooleanEnum =
-        keyType === this.getSchemaType({ type: "number" }) || keyType === this.getSchemaType({ type: "boolean" });
       let content = null;
 
       const formatValue = (value) => {
@@ -114,10 +121,19 @@ class SchemaParser {
         content = _.map(enumNames, (enumName, index) => {
           const enumValue = _.get(schema.enum, index);
           const formattedKey =
-            (enumName && this.typeName.format(enumName, { ignorePrefix: true, ignoreSuffix: true })) ||
-            this.typeName.format(enumValue, { ignorePrefix: true, ignoreSuffix: true });
-
-          if (enumNamesAsValues || _.isUndefined(enumValue)) {
+            (enumName &&
+              this.typeName.format(enumName, {
+                ignorePrefix: true,
+                ignoreSuffix: true,
+                type: "enum-key",
+              })) ||
+            this.typeName.format(`${enumValue}`, {
+              ignorePrefix: true,
+              ignoreSuffix: true,
+              type: "enum-key",
+            });
+
+          if (this.config.enumNamesAsValues || _.isUndefined(enumValue)) {
             return {
               key: formattedKey,
               type: this.config.Ts.Keyword.String,
@@ -134,7 +150,11 @@ class SchemaParser {
       } else {
         content = _.map(schema.enum, (key) => {
           return {
-            key: isIntegerOrBooleanEnum ? key : this.typeName.format(key, { ignorePrefix: true, ignoreSuffix: true }),
+            key: this.typeName.format(`${key}`, {
+              ignorePrefix: true,
+              ignoreSuffix: true,
+              type: "enum-key",
+            }),
             type: keyType,
             value: formatValue(key),
           };
@@ -149,10 +169,7 @@ class SchemaParser {
         schemaType: SCHEMA_TYPES.ENUM,
         type: SCHEMA_TYPES.ENUM,
         keyType: keyType,
-        typeIdentifier:
-          this.config.generateUnionEnums || (!enumNames && isIntegerOrBooleanEnum)
-            ? this.config.Ts.Keyword.Type
-            : this.config.Ts.Keyword.Enum,
+        typeIdentifier: this.config.generateUnionEnums ? this.config.Ts.Keyword.Type : this.config.Ts.Keyword.Enum,
         name: typeName,
         description: this.schemaFormatters.formatDescription(schema.description),
         content,
@@ -276,13 +293,16 @@ class SchemaParser {
     const { properties, additionalProperties } = schema || {};
 
     const propertiesContent = _.map(properties, (property, name) => {
+      this.$processingSchemaPath.push(name);
       const required = this.schemaUtils.isPropertyRequired(name, property, schema);
       const rawTypeData = _.get(this.schemaUtils.getSchemaRefType(property), "rawTypeData", {});
       const nullable = !!(rawTypeData.nullable || property.nullable);
       const fieldName = this.typeName.isValidName(name) ? name : this.config.Ts.StringValue(name);
       const fieldValue = this.getInlineParseContent(property);
       const readOnly = property.readOnly;
 
+      this.$processingSchemaPath.pop();
+
       return {
         ...property,
         $$raw: property,
@@ -353,12 +373,17 @@ class SchemaParser {
       if (schema.items && !schema.type) {
         schema.type = SCHEMA_TYPES.ARRAY;
       }
-
       schemaType = this.getInternalSchemaType(schema);
+
+      this.$processingSchemaPath.push(typeName);
+
+      _.merge(schema, this.config.hooks.onPreParseSchema(schema, typeName, schemaType));
       parsedSchema = this.baseSchemaParsers[schemaType](schema, typeName);
       schema.$parsed = this.config.hooks.onParseSchema(schema, parsedSchema) || parsedSchema;
     }
 
+    this.$processingSchemaPath.pop();
+
     return schema.$parsed;
   };
 
@@ -373,6 +398,14 @@ class SchemaParser {
     const formattedSchema = this.schemaFormatters.formatSchema(parsedSchema, "base");
     return formattedSchema.content;
   };
+
+  buildTypeNameFromPath = () => {
+    const schemaPath = _.uniq(_.compact(this.$processingSchemaPath));
+
+    if (!schemaPath || !schemaPath[0]) return null;
+
+    return internalCase(camelCase(`${schemaPath[0]}_${schemaPath[schemaPath.length - 1]}`));
+  };
 }
 
 module.exports = {