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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/adapters/index.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,yBAAyB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptSemanticToStructural = exports.extractMiraclesFromSemantic = void 0;
+/** Реэкспорт адаптеров семантического diff в структурный формат. */
+var extractMiraclesFromSemantic_1 = require("./extractMiraclesFromSemantic");
+Object.defineProperty(exports, "extractMiraclesFromSemantic", { enumerable: true, get: function () { return extractMiraclesFromSemantic_1.extractMiraclesFromSemantic; } });
+var semanticToStructural_1 = require("./semanticToStructural");
+Object.defineProperty(exports, "adaptSemanticToStructural", { enumerable: true, get: function () { return semanticToStructural_1.adaptSemanticToStructural; } });

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

@@ -0,0 +1,12 @@
+import type { SemanticDiffReport } from '../../semanticDiff/analyzeOpenApiDiff';
+import type { StructuralDiffPart } from '../../types/DiffReport.model';
+/** Минимальный набор полей семантического diff для адаптации в структурный формат. */
+export type SemanticDiffLike = Pick<SemanticDiffReport, 'changes' | 'miracles'>;
+/**
+ * Преобразует семантический diff в структурную часть legacy-отчёта.
+ * @param semantic семантический diff или его подмножество
+ * @param [ignored] количество проигнорированных изменений
+ * @returns структурная часть diff-отчёта
+ */
+export declare function adaptSemanticToStructural(semantic: SemanticDiffLike, ignored?: number): StructuralDiffPart;
+//# sourceMappingURL=semanticToStructural.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semanticToStructural.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/adapters/semanticToStructural.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAChF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAIvE,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,kBAAkB,EAAE,SAAS,GAAG,UAAU,CAAC,CAAC;AAgBhF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAa1G"}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptSemanticToStructural = adaptSemanticToStructural;
+const semanticChangesToDiffEntries_1 = require("../semanticChangesToDiffEntries");
+const extractMiraclesFromSemantic_1 = require("./extractMiraclesFromSemantic");
+function calculateStats(all, ignored) {
+    const breakingCount = all.filter(entry => entry.severity === 'breaking').length;
+    const stabilityScore = all.length === 0 ? 100 : Math.round(((all.length - breakingCount) / all.length) * 100);
+    return {
+        totalChanges: all.length,
+        added: all.filter(entry => entry.action === 'added').length,
+        removed: all.filter(entry => entry.action === 'removed').length,
+        changed: all.filter(entry => entry.action === 'changed').length,
+        ignored: ignored || undefined,
+        stabilityScore,
+    };
+}
+/**
+ * Преобразует семантический diff в структурную часть legacy-отчёта.
+ * @param semantic семантический diff или его подмножество
+ * @param [ignored] количество проигнорированных изменений
+ * @returns структурная часть diff-отчёта
+ */
+function adaptSemanticToStructural(semantic, ignored) {
+    const all = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)(semantic.changes);
+    return {
+        diff: {
+            breaking: all.filter(entry => entry.severity === 'breaking'),
+            warnings: all.filter(entry => entry.severity === 'warning'),
+            info: all.filter(entry => entry.severity === 'info'),
+            all,
+        },
+        miracles: (0, extractMiraclesFromSemantic_1.extractMiraclesFromSemantic)(semantic.changes, semantic.miracles),
+        stats: calculateStats(all, ignored),
+    };
+}

package/dist/core/utils/applyDiffReportToClient.d.ts

@@ -1,3 +1,4 @@
+import type { Context } from '../Context';
 import type { PrefixArtifacts } from '../types/base/PrefixArtifacts.model';
 import type { Client } from '../types/shared/Client.model';
 import { OpenApiVersion } from './getOpenApiVersion';
@@ -8,7 +9,18 @@ type ApplyDiffParams = {
     openApiVersion: OpenApiVersion;
     diffReport: DiffReport | null;
     prefix: PrefixArtifacts;
+    context?: Context;
 };
-export declare const applyDiffReportToClient: ({ client, openApi, openApiVersion, diffReport, prefix }: ApplyDiffParams) => Client;
+/**
+ * Применяет структурный diff-отчёт к сгенерированному клиенту: помечает изменения, miracles и ghost-свойства.
+ * @param client сгенерированный клиент
+ * @param openApi исходная OpenAPI-спецификация
+ * @param openApiVersion версия OpenAPI
+ * @param diffReport загруженный diff-отчёт или null
+ * @param prefix артефакты префиксов имён
+ * @param [context] контекст генерации для разрешения имён схем
+ * @returns клиент с аннотациями diff
+ */
+export declare const applyDiffReportToClient: ({ client, openApi, openApiVersion, diffReport, prefix, context }: ApplyDiffParams) => Client;
 export {};
 //# sourceMappingURL=applyDiffReportToClient.d.ts.map

package/dist/core/utils/applyDiffReportToClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applyDiffReportToClient.d.ts","sourceRoot":"","sources":["../../../src/core/utils/applyDiffReportToClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAW3D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAIrD,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,kBAAkB,CAAC;AAGpE,KAAK,eAAe,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,eAAe,CAAC;CAC3B,CAAC;AAuWF,eAAO,MAAM,uBAAuB,GAAI,yDAAyD,eAAe,KAAG,MAwClH,CAAC"}
+{"version":3,"file":"applyDiffReportToClient.d.ts","sourceRoot":"","sources":["../../../src/core/utils/applyDiffReportToClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAY3D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAKrD,OAAO,KAAK,EAAE,UAAU,EAAmB,MAAM,kBAAkB,CAAC;AAGpE,KAAK,eAAe,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAsbF;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,kEAAkE,eAAe,KAAG,MAwC3H,CAAC"}

package/dist/core/utils/applyDiffReportToClient.js

@@ -9,6 +9,7 @@ const getComment_1 = require("./getComment");
 const getModelNameWithPrefix_1 = require("./getModelNameWithPrefix");
 const getOpenApiVersion_1 = require("./getOpenApiVersion");
 const getOperationName_1 = require("./getOperationName");
+const getOperationParameterName_1 = require("./getOperationParameterName");
 const getOperationPath_1 = require("./getOperationPath");
 const getServiceClassName_1 = require("./getServiceClassName");
 const serviceHelpers_1 = require("./serviceHelpers");
@@ -21,12 +22,28 @@ const getSchemaDefinitions = (openApi, version) => {
     const definitions = openApi?.definitions;
     return definitions ?? {};
 };
-const buildSchemaNameMap = (openApi, version, prefix) => {
+const buildLocalSchemaRef = (schemaName, version) => (version === getOpenApiVersion_1.OpenApiVersion.V3 ? `#/components/schemas/${schemaName}` : `#/definitions/${schemaName}`);
+const resolveSchemaDefinition = (schemaName, schemaDef, version, context) => {
+    if (context) {
+        try {
+            const resolved = context.get(buildLocalSchemaRef(schemaName, version));
+            if (resolved && typeof resolved === 'object') {
+                return resolved;
+            }
+        }
+        catch {
+            // fallback to raw schemaDef
+        }
+    }
+    return schemaDef;
+};
+const buildSchemaNameMap = (openApi, version, prefix, context) => {
     const definitions = getSchemaDefinitions(openApi, version);
     const map = new Map();
     Object.entries(definitions).forEach(([schemaName, schemaDef]) => {
+        const resolvedDef = resolveSchemaDefinition(schemaName, schemaDef, version, context);
         const encodedName = (0, encode_1.encode)(schemaName);
-        const modelName = (0, getModelNameWithPrefix_1.getModelNameWithPrefix)(encodedName, schemaDef, prefix);
+        const modelName = (0, getModelNameWithPrefix_1.getModelNameWithPrefix)(encodedName, resolvedDef, prefix);
         map.set(schemaName, modelName);
     });
     return map;
@@ -96,7 +113,43 @@ const mergeOperationDiff = (existing, entry) => {
         severity,
     };
 };
-const buildOperationKey = (method, path) => `${method.toUpperCase()} ${(0, getOperationPath_1.getOperationPath)(path)}`;
+const normalizeOperationPathForKey = (path) => path.replace(/\$\{([^}]+)\}/g, '{$1}').replace(/\{([^}]+)\}/g, (substring, name) => (substring === '{api-version}' ? substring : `{${name}}`));
+const buildOperationKey = (method, path) => `${method.toUpperCase()} ${normalizeOperationPathForKey(path)}`;
+const createGhostPathParameters = (path) => {
+    const parameters = [];
+    const pattern = /\{([^}]+)\}/g;
+    let match;
+    while ((match = pattern.exec(path)) !== null) {
+        const prop = match[1];
+        if (prop === 'api-version') {
+            continue;
+        }
+        const name = (0, getOperationParameterName_1.getOperationParameterName)(prop);
+        parameters.push({
+            in: 'path',
+            prop,
+            name,
+            alias: '',
+            path: '',
+            export: 'generic',
+            type: 'string',
+            base: 'string',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: false,
+            isReadOnly: false,
+            isRequired: true,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+            mediaType: null,
+        });
+    }
+    return parameters;
+};
 const findOperationMatches = (entries) => {
     const operationDiffs = new Map();
     const removedOperations = [];
@@ -128,6 +181,7 @@ const createGhostOperation = (match, serviceName) => {
     const description = typeof from.description === 'string' ? from.description : '';
     const operationNameFallback = `${match.method}${serviceName}`;
     const operationName = (0, getOperationName_1.getOperationName)(operationId || operationNameFallback);
+    const pathParameters = createGhostPathParameters(match.path);
     return {
         service: serviceName,
         name: operationName,
@@ -136,8 +190,8 @@ const createGhostOperation = (match, serviceName) => {
         deprecated: true,
         method: match.method.toUpperCase(),
         path: (0, getOperationPath_1.getOperationPath)(match.path),
-        parameters: [],
-        parametersPath: [],
+        parameters: pathParameters,
+        parametersPath: pathParameters,
         parametersQuery: [],
         parametersForm: [],
         parametersHeader: [],
@@ -196,20 +250,32 @@ const applyOperationDiffs = (client, entries) => {
     }
     client.services = Array.from(servicesMap.values());
 };
-const applyModelDiffs = (client, entries, openApi, openApiVersion, prefix) => {
-    const schemaNameMap = buildSchemaNameMap(openApi, openApiVersion, prefix);
-    const modelsByName = new Map(client.models.map(model => [model.name, model]));
+const buildModelsByName = (models) => {
+    const modelsByName = new Map();
+    models.forEach(model => {
+        const list = modelsByName.get(model.name) ?? [];
+        list.push(model);
+        modelsByName.set(model.name, list);
+    });
+    return modelsByName;
+};
+const getModelsForSchema = (schemaName, schemaNameMap, modelsByName) => {
+    const modelName = schemaNameMap.get(schemaName);
+    if (!modelName)
+        return [];
+    return modelsByName.get(modelName) ?? [];
+};
+const applyModelDiffs = (client, entries, openApi, openApiVersion, prefix, context) => {
+    const schemaNameMap = buildSchemaNameMap(openApi, openApiVersion, prefix, context);
+    const modelsByName = buildModelsByName(client.models);
     const ghostPropertyKeys = new Set();
     entries.forEach(entry => {
         const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
         const schemaName = getSchemaNameFromSegments(segments, openApiVersion);
         if (!schemaName)
             return;
-        const modelName = schemaNameMap.get(schemaName);
-        if (!modelName)
-            return;
-        const model = modelsByName.get(modelName);
-        if (!model)
+        const models = getModelsForSchema(schemaName, schemaNameMap, modelsByName);
+        if (models.length === 0)
             return;
         const propertiesIndex = segments.indexOf('properties');
         if (propertiesIndex === -1 || propertiesIndex + 1 >= segments.length) {
@@ -217,68 +283,70 @@ const applyModelDiffs = (client, entries, openApi, openApiVersion, prefix) => {
         }
         const rawPropertyName = segments[propertiesIndex + 1];
         const propertyName = (0, escapeName_1.escapeName)(rawPropertyName);
-        if (entry.action === 'removed' && propertiesIndex + 1 === segments.length - 1) {
-            const key = `${modelName}:${propertyName}`;
-            if (ghostPropertyKeys.has(key))
-                return;
-            const exists = model.properties.some(prop => prop.name === propertyName);
-            if (!exists) {
-                const ghost = {
-                    name: propertyName,
-                    alias: '',
-                    path: model.path,
-                    export: 'generic',
-                    type: 'unknown',
-                    base: 'unknown',
-                    template: null,
-                    link: null,
-                    description: null,
-                    isDefinition: false,
-                    isReadOnly: false,
-                    isRequired: false,
-                    isNullable: false,
-                    imports: [],
-                    enum: [],
-                    enums: [],
-                    properties: [],
-                    diff: {
-                        action: 'removed',
-                        path: entry.path,
-                        severity: entry.severity,
-                        from: entry.from,
-                        to: entry.to,
-                    },
-                    isGhost: true,
-                };
-                if (!model.ghostProperties) {
-                    model.ghostProperties = [];
+        for (const model of models) {
+            if (entry.action === 'removed' && propertiesIndex + 1 === segments.length - 1) {
+                const key = `${model.name}:${model.alias}:${propertyName}`;
+                if (ghostPropertyKeys.has(key))
+                    continue;
+                const exists = model.properties.some(prop => prop.name === propertyName);
+                if (!exists) {
+                    const ghost = {
+                        name: propertyName,
+                        alias: '',
+                        path: model.path,
+                        export: 'generic',
+                        type: 'unknown',
+                        base: 'unknown',
+                        template: null,
+                        link: null,
+                        description: null,
+                        isDefinition: false,
+                        isReadOnly: false,
+                        isRequired: false,
+                        isNullable: false,
+                        imports: [],
+                        enum: [],
+                        enums: [],
+                        properties: [],
+                        diff: {
+                            action: 'removed',
+                            path: entry.path,
+                            severity: entry.severity,
+                            from: entry.from,
+                            to: entry.to,
+                        },
+                        isGhost: true,
+                    };
+                    if (!model.ghostProperties) {
+                        model.ghostProperties = [];
+                    }
+                    model.ghostProperties.push(ghost);
+                    ghostPropertyKeys.add(key);
                 }
-                model.ghostProperties.push(ghost);
-                ghostPropertyKeys.add(key);
+                continue;
             }
-            return;
-        }
-        if (entry.action === 'changed' && segments[segments.length - 1] === 'type') {
-            const property = model.properties.find(prop => prop.name === propertyName);
-            if (!property)
-                return;
-            const previousType = describeSchemaType(entry.from);
-            const currentTypeRaw = typeof entry.to === 'string' ? entry.to : describeSchemaType(entry.to);
-            const currentType = normalizeScalarType(currentTypeRaw);
-            const previousScalar = normalizeScalarType(previousType);
-            property.diff = {
-                action: entry.action,
-                path: entry.path,
-                severity: entry.severity,
-                from: entry.from,
-                to: entry.to,
-                previousType,
-            };
-            if (previousScalar && currentType && previousScalar !== currentType) {
-                property.needsCoercion = true;
-                property.coercionFrom = previousScalar;
-                property.coercionTo = currentType;
-                model.hasCoercion = true;
+            if (entry.action === 'changed' && segments[segments.length - 1] === 'type') {
+                const property = model.properties.find(prop => prop.name === propertyName);
+                if (!property)
+                    continue;
+                const previousType = describeSchemaType(entry.from);
+                const currentTypeRaw = typeof entry.to === 'string' ? entry.to : describeSchemaType(entry.to);
+                const currentType = normalizeScalarType(currentTypeRaw);
+                const previousScalar = normalizeScalarType(previousType);
+                property.diff = {
+                    action: entry.action,
+                    path: entry.path,
+                    severity: entry.severity,
+                    from: entry.from,
+                    to: entry.to,
+                    previousType,
+                };
+                if (previousScalar && currentType && previousScalar !== currentType) {
+                    property.needsCoercion = true;
+                    property.coercionFrom = previousScalar;
+                    property.coercionTo = currentType;
+                    model.hasCoercion = true;
+                }
             }
         }
     });
@@ -286,53 +354,65 @@ const applyModelDiffs = (client, entries, openApi, openApiVersion, prefix) => {
 const applyMiracleTypeCoercions = (client, confirmedMiracles, entries) => {
     if (!confirmedMiracles.length)
         return;
-    const modelsByName = new Map(client.models.map(model => [model.name, model]));
+    const modelsByName = buildModelsByName(client.models);
     for (const miracle of confirmedMiracles) {
         if (miracle.type !== 'TYPE_COERCION')
             continue;
         if (!miracle.modelName)
             continue;
-        const model = modelsByName.get(miracle.modelName);
-        if (!model)
+        const models = modelsByName.get(miracle.modelName) ?? [];
+        if (models.length === 0)
             continue;
         const rawProperty = miracle.newProperty ?? miracle.oldProperty;
         if (!rawProperty)
             continue;
         const propertyName = (0, escapeName_1.escapeName)(rawProperty);
-        const property = model.properties.find(prop => prop.name === propertyName);
-        if (!property)
-            continue;
-        property.needsCoercion = true;
-        model.hasCoercion = true;
-        if (!miracle.newPath)
-            continue;
-        const typePath = `${miracle.newPath}.type`;
-        const typeEntry = entries.find(entry => entry.action === 'changed' && entry.path === typePath);
-        if (!typeEntry)
-            continue;
-        const previousType = describeSchemaType(typeEntry.from);
-        const currentTypeRaw = typeof typeEntry.to === 'string' ? typeEntry.to : describeSchemaType(typeEntry.to);
-        const currentType = normalizeScalarType(currentTypeRaw);
-        const previousScalar = normalizeScalarType(previousType);
-        if (previousScalar && currentType && previousScalar !== currentType) {
-            property.coercionFrom = previousScalar;
-            property.coercionTo = currentType;
-            if (!property.diff) {
-                property.diff = {
-                    action: typeEntry.action,
-                    path: typeEntry.path,
-                    severity: typeEntry.severity,
-                    from: typeEntry.from,
-                    to: typeEntry.to,
-                    previousType,
-                };
+        for (const model of models) {
+            const property = model.properties.find(prop => prop.name === propertyName);
+            if (!property)
+                continue;
+            property.needsCoercion = true;
+            model.hasCoercion = true;
+            if (!miracle.newPath)
+                continue;
+            const typePath = `${miracle.newPath}.type`;
+            const typeEntry = entries.find(entry => entry.action === 'changed' && entry.path === typePath);
+            if (!typeEntry)
+                continue;
+            const previousType = describeSchemaType(typeEntry.from);
+            const currentTypeRaw = typeof typeEntry.to === 'string' ? typeEntry.to : describeSchemaType(typeEntry.to);
+            const currentType = normalizeScalarType(currentTypeRaw);
+            const previousScalar = normalizeScalarType(previousType);
+            if (previousScalar && currentType && previousScalar !== currentType) {
+                property.coercionFrom = previousScalar;
+                property.coercionTo = currentType;
+                if (!property.diff) {
+                    property.diff = {
+                        action: typeEntry.action,
+                        path: typeEntry.path,
+                        severity: typeEntry.severity,
+                        from: typeEntry.from,
+                        to: typeEntry.to,
+                        previousType,
+                    };
+                }
             }
         }
     }
 };
-const applyDiffReportToClient = ({ client, openApi, openApiVersion, diffReport, prefix }) => {
+/**
+ * Применяет структурный diff-отчёт к сгенерированному клиенту: помечает изменения, miracles и ghost-свойства.
+ * @param client сгенерированный клиент
+ * @param openApi исходная OpenAPI-спецификация
+ * @param openApiVersion версия OpenAPI
+ * @param diffReport загруженный diff-отчёт или null
+ * @param prefix артефакты префиксов имён
+ * @param [context] контекст генерации для разрешения имён схем
+ * @returns клиент с аннотациями diff
+ */
+const applyDiffReportToClient = ({ client, openApi, openApiVersion, diffReport, prefix, context }) => {
     const entries = diffReport?.diff?.all ?? [];
-    const schemaNameMap = buildSchemaNameMap(openApi, openApiVersion, prefix);
+    const schemaNameMap = buildSchemaNameMap(openApi, openApiVersion, prefix, context);
     const confirmedMiracles = (diffReport?.miracles ?? [])
         .filter(miracle => miracle.status === 'confirmed' || miracle.confidence === 1)
         .map(miracle => {
@@ -341,7 +421,7 @@ const applyDiffReportToClient = ({ client, openApi, openApiVersion, diffReport,
         const oldSchema = getSchemaNameFromSegments(oldSegments, openApiVersion);
         const newSchema = getSchemaNameFromSegments(newSegments, openApiVersion);
         const schemaName = oldSchema || newSchema;
-        const modelName = schemaName ? schemaNameMap.get(schemaName) : undefined;
+        const modelName = (schemaName ? schemaNameMap.get(schemaName) : undefined) ?? miracle.modelName;
         const oldPropIndex = oldSegments.indexOf('properties');
         const newPropIndex = newSegments.indexOf('properties');
         const oldProperty = oldPropIndex !== -1 ? oldSegments[oldPropIndex + 1] : undefined;
@@ -360,7 +440,7 @@ const applyDiffReportToClient = ({ client, openApi, openApiVersion, diffReport,
     if (entries.length === 0) {
         return client;
     }
-    applyModelDiffs(client, entries, openApi, openApiVersion, prefix);
+    applyModelDiffs(client, entries, openApi, openApiVersion, prefix, context);
     applyOperationDiffs(client, entries);
     return client;
 };

package/dist/core/utils/buildMiraclesFromSemanticChanges.d.ts

@@ -0,0 +1,25 @@
+import type { SemanticDiffChange } from '../semanticDiff/analyzeOpenApiDiff';
+import type { MiracleEntry } from '../types/shared/Miracle.model';
+type SemanticPropertyChange = {
+    schemaPath: string;
+    schemaName: string;
+    propertyName: string;
+    jsonPath: string;
+    payload: Record<string, unknown>;
+    typeSignature?: string;
+    description?: string;
+};
+/**
+ * Разбирает JSON Pointer свойства схемы в метаданные изменения.
+ * @param path JSON Pointer путь к свойству
+ * @returns метаданные изменения или null, если путь не относится к свойству схемы
+ */
+export declare function parseSchemaPropertyPointer(path: string): Omit<SemanticPropertyChange, 'payload' | 'typeSignature' | 'description'> | null;
+/**
+ * Строит miracles типов RENAME и TYPE_COERCION из семантических изменений.
+ * @param changes список семантических изменений
+ * @returns список miracles
+ */
+export declare function buildMiraclesFromSemanticChanges(changes: SemanticDiffChange[]): MiracleEntry[];
+export {};
+//# sourceMappingURL=buildMiraclesFromSemanticChanges.d.ts.map

package/dist/core/utils/buildMiraclesFromSemanticChanges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildMiraclesFromSemanticChanges.d.ts","sourceRoot":"","sources":["../../../src/core/utils/buildMiraclesFromSemanticChanges.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGlE,KAAK,sBAAsB,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,sBAAsB,EAAE,SAAS,GAAG,eAAe,GAAG,aAAa,CAAC,GAAG,IAAI,CAezI;AA0CD;;;;GAIG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,kBAAkB,EAAE,GAAG,YAAY,EAAE,CA6F9F"}