ts-openapi-codegen 2.1.0-beta.8 → 2.1.0-beta.9

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

@@ -84,6 +84,137 @@ const createLogger = () => new Logger_1.Logger({
         });
         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)({
+            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)({
+            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');

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__/prepareDtoModels.test.js

@@ -81,7 +81,7 @@ const createInterfaceModel = (name, properties) => ({
         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[]');
+        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');
@@ -194,6 +194,78 @@ const createInterfaceModel = (name, properties) => ({
         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]);
@@ -205,7 +277,7 @@ const createInterfaceModel = (name, properties) => ({
         };
         const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
         const property = prepared.models[0]?.properties[0];
-        node_assert_1.default.strictEqual(property?.dtoInit, "data['weird-name']");
+        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__/resolveClassesModeTypes.test.d.ts

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

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

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

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

@@ -0,0 +1,111 @@
+"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 resolveClassesModeTypes_1 = require("../resolveClassesModeTypes");
+const createArrayResult = (itemBase, itemPath) => ({
+    in: 'response',
+    name: '',
+    alias: '',
+    path: '',
+    code: 200,
+    description: null,
+    export: 'array',
+    type: itemBase,
+    base: itemBase,
+    template: null,
+    link: null,
+    isDefinition: false,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [{ name: itemBase, alias: '', path: `./${itemPath}` }],
+    enum: [],
+    enums: [],
+    properties: [],
+});
+(0, node_test_1.describe)('@unit: resolveClassesModeTypes', () => {
+    (0, node_test_1.test)('resolves array result types and imports to aliased export names', () => {
+        const ingredientCanonical = {
+            name: 'IIngredient',
+            alias: '',
+            path: 'components/schemas-v2/Ingredient',
+            export: 'interface',
+            type: 'IIngredient',
+            base: 'IIngredient',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        };
+        const ingredient = {
+            name: 'IIngredient',
+            alias: 'IIngredient$2',
+            path: 'components/schemas/Ingredient',
+            export: 'interface',
+            type: 'IIngredient',
+            base: 'IIngredient',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        };
+        const service = {
+            name: 'IngredientsService',
+            originName: 'Ingredients',
+            imports: [{ name: 'IIngredient', alias: '', path: './components/schemas/Ingredient' }],
+            operations: [
+                {
+                    service: 'IngredientsService',
+                    name: 'listSequenceIngredients',
+                    summary: null,
+                    description: null,
+                    deprecated: false,
+                    method: 'GET',
+                    path: '/sequences/{sequenceId}/ingredients',
+                    parameters: [],
+                    parametersPath: [],
+                    parametersQuery: [],
+                    parametersForm: [],
+                    parametersHeader: [],
+                    parametersCookie: [],
+                    parametersBody: null,
+                    imports: [],
+                    errors: [],
+                    results: [createArrayResult('IIngredient', 'components/schemas/Ingredient')],
+                    responseHeader: null,
+                    responseType: null,
+                },
+            ],
+        };
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [ingredientCanonical, ingredient],
+            services: [service],
+        };
+        const prepared = (0, resolveClassesModeTypes_1.resolveClassesModeTypes)((0, prepareDtoModels_1.prepareDtoModels)(client));
+        const operation = prepared.services[0]?.operations[0];
+        node_assert_1.default.strictEqual(prepared.services[0]?.imports[0].name, 'IIngredient$2');
+        node_assert_1.default.strictEqual(operation?.results[0].base, 'IIngredient$2');
+        node_assert_1.default.strictEqual(operation?.results[0].type, 'IIngredient$2');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,68 @@
+"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 semanticChangesToDiffEntries_1 = require("../semanticChangesToDiffEntries");
+(0, node_test_1.describe)('@unit: semanticChangesToDiffEntries', () => {
+    (0, node_test_1.test)('maps property type change to legacy diff entry', () => {
+        const change = {
+            type: 'model.property.type.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/properties/age',
+            message: 'Property "age" type changed',
+            from: 'string',
+            to: 'integer',
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'changed');
+        node_assert_1.default.strictEqual(entry.severity, 'breaking');
+        node_assert_1.default.strictEqual(entry.path, '$.components.schemas.User.properties.age.type');
+        node_assert_1.default.strictEqual(entry.from, 'string');
+        node_assert_1.default.strictEqual(entry.to, 'integer');
+        node_assert_1.default.strictEqual(entry.note, change.message);
+    });
+    (0, node_test_1.test)('maps operation removed with metadata payload', () => {
+        const change = {
+            type: 'operation.removed',
+            severity: 'breaking',
+            path: '#/paths/GET /pets',
+            message: 'Operation removed',
+            from: {
+                operationId: 'listPets',
+                summary: 'List pets',
+                tags: ['pets'],
+            },
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'removed');
+        node_assert_1.default.strictEqual(entry.path, "$.paths['/pets'].get");
+        node_assert_1.default.deepStrictEqual(entry.from, change.from);
+    });
+    (0, node_test_1.test)('maps required flag change via fromRequired/toRequired', () => {
+        const change = {
+            type: 'model.property.required.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/required/email',
+            message: 'required changed',
+            fromRequired: false,
+            toRequired: true,
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'changed');
+        node_assert_1.default.strictEqual(entry.from, false);
+        node_assert_1.default.strictEqual(entry.to, true);
+    });
+    (0, node_test_1.test)('exposes semantic mapping helpers', () => {
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticChangeTypeToAction)('model.property.removed'), 'removed');
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticSeverityToDiffSeverity)('non-breaking'), 'warning');
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticChangeToJsonPath)({
+            type: 'model.property.type.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/properties/age',
+            message: 'type',
+        }), '$.components.schemas.User.properties.age.type');
+    });
+});

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

@@ -107,16 +107,15 @@ function createOperationResponse(overrides = {}) {
         const aliasByPath = new Map(service.imports.map(item => [item.path, item.alias]));
         const aliasA = aliasByPath.get('models/a/Foo');
         const aliasB = aliasByPath.get('models/b/Foo');
-        node_assert_1.default.ok(aliasA);
-        node_assert_1.default.ok(aliasB);
-        node_assert_1.default.notEqual(aliasA, aliasB);
-        node_assert_1.default.equal(paramFooA.base, aliasA);
-        node_assert_1.default.equal(paramFooA.type, aliasA);
-        node_assert_1.default.equal(paramFooBArray.base, aliasB);
-        node_assert_1.default.equal(paramFooBArray.type, aliasB);
-        node_assert_1.default.equal(paramFooBArray.link?.base, aliasB);
-        node_assert_1.default.equal(paramFooBArray.link?.type, aliasB);
-        node_assert_1.default.equal(operation.results[0].base, aliasB);
-        node_assert_1.default.equal(operation.results[0].type, aliasB);
+        node_assert_1.default.strictEqual(aliasA, '');
+        node_assert_1.default.strictEqual(aliasB, 'Foo$2');
+        node_assert_1.default.equal(paramFooA.base, 'Foo');
+        node_assert_1.default.equal(paramFooA.type, 'Foo');
+        node_assert_1.default.equal(paramFooBArray.base, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.type, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.link?.base, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.link?.type, 'Foo$2');
+        node_assert_1.default.equal(operation.results[0].base, 'Foo$2');
+        node_assert_1.default.equal(operation.results[0].type, 'Foo$2');
     });
 });

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

@@ -100,6 +100,77 @@ const exportModelsContext = {
         node_assert_1.default.match(clientOutput, /createClient|RequestExecutor/i);
         node_assert_1.default.match(modelsOutput, /BaseDto|fromArray/);
     });
+    (0, node_test_1.test)('renders exportModels with ghost properties and type aliases', () => {
+        const modelWithGhost = {
+            ...schemaModel,
+            name: 'IUser',
+            type: 'IUser',
+            base: 'IUser',
+            rawName: 'IUserRaw',
+            dtoName: 'IUserDto',
+            exportName: 'IUser',
+            dtoKind: 'class',
+            ghostProperties: [
+                {
+                    name: 'legacyField',
+                    alias: '',
+                    path: 'models',
+                    export: 'generic',
+                    type: 'unknown',
+                    base: 'unknown',
+                    template: null,
+                    link: null,
+                    description: null,
+                    isDefinition: false,
+                    isReadOnly: false,
+                    isRequired: false,
+                    isNullable: false,
+                    imports: [],
+                    enum: [],
+                    enums: [],
+                    properties: [],
+                    isGhost: true,
+                },
+            ],
+            properties: [
+                {
+                    name: 'id',
+                    alias: '',
+                    path: 'models',
+                    export: 'generic',
+                    type: 'string',
+                    base: 'string',
+                    template: null,
+                    link: null,
+                    description: null,
+                    isDefinition: false,
+                    isReadOnly: false,
+                    isRequired: true,
+                    isNullable: false,
+                    imports: [],
+                    enum: [],
+                    enums: [],
+                    properties: [],
+                    rawType: 'string',
+                    dtoType: 'string',
+                    dtoInit: 'data.id',
+                    dtoTarget: '.id',
+                },
+            ],
+        };
+        const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useOptions: false,
+            useUnionTypes: false,
+            validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.NONE,
+        });
+        const output = templates.exports.models({
+            ...exportModelsContext,
+            models: [modelWithGhost],
+        });
+        node_assert_1.default.match(output, /legacyField\?: unknown/);
+        node_assert_1.default.match(output, /export type IUser = IUserRaw/);
+    });
     (0, node_test_1.test)('renders schema export with validation library context', () => {
         const templates = (0, registerHandlebarTemplates_1.registerHandlebarTemplates)({
             httpClient: HttpClient_enum_1.HttpClient.FETCH,

package/dist/core/utils/adapters/__tests__/semanticToStructural.test.d.ts

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

package/dist/core/utils/adapters/__tests__/semanticToStructural.test.d.ts.map

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