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

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

@@ -0,0 +1,77 @@
+"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 buildMiraclesFromSemanticChanges_1 = require("../buildMiraclesFromSemanticChanges");
+(0, node_test_1.describe)('@unit: buildMiraclesFromSemanticChanges', () => {
+    (0, node_test_1.test)('parses schema property pointer', () => {
+        const parsed = (0, buildMiraclesFromSemanticChanges_1.parseSchemaPropertyPointer)('#/components/schemas/User/properties/first_name');
+        node_assert_1.default.ok(parsed);
+        node_assert_1.default.strictEqual(parsed.schemaName, 'User');
+        node_assert_1.default.strictEqual(parsed.propertyName, 'first_name');
+        node_assert_1.default.strictEqual(parsed.jsonPath, '$.components.schemas.User.properties.first_name');
+    });
+    (0, node_test_1.test)('creates RENAME miracle between removed and added property', () => {
+        const changes = [
+            {
+                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' },
+            },
+        ];
+        const miracles = (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+        node_assert_1.default.strictEqual(miracles.length, 1);
+        node_assert_1.default.strictEqual(miracles[0].type, 'RENAME');
+        node_assert_1.default.strictEqual(miracles[0].oldPath, '$.components.schemas.User.properties.first_name');
+        node_assert_1.default.strictEqual(miracles[0].newPath, '$.components.schemas.User.properties.firstName');
+        node_assert_1.default.ok(miracles[0].confidence >= 0.8);
+    });
+    (0, node_test_1.test)('creates TYPE_COERCION miracle for scalar type changes', () => {
+        const changes = [
+            {
+                type: 'model.property.type.changed',
+                severity: 'breaking',
+                path: '#/components/schemas/User/properties/age',
+                message: 'type changed',
+                from: 'string',
+                to: 'integer',
+            },
+        ];
+        const miracles = (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+        node_assert_1.default.strictEqual(miracles.length, 1);
+        node_assert_1.default.strictEqual(miracles[0].type, 'TYPE_COERCION');
+        node_assert_1.default.strictEqual(miracles[0].oldPath, '$.components.schemas.User.properties.age');
+    });
+    (0, node_test_1.test)('returns empty list when rename candidates do not match', () => {
+        const changes = [
+            {
+                type: 'model.property.removed',
+                severity: 'breaking',
+                path: '#/components/schemas/User/properties/id',
+                message: 'removed',
+                from: { type: 'string' },
+            },
+            {
+                type: 'model.property.added',
+                severity: 'non-breaking',
+                path: '#/components/schemas/Account/properties/accountId',
+                message: 'added',
+                to: { type: 'string' },
+            },
+        ];
+        const miracles = (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+        node_assert_1.default.deepStrictEqual(miracles, []);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,159 @@
+"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 expandOpenApiRefsForSemanticDiff_1 = require("../expandOpenApiRefsForSemanticDiff");
+const sourceFile = '/tmp/openapi/api.yaml';
+function createResolver(entries) {
+    return {
+        exists: ref => Object.prototype.hasOwnProperty.call(entries, ref),
+        get: ref => entries[ref],
+    };
+}
+(0, node_test_1.describe)('@unit: expandOpenApiRefsForSemanticDiff', () => {
+    (0, node_test_1.test)('expands local refs without mutating the original document', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            id: { $ref: '#/components/schemas/UserId' },
+                        },
+                    },
+                    UserId: { type: 'string', format: 'uuid' },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.User.properties.id, { type: 'string', format: 'uuid' });
+        node_assert_1.default.deepStrictEqual(spec.components.schemas.User.properties.id, { $ref: '#/components/schemas/UserId' });
+    });
+    (0, node_test_1.test)('expands external file refs through the resolver', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: { $ref: './schemas/User.yaml' },
+                },
+            },
+        };
+        const resolver = createResolver({
+            '/tmp/openapi/schemas/User.yaml': {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                },
+            },
+        });
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { refs: resolver, sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.User, {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+            },
+        });
+    });
+    (0, node_test_1.test)('expands external file fragment refs through the resolver', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: { $ref: './schemas/common.yaml#/components/schemas/User' },
+                },
+            },
+        };
+        const resolver = createResolver({
+            '/tmp/openapi/schemas/common.yaml#/components/schemas/User': {
+                type: 'object',
+                required: ['id'],
+                properties: {
+                    id: { type: 'string' },
+                },
+            },
+        });
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { refs: resolver, sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.User, {
+            type: 'object',
+            required: ['id'],
+            properties: {
+                id: { type: 'string' },
+            },
+        });
+    });
+    (0, node_test_1.test)('expands path item refs', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {
+                '/users': { $ref: '#/components/pathItems/Users' },
+            },
+            components: {
+                pathItems: {
+                    Users: {
+                        get: {
+                            operationId: 'listUsers',
+                            responses: {
+                                '200': { description: 'ok' },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.paths['/users'], {
+            get: {
+                operationId: 'listUsers',
+                responses: {
+                    '200': { description: 'ok' },
+                },
+            },
+        });
+    });
+    (0, node_test_1.test)('keeps unresolved refs stable', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    Missing: { $ref: './missing.yaml#/Missing' },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.Missing, { $ref: './missing.yaml#/Missing' });
+    });
+    (0, node_test_1.test)('keeps circular refs stringify-safe', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    Node: {
+                        type: 'object',
+                        properties: {
+                            child: { $ref: '#/components/schemas/Node' },
+                        },
+                    },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        const child = expanded.components.schemas.Node.properties.child;
+        node_assert_1.default.deepStrictEqual(child.properties.child, { $ref: '#/components/schemas/Node' });
+        node_assert_1.default.doesNotThrow(() => JSON.stringify(expanded));
+    });
+});

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

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

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

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

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']);
     });
 });