openapi-ts-generator 10.48.14 → 10.49.3

package/generators/barrel.generator.js

@@ -1,10 +1,10 @@
 import { readdirSync } from 'node:fs';
 import { BaseGenerator } from "./base.generator.js";
 export class BarrelGenerator extends BaseGenerator {
-    GeneratorName = 'BarrelGenerator';
-    tsRegex = /.ts$/;
     constructor(generatorOptions) {
         super(generatorOptions, generatorOptions.templates?.barrel);
+        this.GeneratorName = 'BarrelGenerator';
+        this.tsRegex = /.ts$/;
     }
     generate() {
         let fileNames = readdirSync(this.generatorOptions.outputPath).map((value) => value.replace(this.tsRegex, ''));

package/generators/base.generator.d.ts

@@ -1,9 +1,10 @@
+import handlebars from 'handlebars';
 import { IGeneratorOptions } from '../models/generator-options.ts';
 export declare abstract class BaseGenerator<TContextSchema> {
     readonly generatorOptions: IGeneratorOptions;
     readonly templateFilePath: string | undefined;
     abstract readonly GeneratorName: string;
-    readonly template?: HandlebarsTemplateDelegate<TContextSchema>;
+    readonly template?: handlebars.TemplateDelegate<TContextSchema>;
     readonly emptyArrayRegex: RegExp;
     constructor(generatorOptions: IGeneratorOptions, templateFilePath: string | undefined);
     protected generateFile(outputFilePath: string, context: TContextSchema | null): string | null;

package/generators/base.generator.js

@@ -1,16 +1,13 @@
 import { readFileSync, writeFileSync } from 'node:fs';
-import { compile } from 'handlebars';
+import handlebars from 'handlebars';
 export class BaseGenerator {
-    generatorOptions;
-    templateFilePath;
-    template;
-    emptyArrayRegex = /, ]/g;
     constructor(generatorOptions, templateFilePath) {
         this.generatorOptions = generatorOptions;
         this.templateFilePath = templateFilePath;
+        this.emptyArrayRegex = /, ]/g;
         if (templateFilePath) {
             const templateSource = readFileSync(templateFilePath, { encoding: 'utf8' });
-            this.template = compile(templateSource);
+            this.template = handlebars.compile(templateSource);
         }
     }
     generateFile(outputFilePath, context) {

package/generators/endpoints.generator.js

@@ -1,10 +1,10 @@
-import { camelCase } from 'lodash';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class EndPointsGenerator extends BaseGenerator {
-    GeneratorName = 'EndPointsGenerator';
-    endpointIdentifierRegex = /[A-z0-9_-]*$/;
     constructor(options) {
         super(options, options.templates?.endpoints);
+        this.GeneratorName = 'EndPointsGenerator';
+        this.endpointIdentifierRegex = /[A-Za-z0-9_-]*$/;
     }
     generate(templateData) {
         const paths = this.eliminateDupes(templateData);
@@ -14,13 +14,13 @@ export class EndPointsGenerator extends BaseGenerator {
         const sortedTemplateData = [...templateData.paths].sort((x, y) => (x.endpoint.toUpperCase() < y.endpoint.toUpperCase() ? -1 : 1));
         const result = [];
         sortedTemplateData.forEach((val) => {
-            val = { ...val, tag: camelCase(val.tag) };
+            val = { ...val, tag: lodash.camelCase(val.tag) };
             const dupeIndex = result.findIndex((f) => f.tag === val.tag);
             if (dupeIndex > -1) {
                 const dupeCount = result.filter((f) => f.tag === val.tag).length + 1;
                 const endpointIdentifier = (this.endpointIdentifierRegex.exec(val.endpoint) || [])[0];
                 // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                result.push({ ...val, tag: camelCase(`${val.tag}_${endpointIdentifier || dupeCount}`) });
+                result.push({ ...val, tag: lodash.camelCase(`${val.tag}_${endpointIdentifier || dupeCount}`) });
             }
             else {
                 result.push(val);

package/generators/enum.generator.js

@@ -1,15 +1,15 @@
-import { kebabCase } from 'lodash';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class EnumGenerator extends BaseGenerator {
-    GeneratorName = 'EnumGenerator';
     constructor(options) {
         super(options, options.templates?.enum);
+        this.GeneratorName = 'EnumGenerator';
     }
     generate(templateData) {
         templateData.entities
             ?.filter((entity) => entity.isEnum)
             .forEach((entity) => {
-            super.generateFile(`${this.generatorOptions.outputPath}/${kebabCase(entity.name)}.enum.ts`, entity);
+            super.generateFile(`${this.generatorOptions.outputPath}/${lodash.kebabCase(entity.name)}.enum.ts`, entity);
         });
     }
 }

package/generators/form-group-factory.generator.js

@@ -1,18 +1,18 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-import * as HandleBars from 'handlebars';
-import { kebabCase } from 'lodash';
+import handlebars from 'handlebars';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class FormGroupFactoryGenerator extends BaseGenerator {
-    GeneratorName = 'FormGroupFactoryGenerator';
     constructor(options) {
         super(options, options.templates?.formGroupFactory);
+        this.GeneratorName = 'FormGroupFactoryGenerator';
     }
     generate(templateData) {
         this.registerHelpers();
         templateData.entities
             ?.filter((val) => val.valueProperties?.length + val.referenceProperties?.length > 0)
             .forEach((entity) => {
-            super.generateFile(`${this.generatorOptions.outputPath}/${kebabCase(entity.name)}.form-group-fac.ts`, entity);
+            super.generateFile(`${this.generatorOptions.outputPath}/${lodash.kebabCase(entity.name)}.form-group-fac.ts`, entity);
         });
     }
     registerHelpers() {
@@ -25,7 +25,7 @@ export class FormGroupFactoryGenerator extends BaseGenerator {
         this.registerValidatorHelper('pattern');
     }
     registerValidatorHelper(validatorName, angularValidatorName = validatorName) {
-        HandleBars.registerHelper(`${validatorName}Validator`, (x, y) => this.validatorFactory(x, y, validatorName, angularValidatorName));
+        handlebars.registerHelper(`${validatorName}Validator`, (x, y) => this.validatorFactory(x, y, validatorName, angularValidatorName));
     }
     validatorFactory(propertyCollection, propertyContext, validationName, angularValidatorFunctionName) {
         const props = propertyContext.data.root[propertyCollection];

package/generators/form.generator.js

@@ -1,16 +1,16 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-import { kebabCase } from 'lodash';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class FormGenerator extends BaseGenerator {
-    GeneratorName = 'FormGenerator';
     constructor(options) {
         super(options, options.templates?.form);
+        this.GeneratorName = 'FormGenerator';
     }
     generate(templateData) {
         templateData.entities
             ?.filter((val) => val.valueProperties?.length + val.referenceProperties?.length > 0)
             .forEach((entity) => {
-            super.generateFile(`${this.generatorOptions.outputPath}/${kebabCase(entity.name)}.form.ts`, entity);
+            super.generateFile(`${this.generatorOptions.outputPath}/${lodash.kebabCase(entity.name)}.form.ts`, entity);
         });
     }
 }

package/generators/model-properties.generator.js

@@ -1,17 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-import { kebabCase } from 'lodash';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class ModelPropertiesGenerator extends BaseGenerator {
-    GeneratorName = 'ModelPropertiesGenerator';
     constructor(options) {
         super(options, options.templates?.modelProperties);
+        this.GeneratorName = 'ModelPropertiesGenerator';
     }
     generate(templateData) {
         templateData.entities
             ?.filter((entity) => !entity.isEnum)
             .filter((val) => val.valueProperties?.length > 0 || val.referenceProperties?.length > 0)
             .forEach((entity) => {
-            super.generateFile(`${this.generatorOptions.outputPath}/${kebabCase(entity.name)}.properties.ts`, entity);
+            super.generateFile(`${this.generatorOptions.outputPath}/${lodash.kebabCase(entity.name)}.properties.ts`, entity);
         });
     }
 }

package/generators/model.generator.js

@@ -1,18 +1,17 @@
-import { kebabCase } from 'lodash';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class ModelGenerator extends BaseGenerator {
-    options;
-    GeneratorName = 'ModelGenerator';
     constructor(options) {
         super(options, options.genClasses ? options.templates?.entity : options.templates?.model);
         this.options = options;
+        this.GeneratorName = 'ModelGenerator';
     }
     generate(templateData) {
         const fileSuffix = this.options.genClasses ? '.entity.ts' : '.model.ts';
         templateData.entities
             ?.filter((entity) => !entity.isEnum)
             .forEach((entity) => {
-            super.generateFile(`${this.options.outputPath}/${kebabCase(entity.name)}${fileSuffix}`, entity);
+            super.generateFile(`${this.options.outputPath}/${lodash.kebabCase(entity.name)}${fileSuffix}`, entity);
         });
     }
 }

package/generators/test-object-factory.generator.js

@@ -1,18 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-import { kebabCase } from 'lodash';
+import lodash from 'lodash';
 import { BaseGenerator } from "./base.generator.js";
 export class TestObjectFactoryGenerator extends BaseGenerator {
-    options;
-    GeneratorName = 'TestObjectFactoryGenerator';
     constructor(options) {
         super(options, options.templates?.testObjectFactory);
         this.options = options;
+        this.GeneratorName = 'TestObjectFactoryGenerator';
     }
     generate(templateData) {
         templateData.entities
             ?.filter((val) => val.valueProperties?.length + val.referenceProperties?.length > 0)
             .forEach((entity) => {
-            super.generateFile(`${this.options.outputPath}/${kebabCase(entity.name)}.test-obj-fac.ts`, entity);
+            super.generateFile(`${this.options.outputPath}/${lodash.kebabCase(entity.name)}.test-obj-fac.ts`, entity);
         });
     }
 }

package/jest.setup.d.ts

@@ -0,0 +1 @@
+export {};

package/jest.setup.js

@@ -0,0 +1,4 @@
+import { jest } from '@jest/globals';
+jest.mock('./models/utils.ts', () => ({
+    getDirName: jest.fn(() => './src/models/'),
+}));

package/models/generator-options.js

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { resolve } from 'path';
+import { resolve, } from 'node:path';
+import { getDirName } from "./utils.js";
 export function defaultFilter(_value, _index, _array) {
     return true;
 }
 export function setGeneratorOptionDefaults(options) {
+    const __dirname = getDirName();
     const templateFolder = resolve(`${__dirname}/..`, 'templates');
     options.typeFilterCallBack = options.typeFilterCallBack ?? defaultFilter;
     options.valuePropertyTypeFilterCallBack = options.valuePropertyTypeFilterCallBack ?? defaultFilter;

package/models/logger.js

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 export class MockConsoleLogger {
-    log = (data) => { };
-    error = (data) => { };
-    warn = (data) => { };
+    constructor() {
+        this.log = (data) => { };
+        this.error = (data) => { };
+        this.warn = (data) => { };
+    }
 }

package/models/schema-info.js

@@ -1,15 +1,9 @@
 import { defaultFilter } from "./generator-options.js";
 export class SchemaWrapperInfo {
-    propertySchemaObject = {};
-    propertyReferenceObject = { $ref: '' };
-    isEnum;
-    isCharEnum = false;
-    enumValues;
-    componentSchemaObject;
-    valueProperties;
-    referenceProperties;
-    description;
     constructor(schemaItem) {
+        this.propertySchemaObject = {};
+        this.propertyReferenceObject = { $ref: '' };
+        this.isCharEnum = false;
         this.componentSchemaObject = schemaItem;
         this.description = schemaItem.description;
         this.valueProperties = [];

package/models/utils.d.ts

@@ -0,0 +1 @@
+export declare const getDirName: () => string;

package/models/utils.js

@@ -0,0 +1,6 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const getDirName = () => {
+    const __filename = fileURLToPath(import.meta.url);
+    return dirname(__filename);
+};

package/openapidoc-converter.js

@@ -1,18 +1,16 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-type-conversion */
 /* eslint-disable @typescript-eslint/restrict-template-expressions */
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
-import { singular } from 'pluralize';
-import { camelCase, kebabCase, snakeCase, startCase } from 'lodash';
+import pluralize from 'pluralize';
+import lodash from 'lodash';
 import { defaultFilter } from "./models/generator-options.js";
 import { SchemaWrapperInfo } from "./models/schema-info.js";
 export class OpenApiDocConverter {
-    options;
-    apiDocument;
-    endAlphaNumRegex = /[A-z0-9]*$/s;
-    startNumberregex = /^\d*/;
     constructor(options, apiDocument) {
         this.options = options;
         this.apiDocument = apiDocument;
+        this.endAlphaNumRegex = /[A-z0-9]*$/s;
+        this.startNumberregex = /^\d*/;
     }
     convertDocument() {
         const entities = this.convertEntities();
@@ -27,7 +25,7 @@ export class OpenApiDocConverter {
             tagLookup = tagLookup || path.delete || path.patch;
             const tag = (tagLookup?.tags || ['unknown_endpoint'])[0];
             paths.push({
-                tag: snakeCase(tag),
+                tag: lodash.snakeCase(tag),
                 endpoint: this.options.pathUrlFormattingCallBack ? this.options.pathUrlFormattingCallBack(key) : key,
             });
         }
@@ -55,9 +53,9 @@ export class OpenApiDocConverter {
                             key: schemaWrapperInfo.isCharEnum ? t.key : +t.key,
                         }),
                     name: schemaName,
-                    kebabCasedName: kebabCase(schemaName),
-                    singularName: singular(schemaName),
-                    camelSingularName: camelCase(singular(schemaName)),
+                    kebabCasedName: lodash.kebabCase(schemaName),
+                    singularName: pluralize.singular(schemaName),
+                    camelSingularName: lodash.camelCase(pluralize.singular(schemaName)),
                     description: schemaWrapperInfo.description,
                     referenceProperties: schemaWrapperInfo.referenceProperties,
                     valueProperties: schemaWrapperInfo.valueProperties.filter(this.options.valuePropertyTypeFilterCallBack || defaultFilter),
@@ -77,8 +75,8 @@ export class OpenApiDocConverter {
                 return {
                     key: key ? +key : 0,
                     name,
-                    titleName: startCase(name),
-                    snakeCaseName: snakeCase(name).toUpperCase(),
+                    titleName: lodash.startCase(name),
+                    snakeCaseName: lodash.snakeCase(name).toUpperCase(),
                 };
             }),
         ];
@@ -136,7 +134,7 @@ export class OpenApiDocConverter {
             initialValue,
             initialTestValue,
             isArray: false,
-            snakeCaseName: snakeCase(propertyName).toUpperCase(),
+            snakeCaseName: lodash.snakeCase(propertyName).toUpperCase(),
             typeScriptType: this.getPropertyTypeScriptType(schemaWrapperInfo),
             maxLength: schemaWrapperInfo.propertySchemaObject.maxLength,
             minLength: schemaWrapperInfo.propertySchemaObject.minLength,
@@ -172,7 +170,7 @@ export class OpenApiDocConverter {
             email: false,
             uri: false,
             isArray: true,
-            snakeCaseName: snakeCase(propertyName).toUpperCase(),
+            snakeCaseName: lodash.snakeCase(propertyName).toUpperCase(),
             hasMultipleValidators: false,
             hasValidators: validatorCount > 0,
         };
@@ -228,7 +226,7 @@ export class OpenApiDocConverter {
             return `'${defaultValue.split(' ').pop()}'`;
         }
         else if (email) {
-            return `'${kebabCase(parentTypeName)}@email.org'`;
+            return `'${lodash.kebabCase(parentTypeName)}@email.org'`;
         }
         else if (typescriptType === 'Date') {
             return 'new Date()';
@@ -246,7 +244,7 @@ export class OpenApiDocConverter {
             return minValue ? `${minValue}` : '0';
         }
         else {
-            let retValue = snakeCase(propertyName).toUpperCase();
+            let retValue = lodash.snakeCase(propertyName).toUpperCase();
             while (minLength && retValue.length < minLength) {
                 retValue = `${retValue}_${retValue}`;
             }
@@ -277,7 +275,7 @@ export class OpenApiDocConverter {
             isSameAsParentTypescriptType: parentTypeName.toLowerCase() === typeName.toLowerCase(),
             initialValue,
             initialTestValue,
-            snakeCaseName: snakeCase(propertyName).toUpperCase(),
+            snakeCaseName: lodash.snakeCase(propertyName).toUpperCase(),
             referenceTypeName: typeName,
             typeScriptType: typeName,
             isArray: false,
@@ -353,7 +351,7 @@ export class OpenApiDocConverter {
             const props = properties.filter((t) => t.items.$ref === value || t.$ref === value);
             return {
                 name: value,
-                kebabCasedTypeName: kebabCase(value),
+                kebabCasedTypeName: lodash.kebabCase(value),
                 isEnum: (refSchema?.enum ?? []).length > 0,
                 areAllArrays: props.every((val) => val.type === 'array'),
                 hasArrays: props.some((val) => val.type === 'array'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openapi-ts-generator",
-  "version": "10.48.14",
+  "version": "10.49.3",
   "description": "Based on swagger-ts-generator, this is a type script model generator specifically for services with OpenApi spec documentation.",
   "main": "index.js",
   "type": "module",