ts-openapi-codegen 2.0.0 → 2.1.0-beta.10

package/dist/core/utils/__tests__/loadDiffReport.test.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../../common/Enums");
+const Logger_1 = require("../../../common/Logger");
+const loadDiffReport_1 = require("../loadDiffReport");
+const createTempDir = (t, prefix) => {
+    const root = node_path_1.default.join(__dirname, 'generated');
+    node_fs_1.default.mkdirSync(root, { recursive: true });
+    const tempDir = node_fs_1.default.mkdtempSync(node_path_1.default.join(root, prefix));
+    t.after(() => {
+        node_fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+    });
+    return tempDir;
+};
+const createLogger = () => new Logger_1.Logger({
+    instanceId: 'load-diff-report-test',
+    level: Enums_1.ELogLevel.ERROR,
+    logOutput: Enums_1.ELogOutput.CONSOLE,
+    disableColors: true,
+});
+(0, node_test_1.describe)('@unit: loadDiffReport', () => {
+    (0, node_test_1.test)('returns null when history and diffReport path are disabled', () => {
+        const result = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: false,
+            logger: createLogger(),
+        });
+        node_assert_1.default.strictEqual(result, null);
+    });
+    (0, node_test_1.test)('returns null when diffReport path is set but useHistory is disabled', async (t) => {
+        const dir = createTempDir(t, 'diff-report-no-history-');
+        const reportPath = node_path_1.default.join(dir, 'report.json');
+        node_fs_1.default.writeFileSync(reportPath, JSON.stringify({
+            diff: { all: [{ action: 'changed', path: '$.info.version', severity: 'info', from: '1', to: '2' }] },
+        }), 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: false,
+            diffReport: reportPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.strictEqual(loaded, null);
+    });
+    (0, node_test_1.test)('returns null when report file is missing', () => {
+        const result = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: true,
+            diffReport: node_path_1.default.join(__dirname, 'missing-report.json'),
+            logger: createLogger(),
+        });
+        node_assert_1.default.strictEqual(result, null);
+    });
+    (0, node_test_1.test)('loads report with diff entries', async (t) => {
+        const dir = createTempDir(t, 'diff-report-');
+        const reportPath = node_path_1.default.join(dir, 'report.json');
+        const report = {
+            diff: {
+                all: [{ action: 'changed', path: '$.info.version', severity: 'info', from: '1', to: '2' }],
+            },
+        };
+        node_fs_1.default.writeFileSync(reportPath, JSON.stringify(report), 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: true,
+            diffReport: reportPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.ok(loaded);
+        node_assert_1.default.strictEqual(loaded?.diff?.all?.length, 1);
+    });
+    (0, node_test_1.test)('returns null for empty report without diff or miracles', async (t) => {
+        const dir = createTempDir(t, 'diff-report-empty-');
+        const reportPath = node_path_1.default.join(dir, 'empty.json');
+        node_fs_1.default.writeFileSync(reportPath, JSON.stringify({ diff: { all: [] }, miracles: [] }), 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: true,
+            diffReport: reportPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.strictEqual(loaded, null);
+    });
+    (0, node_test_1.test)('returns null when report is older than input spec', async (t) => {
+        const dir = createTempDir(t, 'diff-report-stale-');
+        const reportPath = node_path_1.default.join(dir, 'report.json');
+        const inputPath = node_path_1.default.join(dir, 'spec.json');
+        node_fs_1.default.writeFileSync(reportPath, JSON.stringify({
+            diff: { all: [{ action: 'changed', path: '$.info.version', severity: 'info' }] },
+        }), 'utf-8');
+        const past = Date.now() - 60_000;
+        node_fs_1.default.utimesSync(reportPath, past / 1000, past / 1000);
+        node_fs_1.default.writeFileSync(inputPath, '{"openapi":"3.0.0"}', 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            diffReport: reportPath,
+            inputPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.strictEqual(loaded, null);
+    });
+    (0, node_test_1.test)('loads semantic report (schemaVersion 1.1.0) and converts to legacy diff', async (t) => {
+        const dir = createTempDir(t, 'semantic-report-');
+        const reportPath = node_path_1.default.join(dir, 'semantic-report.json');
+        const semanticReport = {
+            schemaVersion: '1.1.0',
+            summary: { breaking: 1, nonBreaking: 0, informational: 0 },
+            recommendation: {
+                semver: 'major',
+                confidence: 'high',
+                reason: 'Breaking changes detected.',
+                reasons: ['HAS_BREAKING_CHANGES'],
+            },
+            governance: {
+                summary: { errors: 0, warnings: 0, info: 0 },
+                violations: [],
+            },
+            changes: [
+                {
+                    type: 'model.property.type.changed',
+                    severity: 'breaking',
+                    path: '#/components/schemas/User/properties/age',
+                    message: 'type changed',
+                    from: 'string',
+                    to: 'integer',
+                },
+                {
+                    type: 'model.property.removed',
+                    severity: 'breaking',
+                    path: '#/components/schemas/User/properties/first_name',
+                    message: 'removed',
+                    from: { type: 'string' },
+                },
+                {
+                    type: 'model.property.added',
+                    severity: 'non-breaking',
+                    path: '#/components/schemas/User/properties/firstName',
+                    message: 'added',
+                    to: { type: 'string' },
+                },
+            ],
+            miracles: [
+                {
+                    oldPath: '$.components.schemas.User.properties.age',
+                    newPath: '$.components.schemas.User.properties.age',
+                    type: 'TYPE_COERCION',
+                    confidence: 1,
+                    status: 'auto-generated',
+                },
+                {
+                    oldPath: '$.components.schemas.User.properties.first_name',
+                    newPath: '$.components.schemas.User.properties.firstName',
+                    type: 'RENAME',
+                    confidence: 1,
+                    status: 'auto-generated',
+                },
+            ],
+        };
+        node_fs_1.default.writeFileSync(reportPath, JSON.stringify(semanticReport), 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: true,
+            diffReport: reportPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.ok(loaded);
+        node_assert_1.default.strictEqual(loaded?.version, '1.1.0');
+        node_assert_1.default.strictEqual(loaded?.diff?.all?.length, 3);
+        node_assert_1.default.ok(loaded?.diff?.all?.some(entry => entry.path.endsWith('.type') && entry.action === 'changed'));
+        node_assert_1.default.strictEqual(loaded?.miracles?.length, 2);
+        node_assert_1.default.ok(loaded?.miracles?.some(miracle => miracle.type === 'RENAME'));
+        node_assert_1.default.ok(loaded?.miracles?.some(miracle => miracle.type === 'TYPE_COERCION'));
+    });
+    (0, node_test_1.test)('loads unified report (schemaVersion 2.0.0) and returns structural legacy diff', async (t) => {
+        const dir = createTempDir(t, 'unified-report-');
+        const reportPath = node_path_1.default.join(dir, 'unified-report.json');
+        const unifiedReport = {
+            schemaVersion: '2.0.0',
+            timestamp: '2026-01-01T00:00:00.000Z',
+            metadata: {
+                base: 'old.json',
+                target: 'new.json',
+                baseHash: 'old-hash',
+                targetHash: 'new-hash',
+            },
+            semantic: {
+                summary: { breaking: 1, nonBreaking: 0, informational: 0 },
+                recommendation: {
+                    semver: 'major',
+                    confidence: 'high',
+                    reason: 'Breaking changes detected.',
+                    reasons: ['HAS_BREAKING_CHANGES'],
+                },
+                governance: {
+                    summary: { errors: 0, warnings: 0, info: 0 },
+                    violations: [],
+                },
+                changes: [
+                    {
+                        type: 'model.property.removed',
+                        severity: 'breaking',
+                        path: '#/components/schemas/User/properties/name',
+                        message: 'removed',
+                    },
+                ],
+            },
+            structural: {
+                diff: {
+                    breaking: [{ action: 'removed', path: '$.components.schemas.User.properties.name', severity: 'breaking' }],
+                    warnings: [],
+                    info: [],
+                    all: [{ action: 'removed', path: '$.components.schemas.User.properties.name', severity: 'breaking' }],
+                },
+                miracles: [],
+                stats: {
+                    totalChanges: 1,
+                    added: 0,
+                    removed: 1,
+                    changed: 0,
+                    stabilityScore: 0,
+                },
+            },
+        };
+        node_fs_1.default.writeFileSync(reportPath, JSON.stringify(unifiedReport), 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: true,
+            diffReport: reportPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.ok(loaded);
+        node_assert_1.default.strictEqual(loaded?.version, '2.0.0');
+        node_assert_1.default.strictEqual(loaded?.metadata?.base, 'old.json');
+        node_assert_1.default.strictEqual(loaded?.diff?.all?.length, 1);
+        node_assert_1.default.strictEqual(loaded?.stats?.stabilityScore, 0);
+    });
+    (0, node_test_1.test)('returns null when report JSON is invalid', async (t) => {
+        const dir = createTempDir(t, 'diff-report-broken-');
+        const reportPath = node_path_1.default.join(dir, 'broken.json');
+        node_fs_1.default.writeFileSync(reportPath, '{ not-json', 'utf-8');
+        const loaded = (0, loadDiffReport_1.loadDiffReport)({
+            useHistory: true,
+            diffReport: reportPath,
+            logger: createLogger(),
+        });
+        node_assert_1.default.strictEqual(loaded, null);
+    });
+});

package/dist/core/utils/__tests__/modelHelpers.test.js

@@ -29,6 +29,22 @@ function createModel(overrides = {}) {
     };
 }
 (0, node_test_1.describe)('@unit: modelHelpers', () => {
+    (0, node_test_1.test)('assignDuplicateAliases keeps plain name for a single item and for the first duplicate', () => {
+        const single = [{ name: 'Pet', alias: 'old' }];
+        (0, modelHelpers_1.assignDuplicateAliases)(single);
+        node_assert_1.default.deepStrictEqual(single, [{ name: 'Pet', alias: '' }]);
+        const duplicates = [
+            { name: 'Pet', alias: 'old' },
+            { name: 'Pet', alias: 'old' },
+            { name: 'Pet', alias: 'old' },
+        ];
+        (0, modelHelpers_1.assignDuplicateAliases)(duplicates);
+        node_assert_1.default.deepStrictEqual(duplicates, [
+            { name: 'Pet', alias: '' },
+            { name: 'Pet', alias: 'Pet$2' },
+            { name: 'Pet', alias: 'Pet$3' },
+        ]);
+    });
     (0, node_test_1.test)('resolveModelImports should propagate duplicate aliases to nested model types', () => {
         const importFooA = { name: 'Foo', alias: '', path: './a/Foo' };
         const importFooB = { name: 'Foo', alias: '', path: './b/Foo' };
@@ -86,16 +102,18 @@ function createModel(overrides = {}) {
         const models = [fooModelA, fooModelB, wrapper];
         (0, modelHelpers_1.setDuplicateModelAliases)(models);
         (0, modelHelpers_1.resolveModelImports)(models, '/tmp/generated/models');
-        const wrapperImportAliases = wrapper.imports.map(item => item.alias).filter(Boolean);
-        node_assert_1.default.deepStrictEqual(wrapperImportAliases, ['Foo$1', 'Foo$2']);
-        node_assert_1.default.equal(propertyFooA.base, 'Foo$1');
-        node_assert_1.default.equal(propertyFooA.type, 'Foo$1');
+        const wrapperImportAliases = wrapper.imports.map(item => item.alias);
+        node_assert_1.default.deepStrictEqual(wrapperImportAliases, ['', 'Foo$2']);
+        node_assert_1.default.equal(propertyFooA.base, 'Foo');
+        node_assert_1.default.equal(propertyFooA.type, 'Foo');
         node_assert_1.default.equal(propertyFooBArray.base, 'Foo$2');
         node_assert_1.default.equal(propertyFooBArray.type, 'Foo$2');
         node_assert_1.default.equal(propertyFooBArray.link?.base, 'Foo$2');
         node_assert_1.default.equal(propertyFooBArray.link?.type, 'Foo$2');
-        node_assert_1.default.equal(enumRefFooA.base, 'Foo$1');
-        node_assert_1.default.equal(enumRefFooA.type, 'Foo$1');
+        node_assert_1.default.equal(enumRefFooA.base, 'Foo');
+        node_assert_1.default.equal(enumRefFooA.type, 'Foo');
+        node_assert_1.default.equal(fooModelA.alias, '');
+        node_assert_1.default.equal(fooModelB.alias, 'Foo$2');
         node_assert_1.default.equal(wrapper.alias, '');
     });
     (0, node_test_1.test)('resolveModelImports should propagate alias when nested import object is not reused after dedup', () => {
@@ -144,8 +162,8 @@ function createModel(overrides = {}) {
         (0, modelHelpers_1.setDuplicateModelAliases)(models);
         (0, modelHelpers_1.resolveModelImports)(models, '/tmp/generated/models');
         node_assert_1.default.equal(wrapper.imports[0].path, '../a/Foo');
-        node_assert_1.default.equal(wrapper.imports[0].alias, 'Foo$1');
-        node_assert_1.default.equal(nestedRef.base, 'Foo$1');
-        node_assert_1.default.equal(nestedRef.type, 'Foo$1');
+        node_assert_1.default.equal(wrapper.imports[0].alias, '');
+        node_assert_1.default.equal(nestedRef.base, 'Foo');
+        node_assert_1.default.equal(nestedRef.type, 'Foo');
     });
 });

package/dist/core/utils/__tests__/postProcessModelImports.test.js

@@ -38,10 +38,7 @@ function createModel(overrides = {}) {
             ],
         });
         const result = (0, postProcessModelImports_1.postProcessModelImports)(model);
-        node_assert_1.default.deepStrictEqual(result.map(item => `${item.name}:${item.alias}:${item.path}`), [
-            'ISimpleDto:ISimpleDto$1:./path/alias_response/SimpleDto',
-            'ISimpleDto:ISimpleDto$2:./path/common_request/SimpleDto',
-        ]);
+        node_assert_1.default.deepStrictEqual(result.map(item => `${item.name}:${item.alias}:${item.path}`), ['ISimpleDto:ISimpleDto$1:./path/alias_response/SimpleDto', 'ISimpleDto:ISimpleDto$2:./path/common_request/SimpleDto']);
     });
     (0, node_test_1.test)('removes self import by path even if import name differs from model name', () => {
         const model = createModel({

package/dist/core/utils/__tests__/postProcessServiceImports.test.js

@@ -18,9 +18,6 @@ const postProcessServiceImports_1 = require("../postProcessServiceImports");
             ],
         };
         const result = (0, postProcessServiceImports_1.postProcessServiceImports)(service);
-        node_assert_1.default.deepStrictEqual(result.map(item => `${item.name}:${item.alias}:${item.path}`), [
-            'UserService:UserService$1:../models/path/UserService',
-            'UserService::../models/UserService',
-        ]);
+        node_assert_1.default.deepStrictEqual(result.map(item => `${item.name}:${item.alias}:${item.path}`), ['UserService:UserService$1:../models/path/UserService', 'UserService::../models/UserService']);
     });
 });

package/dist/core/utils/__tests__/prepareDtoModels.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prepareDtoModels.test.d.ts.map

package/dist/core/utils/__tests__/prepareDtoModels.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareDtoModels.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/prepareDtoModels.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/prepareDtoModels.test.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const prepareDtoModels_1 = require("../prepareDtoModels");
+const createPrimitiveModel = (name, type) => ({
+    name,
+    alias: '',
+    path: 'models',
+    export: 'generic',
+    type,
+    base: type,
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: false,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties: [],
+});
+const createInterfaceModel = (name, properties) => ({
+    name,
+    alias: '',
+    path: 'models',
+    export: 'interface',
+    type: name,
+    base: name,
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: true,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties,
+});
+(0, node_test_1.describe)('@unit: prepareDtoModels', () => {
+    (0, node_test_1.test)('builds dto init/toJSON for references and arrays of references', () => {
+        const profile = createInterfaceModel('IProfile', [createPrimitiveModel('bio', 'string')]);
+        const profileRef = {
+            ...createPrimitiveModel('profile', 'IProfile'),
+            export: 'reference',
+            type: 'IProfile',
+            isRequired: true,
+        };
+        const profilesArray = {
+            ...createPrimitiveModel('profiles', 'IProfile'),
+            export: 'array',
+            link: { ...createPrimitiveModel('IProfile', 'IProfile'), export: 'reference', type: 'IProfile' },
+            isRequired: false,
+        };
+        const user = createInterfaceModel('IUser', [profileRef, profilesArray]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [user, profile],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedUser = prepared.models.find(model => model.name === 'IUser');
+        node_assert_1.default.ok(preparedUser);
+        const preparedProfile = prepared.models.find(model => model.name === 'IProfile');
+        node_assert_1.default.ok(preparedProfile);
+        node_assert_1.default.strictEqual(preparedProfile?.rawName, 'IProfileRaw');
+        node_assert_1.default.strictEqual(preparedProfile?.dtoName, 'IProfileDto');
+        const profileProperty = preparedUser?.properties.find(prop => prop.name === 'profile');
+        node_assert_1.default.ok(profileProperty);
+        node_assert_1.default.strictEqual(profileProperty?.dtoType, 'IProfileDto');
+        node_assert_1.default.strictEqual(profileProperty?.rawType, 'IProfileRaw');
+        node_assert_1.default.strictEqual(profileProperty?.dtoInit, 'new IProfileDto(data.profile)');
+        node_assert_1.default.strictEqual(profileProperty?.dtoToJSON, 'this.profile.toJSON()');
+        const profilesProperty = preparedUser?.properties.find(prop => prop.name === 'profiles');
+        node_assert_1.default.ok(profilesProperty);
+        node_assert_1.default.strictEqual(profilesProperty?.dtoType, 'IProfileDto[] | undefined');
+        node_assert_1.default.strictEqual(profilesProperty?.rawType, 'IProfileRaw[]');
+        node_assert_1.default.strictEqual(profilesProperty?.dtoInit, 'data.profiles ? fromArray(IProfileDto, data.profiles) : undefined');
+        node_assert_1.default.strictEqual(profilesProperty?.dtoToJSON, 'this.profiles ? this.profiles.map(item => item.toJSON()) : undefined');
+    });
+    (0, node_test_1.test)('attaches dto getters from confirmed miracles', () => {
+        const user = createInterfaceModel('IUser', [createPrimitiveModel('fullName', 'string')]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [user],
+            services: [],
+            miracles: [
+                {
+                    type: 'RENAME',
+                    oldPath: '$.components.schemas.User.properties.oldName',
+                    newPath: '$.components.schemas.User.properties.fullName',
+                    confidence: 1,
+                    status: 'confirmed',
+                    modelName: 'IUser',
+                    oldProperty: 'oldName',
+                    newProperty: 'fullName',
+                },
+            ],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedUser = prepared.models.find(model => model.name === 'IUser');
+        node_assert_1.default.ok(preparedUser?.dtoGetters);
+        node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.length, 1);
+        node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.[0].oldName, 'oldName');
+        node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.[0].newName, 'fullName');
+    });
+    (0, node_test_1.test)('resolves one-of and dictionary property types', () => {
+        const tag = createPrimitiveModel('tag', 'string');
+        const tagRef = {
+            ...createPrimitiveModel('value', 'string'),
+            export: 'reference',
+            type: 'string',
+            isRequired: true,
+        };
+        const oneOfProp = {
+            ...createPrimitiveModel('payload', 'string | number'),
+            export: 'one-of',
+            properties: [createPrimitiveModel('a', 'string'), createPrimitiveModel('b', 'number')],
+            isRequired: true,
+        };
+        const dictProp = {
+            ...createPrimitiveModel('tags', 'Record<string, string>'),
+            export: 'dictionary',
+            link: tagRef,
+            isRequired: false,
+        };
+        const container = createInterfaceModel('IContainer', [oneOfProp, dictProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [container, tag],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedContainer = prepared.models.find(model => model.name === 'IContainer');
+        const preparedOneOf = preparedContainer?.properties.find(prop => prop.name === 'payload');
+        const preparedDict = preparedContainer?.properties.find(prop => prop.name === 'tags');
+        node_assert_1.default.ok(preparedOneOf?.dtoType?.includes('|'));
+        node_assert_1.default.match(preparedDict?.dtoType ?? '', /Record<string, string>/);
+    });
+    (0, node_test_1.test)('resolves enum property types in dtoType', () => {
+        const statusEnum = {
+            ...createPrimitiveModel('Status', 'string'),
+            export: 'enum',
+            enum: [
+                { name: 'Active', value: "'active'", type: 'string', description: null },
+                { name: 'Inactive', value: "'inactive'", type: 'string', description: null },
+            ],
+        };
+        const statusProp = {
+            ...createPrimitiveModel('status', 'string'),
+            export: 'enum',
+            enum: statusEnum.enum,
+            isRequired: true,
+        };
+        const model = createInterfaceModel('IUser', [statusProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [model, statusEnum],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models[0]?.properties[0];
+        node_assert_1.default.match(property?.dtoType ?? '', /active/);
+        node_assert_1.default.match(property?.dtoType ?? '', /inactive/);
+    });
+    (0, node_test_1.test)('uses optional toJSON for non-required reference properties', () => {
+        const profile = createInterfaceModel('IProfile', [createPrimitiveModel('bio', 'string')]);
+        const profileRef = {
+            ...createPrimitiveModel('profile', 'IProfile'),
+            export: 'reference',
+            type: 'IProfile',
+            isRequired: false,
+        };
+        const user = createInterfaceModel('IUser', [profileRef]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [user, profile],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models.find(m => m.name === 'IUser')?.properties[0];
+        node_assert_1.default.match(property?.dtoInit ?? '', /\? new IProfileDto/);
+        node_assert_1.default.match(property?.dtoToJSON ?? '', /\? this.profile.toJSON/);
+    });
+    (0, node_test_1.test)('assigns unique raw/dto names for duplicate models with aliases', () => {
+        const ingredient1 = createInterfaceModel('IIngredient', [createPrimitiveModel('id', 'string')]);
+        ingredient1.path = 'components/schemas-v2/Ingredient';
+        const ingredient2 = createInterfaceModel('IIngredient', [createPrimitiveModel('pathwayId', 'string')]);
+        ingredient2.alias = 'IIngredient$2';
+        ingredient2.path = 'components/schemas/Ingredient';
+        const ref = {
+            ...createPrimitiveModel('items', 'IIngredient'),
+            export: 'reference',
+            type: 'IIngredient$2',
+            isRequired: true,
+        };
+        const container = createInterfaceModel('IContainer', [ref]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [container, ingredient1, ingredient2],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const prepared1 = prepared.models.find(model => model.name === 'IIngredient' && !model.alias);
+        const prepared2 = prepared.models.find(model => model.alias === 'IIngredient$2');
+        node_assert_1.default.strictEqual(prepared1?.rawName, 'IIngredientRaw');
+        node_assert_1.default.strictEqual(prepared1?.dtoName, 'IIngredientDto');
+        node_assert_1.default.strictEqual(prepared2?.rawName, 'IIngredient$2Raw');
+        node_assert_1.default.strictEqual(prepared2?.dtoName, 'IIngredient$2Dto');
+        const itemsProperty = prepared.models.find(model => model.name === 'IContainer')?.properties[0];
+        node_assert_1.default.strictEqual(itemsProperty?.rawType, 'IIngredient$2Raw');
+        node_assert_1.default.strictEqual(itemsProperty?.dtoType, 'IIngredient$2Dto');
+    });
+    (0, node_test_1.test)('adds undefined fallback for optional dto fields without defaults', () => {
+        const optionalProp = createPrimitiveModel('detail', 'string');
+        optionalProp.isRequired = false;
+        const model = createInterfaceModel('IProblem', [optionalProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [model],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models[0]?.properties[0];
+        node_assert_1.default.match(property?.dtoType ?? '', /undefined/);
+        node_assert_1.default.strictEqual(property?.dtoInit, 'data.detail ?? undefined');
+    });
+    (0, node_test_1.test)('attaches dto getters for aliased duplicate models', () => {
+        const sequence = createInterfaceModel('ISequence', [createPrimitiveModel('pathwayId', 'string')]);
+        sequence.alias = 'ISequence$2';
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [sequence],
+            services: [],
+            miracles: [
+                {
+                    type: 'RENAME',
+                    oldPath: '$.components.schemas.Sequence.properties.pathway_id',
+                    newPath: '$.components.schemas.Sequence.properties.pathwayId',
+                    confidence: 1,
+                    status: 'confirmed',
+                    modelName: 'ISequence$2',
+                    oldProperty: 'pathway_id',
+                    newProperty: 'pathwayId',
+                },
+            ],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedSequence = prepared.models.find(model => model.alias === 'ISequence$2');
+        node_assert_1.default.ok(preparedSequence?.dtoGetters);
+        node_assert_1.default.strictEqual(preparedSequence?.dtoGetters?.[0].oldName, 'pathway_id');
+        node_assert_1.default.strictEqual(preparedSequence?.dtoGetters?.[0].newName, 'pathwayId');
+    });
+    (0, node_test_1.test)('uses bracket accessor for quoted property names', () => {
+        const quotedProp = createPrimitiveModel("'weird-name'", 'string');
+        const model = createInterfaceModel('IQuoted', [quotedProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [model],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models[0]?.properties[0];
+        node_assert_1.default.strictEqual(property?.dtoInit, "data['weird-name'] ?? undefined");
+        node_assert_1.default.strictEqual(property?.dtoTarget, "['weird-name']");
+    });
+});

package/dist/core/utils/__tests__/registerHandlebarHelpers.test.js

@@ -39,8 +39,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const Handlebars = __importStar(require("handlebars/runtime"));
+const header_1 = __importDefault(require("../../../templatesCompiled/client/partials/header"));
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const registerHandlebarHelpers_1 = require("../registerHandlebarHelpers");
+const GENERATED_FILE_COMMENT = 'This file was automatically generated by the generator';
+function renderHeaderPartial(useBatchEslintFix) {
+    (0, registerHandlebarHelpers_1.registerHandlebarHelpers)({
+        httpClient: HttpClient_enum_1.HttpClient.FETCH,
+        useOptions: false,
+        useUnionTypes: false,
+        useBatchEslintFix,
+    });
+    Handlebars.registerPartial('header', Handlebars.template(header_1.default));
+    return Handlebars.partials['header']({});
+}
 (0, node_test_1.describe)('@unit: registerHandlebarHelpers', () => {
     (0, node_test_1.test)('should register the helpers', () => {
         (0, registerHandlebarHelpers_1.registerHandlebarHelpers)({
@@ -54,5 +66,20 @@ const registerHandlebarHelpers_1 = require("../registerHandlebarHelpers");
         node_assert_1.default.ok(helpers.some(item => item === 'containsSpaces'));
         node_assert_1.default.ok(helpers.some(item => item === 'union'));
         node_assert_1.default.ok(helpers.some(item => item === 'intersection'));
+        node_assert_1.default.ok(helpers.some(item => item === 'useBatchEslintFix'));
+    });
+    (0, node_test_1.test)('header partial includes generated-file comment and disable directives when batch ESLint is off', () => {
+        const output = renderHeaderPartial(false);
+        node_assert_1.default.match(output, new RegExp(GENERATED_FILE_COMMENT));
+        node_assert_1.default.match(output, /\/\* istanbul ignore file \*\//);
+        node_assert_1.default.match(output, /\/\* tslint:disable \*\//);
+        node_assert_1.default.match(output, /\/\* eslint-disable \*\//);
+    });
+    (0, node_test_1.test)('header partial omits disable directives when batch ESLint is on', () => {
+        const output = renderHeaderPartial(true);
+        node_assert_1.default.match(output, new RegExp(GENERATED_FILE_COMMENT));
+        node_assert_1.default.match(output, /\/\* istanbul ignore file \*\//);
+        node_assert_1.default.doesNotMatch(output, /tslint:disable/);
+        node_assert_1.default.doesNotMatch(output, /eslint-disable/);
     });
 });