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

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__/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/);
     });
 });

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

@@ -14,24 +14,15 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             (0, createOperationParameter_1.createOperationParameter)('optional', { isRequired: false }),
             (0, createOperationParameter_1.createOperationParameter)('required', { isRequired: true }),
             (0, createOperationParameter_1.createOperationParameter)('optional-with-default', { isRequired: false, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('required-with-default', { isRequired: true, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('required-with-default', { isRequired: true, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
-        node_assert_1.default.deepStrictEqual(sortedNames, [
-            'required',
-            'required-with-default',
-            'optional',
-            'optional-with-default'
-        ]);
+        node_assert_1.default.deepStrictEqual(sortedNames, ['required', 'required-with-default', 'optional', 'optional-with-default']);
     });
     // Comparison tests within groups
     (0, node_test_1.test)('must sort by name within the required group', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: true })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: true })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['Alpha', 'Beta', 'Gamma']);
@@ -40,18 +31,14 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         const params = [
             (0, createOperationParameter_1.createOperationParameter)('Zeta', { isRequired: true, default: 'def' }),
             (0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['Alpha', 'Beta', 'Zeta']);
     });
     (0, node_test_1.test)('it should sort by name within the optional group', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('Second', { isRequired: false }),
-            (0, createOperationParameter_1.createOperationParameter)('First', { isRequired: false }),
-            (0, createOperationParameter_1.createOperationParameter)('Third', { isRequired: false })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('Second', { isRequired: false }), (0, createOperationParameter_1.createOperationParameter)('First', { isRequired: false }), (0, createOperationParameter_1.createOperationParameter)('Third', { isRequired: false })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['First', 'Second', 'Third']);
@@ -60,7 +47,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         const params = [
             (0, createOperationParameter_1.createOperationParameter)('Dog', { isRequired: false, default: 'def' }),
             (0, createOperationParameter_1.createOperationParameter)('Cat', { isRequired: false, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('Bird', { isRequired: false, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('Bird', { isRequired: false, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
@@ -73,7 +60,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         ['required', 'optional-with-default'],
         ['required-with-default', 'optional'],
         ['required-with-default', 'optional-with-default'],
-        ['optional', 'optional-with-default']
+        ['optional', 'optional-with-default'],
     ];
     for (const [groupA, groupB] of groupPairs) {
         (0, node_test_1.test)(`must place "${groupA}" before "${groupB}"`, () => {
@@ -118,7 +105,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: false }), // optional
             (0, createOperationParameter_1.createOperationParameter)('Delta', { isRequired: true, default: 'def' }), // required-with-default
             (0, createOperationParameter_1.createOperationParameter)('Epsilon', { isRequired: false, default: 'def' }), // optional-with-default
-            (0, createOperationParameter_1.createOperationParameter)('Alpha2', { isRequired: true }) // required
+            (0, createOperationParameter_1.createOperationParameter)('Alpha2', { isRequired: true }), // required
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
@@ -128,16 +115,12 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             'Delta', // required-with-default
             'Beta', // optional
             'Gamma', // optional
-            'Epsilon' // optional-with-default
+            'Epsilon', // optional-with-default
         ]);
     });
     // A test for borderline cases
     (0, node_test_1.test)('It must handle empty names correctly.', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('B', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('A', { isRequired: true })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('B', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('A', { isRequired: true })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['', 'A', 'B']);

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":""}

package/dist/core/utils/adapters/__tests__/semanticToStructural.test.js

@@ -0,0 +1,63 @@
+"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 semanticToStructural_1 = require("../semanticToStructural");
+(0, node_test_1.describe)('@unit: semanticToStructural adapter', () => {
+    (0, node_test_1.test)('groups semantic changes by legacy severity and calculates stats', () => {
+        const changes = [
+            {
+                type: 'model.property.removed',
+                severity: 'breaking',
+                path: '#/components/schemas/User/properties/oldName',
+                message: 'removed',
+                from: { type: 'string' },
+            },
+            {
+                type: 'model.property.added',
+                severity: 'non-breaking',
+                path: '#/components/schemas/User/properties/newName',
+                message: 'added',
+                to: { type: 'string' },
+            },
+            {
+                type: 'model.property.type.changed',
+                severity: 'informational',
+                path: '#/components/schemas/User/properties/age',
+                message: 'type changed',
+                from: 'integer',
+                to: 'integer:int64',
+            },
+        ];
+        const structural = (0, semanticToStructural_1.adaptSemanticToStructural)({ changes }, 2);
+        node_assert_1.default.strictEqual(structural.diff.all.length, 3);
+        node_assert_1.default.strictEqual(structural.diff.breaking.length, 1);
+        node_assert_1.default.strictEqual(structural.diff.warnings.length, 1);
+        node_assert_1.default.strictEqual(structural.diff.info.length, 1);
+        node_assert_1.default.strictEqual(structural.stats.totalChanges, 3);
+        node_assert_1.default.strictEqual(structural.stats.added, 1);
+        node_assert_1.default.strictEqual(structural.stats.removed, 1);
+        node_assert_1.default.strictEqual(structural.stats.changed, 1);
+        node_assert_1.default.strictEqual(structural.stats.ignored, 2);
+        node_assert_1.default.strictEqual(structural.stats.stabilityScore, 67);
+    });
+    (0, node_test_1.test)('uses provided miracles instead of rebuilding them', () => {
+        const structural = (0, semanticToStructural_1.adaptSemanticToStructural)({
+            changes: [],
+            miracles: [
+                {
+                    oldPath: '$.old',
+                    newPath: '$.new',
+                    type: 'RENAME',
+                    confidence: 1,
+                    status: 'confirmed',
+                },
+            ],
+        });
+        node_assert_1.default.strictEqual(structural.miracles.length, 1);
+        node_assert_1.default.strictEqual(structural.miracles[0].status, 'confirmed');
+    });
+});

package/dist/core/utils/adapters/extractMiraclesFromSemantic.d.ts

@@ -0,0 +1,10 @@
+import type { SemanticDiffChange } from '../../semanticDiff/analyzeOpenApiDiff';
+import type { MiracleEntry } from '../../types/shared/Miracle.model';
+/**
+ * Возвращает miracles из отчёта или строит их из семантических изменений.
+ * @param changes список семантических изменений
+ * @param [miracles] готовый список miracles из отчёта
+ * @returns список miracles для структурного diff
+ */
+export declare function extractMiraclesFromSemantic(changes: SemanticDiffChange[], miracles?: MiracleEntry[]): MiracleEntry[];
+//# sourceMappingURL=extractMiraclesFromSemantic.d.ts.map

package/dist/core/utils/adapters/extractMiraclesFromSemantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractMiraclesFromSemantic.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/adapters/extractMiraclesFromSemantic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,kBAAkB,EAAE,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAEpH"}

package/dist/core/utils/adapters/extractMiraclesFromSemantic.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMiraclesFromSemantic = extractMiraclesFromSemantic;
+const buildMiraclesFromSemanticChanges_1 = require("../buildMiraclesFromSemanticChanges");
+/**
+ * Возвращает miracles из отчёта или строит их из семантических изменений.
+ * @param changes список семантических изменений
+ * @param [miracles] готовый список miracles из отчёта
+ * @returns список miracles для структурного diff
+ */
+function extractMiraclesFromSemantic(changes, miracles) {
+    return miracles?.length ? miracles : (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+}

package/dist/core/utils/adapters/index.d.ts

@@ -0,0 +1,4 @@
+/** Реэкспорт адаптеров семантического diff в структурный формат. */
+export { extractMiraclesFromSemantic } from './extractMiraclesFromSemantic';
+export { adaptSemanticToStructural, type SemanticDiffLike } from './semanticToStructural';
+//# sourceMappingURL=index.d.ts.map