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

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,21 +22,37 @@ 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;
 };
 const getSchemaNameFromSegments = (segments, version) => {
     if (version === getOpenApiVersion_1.OpenApiVersion.V3) {
-        return segments[0] === 'components' && segments[1] === 'schemas' ? segments[2] ?? null : null;
+        return segments[0] === 'components' && segments[1] === 'schemas' ? (segments[2] ?? null) : null;
     }
-    return segments[0] === 'definitions' ? segments[1] ?? null : null;
+    return segments[0] === 'definitions' ? (segments[1] ?? null) : null;
 };
 const describeSchemaType = (value) => {
     if (typeof value === 'string') {
@@ -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/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

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

package/dist/core/utils/buildMiraclesFromSemanticChanges.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSchemaPropertyPointer = parseSchemaPropertyPointer;
+exports.buildMiraclesFromSemanticChanges = buildMiraclesFromSemanticChanges;
+const leven_1 = __importDefault(require("leven"));
+const miracles_1 = require("../../cli/analyzeDiff/miracles");
+const semanticPointerToJsonPath_1 = require("./semanticPointerToJsonPath");
+const SCHEMA_PROPERTY_POINTER_REGEX = /^#\/components\/schemas\/([^/]+)\/properties\/([^/]+)$/;
+/**
+ * Разбирает JSON Pointer свойства схемы в метаданные изменения.
+ * @param path JSON Pointer путь к свойству
+ * @returns метаданные изменения или null, если путь не относится к свойству схемы
+ */
+function parseSchemaPropertyPointer(path) {
+    const match = path.match(SCHEMA_PROPERTY_POINTER_REGEX);
+    if (!match) {
+        return null;
+    }
+    const schemaName = match[1];
+    const propertyName = match[2];
+    return {
+        schemaPath: `components.schemas.${schemaName}`,
+        schemaName,
+        propertyName,
+        jsonPath: (0, semanticPointerToJsonPath_1.semanticPointerToJsonPath)(path),
+    };
+}
+const toPayload = (value) => {
+    if (value && typeof value === 'object') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return { type: value };
+    }
+    return {};
+};
+const extractSemanticPropertyChange = (change, action) => {
+    const parsed = parseSchemaPropertyPointer(change.path);
+    if (!parsed) {
+        return null;
+    }
+    const payload = toPayload(action === 'removed' ? change.from : change.to);
+    const typeSignature = (0, miracles_1.getTypeSignature)(payload) ?? (typeof change.from === 'string' ? change.from : typeof change.to === 'string' ? change.to : undefined);
+    return {
+        ...parsed,
+        payload,
+        typeSignature,
+    };
+};
+const isSimilarityCandidate = (removed, added) => {
+    if (removed.schemaPath !== added.schemaPath) {
+        return false;
+    }
+    if (removed.typeSignature && added.typeSignature) {
+        return removed.typeSignature === added.typeSignature;
+    }
+    return true;
+};
+/**
+ * Строит miracles типов RENAME и TYPE_COERCION из семантических изменений.
+ * @param changes список семантических изменений
+ * @returns список miracles
+ */
+function buildMiraclesFromSemanticChanges(changes) {
+    const removedProps = [];
+    const addedProps = [];
+    const miracles = [];
+    for (const change of changes) {
+        if (change.type === 'model.property.removed') {
+            const removed = extractSemanticPropertyChange(change, 'removed');
+            if (removed) {
+                removedProps.push(removed);
+            }
+            continue;
+        }
+        if (change.type === 'model.property.added') {
+            const added = extractSemanticPropertyChange(change, 'added');
+            if (added) {
+                addedProps.push(added);
+            }
+            continue;
+        }
+        if (change.type !== 'model.property.type.changed') {
+            continue;
+        }
+        const parsed = parseSchemaPropertyPointer(change.path);
+        if (!parsed) {
+            continue;
+        }
+        const fromType = (0, miracles_1.normalizeScalarType)(typeof change.from === 'string' ? change.from : undefined);
+        const toType = (0, miracles_1.normalizeScalarType)(typeof change.to === 'string' ? change.to : undefined);
+        if (!fromType || !toType || fromType === toType) {
+            continue;
+        }
+        miracles.push({
+            oldPath: parsed.jsonPath,
+            newPath: parsed.jsonPath,
+            type: 'TYPE_COERCION',
+            confidence: 1,
+            status: 'auto-generated',
+        });
+    }
+    for (const removed of removedProps) {
+        const candidates = addedProps.filter(added => isSimilarityCandidate(removed, added));
+        if (candidates.length === 0) {
+            continue;
+        }
+        const removedName = (0, miracles_1.normalizeName)(removed.propertyName);
+        if (!removedName) {
+            continue;
+        }
+        let best = null;
+        for (const candidate of candidates) {
+            const addedName = (0, miracles_1.normalizeName)(candidate.propertyName);
+            if (!addedName) {
+                continue;
+            }
+            const distance = (0, leven_1.default)(removedName, addedName);
+            const ratio = distance / Math.max(removedName.length, addedName.length);
+            if (!best || ratio < best.ratio) {
+                best = { candidate, ratio };
+            }
+        }
+        if (!best || best.ratio > 0.2) {
+            continue;
+        }
+        const sameType = !!removed.typeSignature && !!best.candidate.typeSignature && removed.typeSignature === best.candidate.typeSignature;
+        const onlyCandidate = candidates.length === 1;
+        const descBonus = (0, miracles_1.descriptionSimilarityBonus)(removed.description, best.candidate.description);
+        const confidence = (0, miracles_1.computeConfidence)(best.ratio, sameType, onlyCandidate, descBonus);
+        miracles.push({
+            oldPath: removed.jsonPath,
+            newPath: best.candidate.jsonPath,
+            type: 'RENAME',
+            confidence,
+            status: 'auto-generated',
+            modelName: removed.schemaName,
+            oldProperty: removed.propertyName,
+            newProperty: best.candidate.propertyName,
+        });
+    }
+    return miracles;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Резолвер ссылок для семантического diff.
+ * @property [exists] проверка существования ссылки
+ * @property get получение значения по ссылке
+ */
+export type SemanticRefResolver = {
+    exists?: (ref: string) => boolean;
+    get: (ref: string) => unknown;
+};
+type ExpandOptions = {
+    refs?: SemanticRefResolver;
+    sourceFile?: string;
+};
+/**
+ * Строит клон спецификации с развёрнутыми refs для семантического сравнения.
+ * Циклы и неразрешённые refs остаются стабильными `$ref`-объектами.
+ * @param root корневой узел OpenAPI-документа
+ * @param [options] опции резолва ссылок
+ * @returns клон с развёрнутыми refs
+ */
+export declare function expandOpenApiRefsForSemanticDiff<T = unknown>(root: T, options?: ExpandOptions): T;
+export {};
+//# sourceMappingURL=expandOpenApiRefsForSemanticDiff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expandOpenApiRefsForSemanticDiff.d.ts","sourceRoot":"","sources":["../../../src/core/utils/expandOpenApiRefsForSemanticDiff.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACjC,CAAC;AAaF,KAAK,aAAa,GAAG;IACjB,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAmLF;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,CAAC,CAGrG"}