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

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,3 @@
+/** Реэкспорт адаптеров семантического diff в структурный формат. */
+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,yBAAyB,EAAE,KAAK,gBAAgB,EAAE,MAAM,wBAAwB,CAAC"}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptSemanticToStructural = void 0;
+/** Реэкспорт адаптеров семантического diff в структурный формат. */
+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

@@ -0,0 +1,26 @@
+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';
+import type { DiffReport } from './loadDiffReport';
+type ApplyDiffParams = {
+    client: Client;
+    openApi: Record<string, unknown>;
+    openApiVersion: OpenApiVersion;
+    diffReport: DiffReport | null;
+    prefix: PrefixArtifacts;
+    context?: Context;
+};
+/**
+ * Применяет структурный 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDiffReportToClient = void 0;
+const jsonPath_1 = require("../../common/utils/jsonPath");
+const encode_1 = require("./encode");
+const escapeName_1 = require("./escapeName");
+const getClassName_1 = require("./getClassName");
+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");
+const getSchemaDefinitions = (openApi, version) => {
+    if (version === getOpenApiVersion_1.OpenApiVersion.V3) {
+        const components = openApi?.components;
+        const schemas = components?.schemas;
+        return schemas ?? {};
+    }
+    const definitions = openApi?.definitions;
+    return definitions ?? {};
+};
+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, resolvedDef, prefix);
+        map.set(schemaName, modelName);
+    });
+    return map;
+};
+const getSchemaNameFromSegments = (segments, version) => {
+    if (version === getOpenApiVersion_1.OpenApiVersion.V3) {
+        return segments[0] === 'components' && segments[1] === 'schemas' ? (segments[2] ?? null) : null;
+    }
+    return segments[0] === 'definitions' ? (segments[1] ?? null) : null;
+};
+const describeSchemaType = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        if (typeof record.$ref === 'string') {
+            return `ref:${record.$ref}`;
+        }
+        if (typeof record.type === 'string') {
+            return record.type;
+        }
+        if (Array.isArray(record.oneOf)) {
+            return 'oneOf';
+        }
+        if (Array.isArray(record.anyOf)) {
+            return 'anyOf';
+        }
+        if (Array.isArray(record.allOf)) {
+            return 'allOf';
+        }
+    }
+    return undefined;
+};
+const normalizeScalarType = (value) => {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (normalized === 'int' || normalized === 'integer')
+        return 'number';
+    if (normalized === 'float' || normalized === 'double')
+        return 'number';
+    if (normalized === 'string')
+        return 'string';
+    if (normalized === 'number')
+        return 'number';
+    if (normalized === 'boolean')
+        return 'boolean';
+    return undefined;
+};
+const mergeOperationDiff = (existing, entry) => {
+    if (!existing) {
+        return {
+            action: entry.action,
+            path: entry.path,
+            severity: entry.severity,
+            from: entry.from,
+            to: entry.to,
+        };
+    }
+    const severityOrder = ['info', 'warning', 'breaking'];
+    const existingScore = severityOrder.indexOf(existing.severity);
+    const incomingScore = severityOrder.indexOf(entry.severity);
+    const severity = incomingScore > existingScore ? entry.severity : existing.severity;
+    return {
+        ...existing,
+        severity,
+    };
+};
+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 = [];
+    entries.forEach(entry => {
+        const segments = (0, jsonPath_1.parseJsonPath)(entry.path);
+        if (segments[0] !== 'paths' || segments.length < 3) {
+            return;
+        }
+        const rawPath = segments[1];
+        const method = segments[2];
+        const key = buildOperationKey(method, rawPath);
+        if (entry.action === 'removed' && segments.length === 3) {
+            removedOperations.push({
+                key,
+                path: rawPath,
+                method,
+                entry,
+            });
+            return;
+        }
+        operationDiffs.set(key, mergeOperationDiff(operationDiffs.get(key), entry));
+    });
+    return { operationDiffs, removedOperations };
+};
+const createGhostOperation = (match, serviceName) => {
+    const from = (match.entry.from ?? {});
+    const operationId = typeof from.operationId === 'string' ? from.operationId : '';
+    const summary = typeof from.summary === 'string' ? from.summary : '';
+    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,
+        summary: (0, getComment_1.getComment)(summary),
+        description: (0, getComment_1.getComment)(description),
+        deprecated: true,
+        method: match.method.toUpperCase(),
+        path: (0, getOperationPath_1.getOperationPath)(match.path),
+        parameters: pathParameters,
+        parametersPath: pathParameters,
+        parametersQuery: [],
+        parametersForm: [],
+        parametersHeader: [],
+        parametersCookie: [],
+        parametersBody: null,
+        imports: [],
+        errors: [],
+        results: [],
+        responseHeader: null,
+        responseType: null,
+        diff: {
+            action: 'removed',
+            path: match.entry.path,
+            severity: match.entry.severity,
+            from: match.entry.from,
+            to: match.entry.to,
+        },
+        isGhost: true,
+    };
+};
+const resolveServiceFromMatch = (services, match) => {
+    const from = (match.entry.from ?? {});
+    const tagsValue = from.tags;
+    const tag = Array.isArray(tagsValue) ? String(tagsValue[0] ?? '') : '';
+    const preferredName = tag ? (0, getServiceClassName_1.getServiceClassName)(tag) : (0, getServiceClassName_1.getServiceClassName)('Default');
+    const preferredOrigin = tag ? (0, getClassName_1.getClassName)(tag) : (0, getClassName_1.getClassName)('Default');
+    const existingByName = services.get(preferredName);
+    if (existingByName) {
+        return existingByName;
+    }
+    const existingByOrigin = Array.from(services.values()).find(service => service.originName === preferredOrigin);
+    if (existingByOrigin) {
+        return existingByOrigin;
+    }
+    return (0, serviceHelpers_1.ensureService)(services, preferredName, preferredOrigin);
+};
+const applyOperationDiffs = (client, entries) => {
+    const { operationDiffs, removedOperations } = findOperationMatches(entries);
+    const servicesMap = new Map(client.services.map(service => [service.name, service]));
+    for (const service of servicesMap.values()) {
+        for (const operation of service.operations) {
+            const key = buildOperationKey(operation.method, operation.path);
+            const diff = operationDiffs.get(key);
+            if (diff) {
+                operation.diff = diff;
+            }
+        }
+    }
+    for (const match of removedOperations) {
+        const service = resolveServiceFromMatch(servicesMap, match);
+        const ghostOperation = createGhostOperation(match, service.name);
+        const existingOperation = service.operations.find(op => buildOperationKey(op.method, op.path) === match.key);
+        if (!existingOperation) {
+            service.operations.push(ghostOperation);
+        }
+    }
+    client.services = Array.from(servicesMap.values());
+};
+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 models = getModelsForSchema(schemaName, schemaNameMap, modelsByName);
+        if (models.length === 0)
+            return;
+        const propertiesIndex = segments.indexOf('properties');
+        if (propertiesIndex === -1 || propertiesIndex + 1 >= segments.length) {
+            return;
+        }
+        const rawPropertyName = segments[propertiesIndex + 1];
+        const propertyName = (0, escapeName_1.escapeName)(rawPropertyName);
+        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);
+                }
+                continue;
+            }
+            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;
+                }
+            }
+        }
+    });
+};
+const applyMiracleTypeCoercions = (client, confirmedMiracles, entries) => {
+    if (!confirmedMiracles.length)
+        return;
+    const modelsByName = buildModelsByName(client.models);
+    for (const miracle of confirmedMiracles) {
+        if (miracle.type !== 'TYPE_COERCION')
+            continue;
+        if (!miracle.modelName)
+            continue;
+        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);
+        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,
+                    };
+                }
+            }
+        }
+    }
+};
+/**
+ * Применяет структурный 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, context);
+    const confirmedMiracles = (diffReport?.miracles ?? [])
+        .filter(miracle => miracle.status === 'confirmed' || miracle.confidence === 1)
+        .map(miracle => {
+        const oldSegments = (0, jsonPath_1.parseJsonPath)(miracle.oldPath);
+        const newSegments = (0, jsonPath_1.parseJsonPath)(miracle.newPath);
+        const oldSchema = getSchemaNameFromSegments(oldSegments, openApiVersion);
+        const newSchema = getSchemaNameFromSegments(newSegments, openApiVersion);
+        const schemaName = oldSchema || newSchema;
+        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;
+        const newProperty = newPropIndex !== -1 ? newSegments[newPropIndex + 1] : undefined;
+        return {
+            ...miracle,
+            modelName,
+            oldProperty,
+            newProperty,
+        };
+    });
+    if (confirmedMiracles.length > 0) {
+        client.miracles = confirmedMiracles;
+    }
+    applyMiracleTypeCoercions(client, confirmedMiracles, entries);
+    if (entries.length === 0) {
+        return client;
+    }
+    applyModelDiffs(client, entries, openApi, openApiVersion, prefix, context);
+    applyOperationDiffs(client, entries);
+    return client;
+};
+exports.applyDiffReportToClient = applyDiffReportToClient;

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

@@ -1,3 +1,3 @@
-import { Model } from "../types/shared/Model.model";
+import { Model } from '../types/shared/Model.model';
 export declare function areEqual(a: Model, b: Model): boolean;
 //# sourceMappingURL=areEqual.d.ts.map