ts-openapi-codegen 2.0.0-beta.11 → 2.0.0-beta.13

package/dist/cli/index.js

@@ -77,7 +77,7 @@ program
     await updateNotifier.checkAndNotify();
 })
     .action(async (options) => {
-    await (0, checkConfig_1.checkConfig)(options.openapiConfig);
+    await (0, checkConfig_1.checkConfig)(options);
 });
 /**
  * update - Команда для обновления конфигурационного файла
@@ -129,8 +129,7 @@ program
     await (0, previewChanges_1.previewChanges)(options);
 });
 program.exitOverride();
-// TODO: Включить позже!
-// program.showSuggestionAfterError(false);
+program.showSuggestionAfterError(false);
 // Парсирование аргументов с обработкой ошибок
 try {
     program.parse(process.argv);

package/dist/cli/previewChanges/previewChanges.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"previewChanges.d.ts","sourceRoot":"","sources":["../../../src/cli/previewChanges/previewChanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AA4BzC;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAiJzE"}
+{"version":3,"file":"previewChanges.d.ts","sourceRoot":"","sources":["../../../src/cli/previewChanges/previewChanges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAmHzC;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAoLzE"}

package/dist/cli/previewChanges/previewChanges.js

@@ -51,36 +51,100 @@ const formatDiff_1 = require("./utils/formatDiff");
 const isDirectoryEmpty_1 = require("./utils/isDirectoryEmpty");
 const readDirectoryRecursive_1 = require("./utils/readDirectoryRecursive");
 const updateOutputPaths_1 = require("./utils/updateOutputPaths");
+function buildSummary(changes) {
+    const added = [];
+    const removed = [];
+    const modified = [];
+    for (const change of changes) {
+        if (change.status === 'added') {
+            added.push(change.file);
+            continue;
+        }
+        if (change.status === 'removed') {
+            removed.push(change.file);
+            continue;
+        }
+        modified.push(change.file);
+    }
+    added.sort();
+    removed.sort();
+    modified.sort();
+    return {
+        added,
+        removed,
+        modified,
+        total: changes.length,
+    };
+}
+function toFileLink(filePath) {
+    return `./${filePath}.md`;
+}
+function toCategoryMarkdown(title, files) {
+    const lines = [`# ${title}`, ''];
+    if (files.length === 0) {
+        lines.push('_No files_', '');
+        return lines.join('\n');
+    }
+    for (const file of files) {
+        lines.push(`- [${file}](${toFileLink(file)})`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function toSummaryMarkdown(summary) {
+    return [
+        '# Preview Changes Summary',
+        '',
+        `Total changes: ${summary.total}`,
+        `Added files: ${summary.added.length}`,
+        `Removed files: ${summary.removed.length}`,
+        `Modified files: ${summary.modified.length}`,
+        '',
+        '## Reports',
+        '- [Added files](./added-files.md)',
+        '- [Removed files](./removed-files.md)',
+        '- [Modified files](./modified-files.md)',
+        '',
+        '## Added',
+        ...summary.added.map(file => `- [${file}](${toFileLink(file)})`),
+        '',
+        '## Removed',
+        ...summary.removed.map(file => `- [${file}](${toFileLink(file)})`),
+        '',
+        '## Modified',
+        ...summary.modified.map(file => `- [${file}](${toFileLink(file)})`),
+        '',
+    ].join('\n');
+}
 /**
  * Основная функция для предпросмотра изменений
  *
  * TODO: Добавить проверку опций команды перед выполнением
  */
 async function previewChanges(options) {
-    const validationResult = (0, validateZodOptions_1.validateZodOptions)(schemas_1.previewChangesSchema, options);
-    if (!validationResult.success) {
-        Consts_1.APP_LOGGER.error(validationResult.errors.join('\n'));
-        process.exit(1);
-    }
-    const { openapiConfig, generatedDir, previewDir, diffDir } = validationResult.data;
-    const resolvedGeneratedDir = (0, pathHelpers_1.resolveHelper)(process.cwd(), generatedDir || '');
-    const resolvedPreviewDir = (0, pathHelpers_1.resolveHelper)(process.cwd(), previewDir || '');
-    const resolvedDiffDir = (0, pathHelpers_1.resolveHelper)(process.cwd(), diffDir || '');
+    let exitCode = 0;
+    let resolvedPreviewDir = '';
     let previewDirCreated = false;
     try {
+        const validationResult = (0, validateZodOptions_1.validateZodOptions)(schemas_1.previewChangesSchema, options);
+        if (!validationResult.success) {
+            Consts_1.APP_LOGGER.error(validationResult.errors.join('\n'));
+            exitCode = 1;
+            return;
+        }
+        const { openapiConfig, generatedDir, previewDir, diffDir } = validationResult.data;
+        const resolvedGeneratedDir = (0, pathHelpers_1.resolveHelper)(process.cwd(), generatedDir || '');
+        resolvedPreviewDir = (0, pathHelpers_1.resolveHelper)(process.cwd(), previewDir || '');
+        const resolvedDiffDir = (0, pathHelpers_1.resolveHelper)(process.cwd(), diffDir || '');
         // 1. Проверка директории со сгенерированным кодом
         if (await (0, isDirectoryEmpty_1.isDirectoryEmpty)(resolvedGeneratedDir)) {
             Consts_1.APP_LOGGER.info(`Directory "${generatedDir}" is empty or does not exist. Nothing to compare.`);
-            process.exit(0);
+            return;
         }
-        // 2. Создание временной директории для preview
-        await fileSystemHelpers_1.fileSystemHelpers.mkdir(resolvedPreviewDir);
-        previewDirCreated = true;
-        // 3. Загрузка конфигурации
+        // 2. Загрузка конфигурации
         const configData = (0, loadConfigIfExists_1.loadConfigIfExists)(openapiConfig);
         if (!configData) {
-            Consts_1.APP_LOGGER.error('The configuration file is missing');
-            process.exit(1);
+            throw new Error('The configuration file is missing');
         }
         const preparedOptions = (0, convertArrayToObject_1.convertArrayToObject)(configData);
         // Миграция опций
@@ -91,9 +155,12 @@ async function previewChanges(options) {
             migrationMode: Enums_1.EMigrationMode.GENERATE_OPENAPI,
         });
         if (!migratedOptions) {
-            Consts_1.APP_LOGGER.error("Couldn't convert the set of options to the current version");
-            process.exit(1);
+            throw new Error("Couldn't convert the set of options to the current version");
         }
+        // 3. Подготовка и создание временной директории preview
+        await fileSystemHelpers_1.fileSystemHelpers.rmdir(resolvedPreviewDir);
+        await fileSystemHelpers_1.fileSystemHelpers.mkdir(resolvedPreviewDir);
+        previewDirCreated = true;
         // 4. Обновление путей output для генерации в preview директорию
         const migratedValue = migratedOptions.value;
         const previewOptions = (0, updateOutputPaths_1.updateOutputPaths)(migratedValue, previewDir || '', generatedDir || '');
@@ -104,13 +171,15 @@ async function previewChanges(options) {
         Consts_1.APP_LOGGER.info('Comparing files...');
         const oldFiles = await (0, readDirectoryRecursive_1.readDirectoryRecursive)(resolvedGeneratedDir);
         const newFiles = await (0, readDirectoryRecursive_1.readDirectoryRecursive)(resolvedPreviewDir);
-        const allFiles = new Set([...oldFiles, ...newFiles]);
+        const oldFileSet = new Set(oldFiles);
+        const newFileSet = new Set(newFiles);
+        const allFiles = new Set([...oldFileSet, ...newFileSet]);
         const changes = [];
-        for (const file of allFiles) {
+        for (const file of [...allFiles].sort()) {
             const oldPath = (0, pathHelpers_1.joinHelper)(resolvedGeneratedDir, file);
             const newPath = (0, pathHelpers_1.joinHelper)(resolvedPreviewDir, file);
-            const oldExists = await fileSystemHelpers_1.fileSystemHelpers.exists(oldPath);
-            const newExists = await fileSystemHelpers_1.fileSystemHelpers.exists(newPath);
+            const oldExists = oldFileSet.has(file);
+            const newExists = newFileSet.has(file);
             if (oldExists && newExists) {
                 // Файл существует в обеих директориях - сравниваем
                 const fileDiff = await (0, compareFiles_1.compareFiles)(oldPath, newPath);
@@ -142,6 +211,7 @@ async function previewChanges(options) {
         }
         // 7. Сохранение результатов в diff директорию
         if (changes.length > 0) {
+            await fileSystemHelpers_1.fileSystemHelpers.rmdir(resolvedDiffDir);
             await fileSystemHelpers_1.fileSystemHelpers.mkdir(resolvedDiffDir);
             for (const change of changes) {
                 const diffFilePath = (0, pathHelpers_1.joinHelper)(resolvedDiffDir, `${change.file}.md`);
@@ -160,30 +230,40 @@ async function previewChanges(options) {
                 await fileSystemHelpers_1.fileSystemHelpers.writeFile(diffFilePath, diffContent, 'utf-8');
                 Consts_1.APP_LOGGER.info(`Diff saved: ${diffFilePath}`);
             }
+            const summary = buildSummary(changes);
+            await fileSystemHelpers_1.fileSystemHelpers.writeFile((0, pathHelpers_1.joinHelper)(resolvedDiffDir, 'added-files.md'), toCategoryMarkdown('Added Files', summary.added), 'utf-8');
+            await fileSystemHelpers_1.fileSystemHelpers.writeFile((0, pathHelpers_1.joinHelper)(resolvedDiffDir, 'removed-files.md'), toCategoryMarkdown('Removed Files', summary.removed), 'utf-8');
+            await fileSystemHelpers_1.fileSystemHelpers.writeFile((0, pathHelpers_1.joinHelper)(resolvedDiffDir, 'modified-files.md'), toCategoryMarkdown('Modified Files', summary.modified), 'utf-8');
+            await fileSystemHelpers_1.fileSystemHelpers.writeFile((0, pathHelpers_1.joinHelper)(resolvedDiffDir, 'summary.json'), JSON.stringify(summary, null, 2), 'utf-8');
+            await fileSystemHelpers_1.fileSystemHelpers.writeFile((0, pathHelpers_1.joinHelper)(resolvedDiffDir, 'summary.md'), toSummaryMarkdown(summary), 'utf-8');
             Consts_1.APP_LOGGER.info(`\nTotal changes: ${changes.length}`);
             Consts_1.APP_LOGGER.info(`Diff files saved to: ${diffDir}`);
         }
         else {
+            await fileSystemHelpers_1.fileSystemHelpers.rmdir(resolvedDiffDir);
             Consts_1.APP_LOGGER.info('No changes detected. All files are identical.');
         }
-        // 8. Удаление временной директории preview
-        Consts_1.APP_LOGGER.info(`Cleaning up preview directory: ${previewDir}`);
-        await fileSystemHelpers_1.fileSystemHelpers.rmdir(resolvedPreviewDir);
-        previewDirCreated = false;
-        process.exit(0);
     }
     catch (error) {
-        // Очистка preview директории в случае ошибки
-        if (previewDirCreated) {
+        exitCode = 1;
+        Consts_1.APP_LOGGER.error(error.message);
+    }
+    finally {
+        if (previewDirCreated || resolvedPreviewDir) {
             try {
-                Consts_1.APP_LOGGER.info(`Cleaning up preview directory after error: ${previewDir}`);
-                await fileSystemHelpers_1.fileSystemHelpers.rmdir(resolvedPreviewDir);
+                if (resolvedPreviewDir) {
+                    Consts_1.APP_LOGGER.info(`Cleaning up preview directory: ${resolvedPreviewDir}`);
+                    await fileSystemHelpers_1.fileSystemHelpers.rmdir(resolvedPreviewDir);
+                }
             }
             catch (cleanupError) {
                 Consts_1.APP_LOGGER.error(`Failed to cleanup preview directory: ${cleanupError.message}`);
+                exitCode = 1;
             }
         }
-        Consts_1.APP_LOGGER.error(error.message);
+    }
+    if (exitCode !== 0) {
         process.exit(1);
     }
+    process.exit(0);
 }

package/dist/cli/previewChanges/utils/updateOutputPaths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateOutputPaths.d.ts","sourceRoot":"","sources":["../../../../src/cli/previewChanges/utils/updateOutputPaths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG1D;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC7B,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACrB,WAAW,CAuIb"}
+{"version":3,"file":"updateOutputPaths.d.ts","sourceRoot":"","sources":["../../../../src/cli/previewChanges/utils/updateOutputPaths.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG1D;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC7B,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACrB,WAAW,CA6Ib"}

package/dist/cli/previewChanges/utils/updateOutputPaths.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateOutputPaths = updateOutputPaths;
+const path_1 = require("path");
 const pathHelpers_1 = require("../../../common/utils/pathHelpers");
 /**
  * Обновляет пути output в опциях для генерации в preview директорию
@@ -23,6 +24,11 @@ function updateOutputPaths(options, previewDir, generatedDir) {
         if (relativePath.startsWith('./')) {
             relativePath = relativePath.substring(2);
         }
+        // Если путь выходит за пределы generatedDir, используем basename для безопасного переноса
+        if (relativePath.startsWith('../')) {
+            const outputBaseName = (0, path_1.basename)(resolvedOldPath);
+            return (0, pathHelpers_1.joinHelper)(previewDir, outputBaseName);
+        }
         // Если путь пустой или равен текущей директории, возвращаем previewDir
         if (!relativePath || relativePath === '' || relativePath === './') {
             return previewDir;

package/dist/common/VersionedSchema/AllVersionedSchemas/AllMigrationPlans.d.ts

@@ -1,7 +1,7 @@
 import { SchemaMigrationPlan } from '../Types';
 /**
  * Unified migration plan that includes all migrations from all schema types.
- * Migrates from any old version to the latest UNIFIED_v1 schema.
+ * Migrates from any old version to the latest UNIFIED_OPTIONS_v1 schema.
  * Reuses existing migration plans to avoid code duplication.
  */
 export declare const allMigrationPlans: SchemaMigrationPlan<Record<string, any>, Record<string, any>>[];

package/dist/common/VersionedSchema/AllVersionedSchemas/AllMigrationPlans.js

@@ -22,26 +22,26 @@ function addVersionPrefixToMigrationPlans(plans, prefix) {
 }
 /**
  * Unified migration plan that includes all migrations from all schema types.
- * Migrates from any old version to the latest UNIFIED_v1 schema.
+ * Migrates from any old version to the latest UNIFIED_OPTIONS_v1 schema.
  * Reuses existing migration plans to avoid code duplication.
  */
 exports.allMigrationPlans = [
     // ===== OPTIONS migrations (with prefix) =====
     ...addVersionPrefixToMigrationPlans(OptionsMigrationPlans_1.optionsMigrationPlans, 'OPTIONS'),
     // Migration from OPTIONS latest version to UNIFIED v1
-    (0, createTrivialMigration_1.createTrivialMigration)(`OPTIONS_${(0, getLatestVersionFromMigrationPlans_1.getLatestVersionFromMigrationPlans)(OptionsMigrationPlans_1.optionsMigrationPlans)}`, 'UNIFIED_v1', 'Migrate from OPTIONS to UNIFIED schema'),
+    (0, createTrivialMigration_1.createTrivialMigration)(`OPTIONS_${(0, getLatestVersionFromMigrationPlans_1.getLatestVersionFromMigrationPlans)(OptionsMigrationPlans_1.optionsMigrationPlans)}`, 'UNIFIED_OPTIONS_v1', 'Migrate from OPTIONS to UNIFIED schema'),
     // ===== MULTI_OPTIONS migrations (with prefix) =====
     ...addVersionPrefixToMigrationPlans(MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan, 'MULTI_OPTIONS'),
     // Migration from MULTI_OPTIONS latest version to UNIFIED v1
-    (0, createTrivialMigration_1.createTrivialMigration)(`MULTI_OPTIONS_${(0, getLatestVersionFromMigrationPlans_1.getLatestVersionFromMigrationPlans)(MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan)}`, 'UNIFIED_v1', 'Migrate from MULTI_OPTIONS to UNIFIED schema'),
-    (0, createFieldTransformationMigration_1.createFieldTransformationMigration)('UNIFIED_v1', 'UNIFIED_v2', ({ includeSchemasFiles, ...otherProps }) => {
+    (0, createTrivialMigration_1.createTrivialMigration)(`MULTI_OPTIONS_${(0, getLatestVersionFromMigrationPlans_1.getLatestVersionFromMigrationPlans)(MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan)}`, 'UNIFIED_OPTIONS_v1', 'Migrate from MULTI_OPTIONS to UNIFIED schema'),
+    (0, createFieldTransformationMigration_1.createFieldTransformationMigration)('UNIFIED_OPTIONS_v1', 'UNIFIED_OPTIONS_v2', ({ includeSchemasFiles, ...otherProps }) => {
         return { ...otherProps, validationLibrary: !includeSchemasFiles ? ValidationLibrary_enum_1.ValidationLibrary.NONE : undefined };
     }, 'Transforms includeSchemasFiles to validationLibrary: if includeSchemasFiles is false, sets validationLibrary to NONE'),
-    (0, createDefaultFieldsMigration_1.createDefaultFieldsMigration)('UNIFIED_v2', 'UNIFIED_v3', {
+    (0, createDefaultFieldsMigration_1.createDefaultFieldsMigration)('UNIFIED_OPTIONS_v2', 'UNIFIED_OPTIONS_v3', {
         logLevel: Enums_1.ELogLevel.ERROR,
         logTarget: Enums_1.ELogOutput.CONSOLE
     }),
-    (0, createDefaultFieldsMigration_1.createDefaultFieldsMigration)('UNIFIED_v3', 'UNIFIED_v4', {
+    (0, createDefaultFieldsMigration_1.createDefaultFieldsMigration)('UNIFIED_OPTIONS_v3', 'UNIFIED_OPTIONS_v4', {
         emptySchemaStrategy: EmptySchemaStrategy_enum_1.EmptySchemaStrategy.KEEP
     })
 ];

package/dist/common/VersionedSchema/Utils/__mocks__/compatibilityCases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compatibilityCases.d.ts","sourceRoot":"","sources":["../../../../../src/common/VersionedSchema/Utils/__mocks__/compatibilityCases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAChC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,EAiFjD,CAAC"}
+{"version":3,"file":"compatibilityCases.d.ts","sourceRoot":"","sources":["../../../../../src/common/VersionedSchema/Utils/__mocks__/compatibilityCases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,KAAK,iBAAiB,GAAG;IACrB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,kBAAkB,EAAE,CAAC;CAChC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,EA8FjD,CAAC"}

package/dist/common/VersionedSchema/Utils/__mocks__/compatibilityCases.js

@@ -54,6 +54,19 @@ exports.compatibilityCases = [
         to: 'v3',
         expect: [{ type: 'added', key: 'useCancelableRequest' }],
     },
+    {
+        type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+        from: 'v3',
+        to: 'v4',
+        expect: [
+            { type: 'removed', key: 'output' },
+            { type: 'removed', key: 'outputCore' },
+            { type: 'removed', key: 'outputServices' },
+            { type: 'removed', key: 'outputModels' },
+            { type: 'removed', key: 'outputSchemas' },
+            { type: 'removed', key: 'input' },
+        ],
+    },
     {
         type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
         from: 'v4',

package/dist/common/VersionedSchema/Utils/__tests__/allUtils.test.d.ts

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

package/dist/common/VersionedSchema/Utils/__tests__/allUtils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allUtils.test.d.ts","sourceRoot":"","sources":["../../../../../src/common/VersionedSchema/Utils/__tests__/allUtils.test.ts"],"names":[],"mappings":""}

package/dist/common/VersionedSchema/Utils/__tests__/allUtils.test.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable simple-import-sort/imports */
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const zod_1 = require("zod");
+const Enums_1 = require("../../Enums");
+const buildVersionedSchema_1 = require("../buildVersionedSchema");
+const createDefaultFieldsMigration_1 = require("../createDefaultFieldsMigration");
+const createFieldTransformationMigration_1 = require("../createFieldTransformationMigration");
+const createTrivialMigration_1 = require("../createTrivialMigration");
+const determineBestMatchingSchemaVersion_1 = require("../determineBestMatchingSchemaVersion");
+const generateKeyMappingForInvalidKeys_1 = require("../generateKeyMappingForInvalidKeys");
+const getCurrentErrorMessage_1 = require("../getCurrentErrorMessage");
+const getKeyByMapValue_1 = require("../getKeyByMapValue");
+const getLatestVersionFromMigrationPlans_1 = require("../getLatestVersionFromMigrationPlans");
+const getUniqueKeysFromSchemas_1 = require("../getUniqueKeysFromSchemas");
+const getUniqueObjectKeys_1 = require("../getUniqueObjectKeys");
+const replaceInvalidKeysWithMappedNames_1 = require("../replaceInvalidKeysWithMappedNames");
+const validateAndSuggestKeyCorrections_1 = require("../validateAndSuggestKeyCorrections");
+(0, node_test_1.describe)('@unit: buildVersionedSchema', () => {
+    (0, node_test_1.test)('builds schema metadata without refine', () => {
+        const base = zod_1.z.object({ input: zod_1.z.string() });
+        const result = (0, buildVersionedSchema_1.buildVersionedSchema)({
+            base,
+            version: 'v1',
+            type: Enums_1.EVersionedSchemaType.OPTIONS,
+        });
+        node_assert_1.default.strictEqual(result.baseSchema, base);
+        node_assert_1.default.strictEqual(result.version, 'v1');
+        node_assert_1.default.strictEqual(result.type, Enums_1.EVersionedSchemaType.OPTIONS);
+        node_assert_1.default.deepStrictEqual(result.schema.parse({ input: 'ok' }), { input: 'ok' });
+    });
+    (0, node_test_1.test)('applies refine when provided', () => {
+        const base = zod_1.z.object({ input: zod_1.z.string(), output: zod_1.z.string() });
+        const schema = (0, buildVersionedSchema_1.buildVersionedSchema)({
+            base,
+            version: 'v2',
+            type: Enums_1.EVersionedSchemaType.OPTIONS,
+            refine: (data, ctx) => {
+                if (data.input === data.output) {
+                    ctx.addIssue({
+                        code: 'custom',
+                        message: 'input and output must be different',
+                        path: ['output'],
+                    });
+                }
+            },
+        }).schema;
+        const result = schema.safeParse({ input: 'same', output: 'same' });
+        node_assert_1.default.strictEqual(result.success, false);
+    });
+});
+(0, node_test_1.describe)('@unit: migration plan helpers', () => {
+    (0, node_test_1.test)('createDefaultFieldsMigration merges default values', () => {
+        const plan = (0, createDefaultFieldsMigration_1.createDefaultFieldsMigration)('v1', 'v2', { enabled: true });
+        node_assert_1.default.strictEqual(plan.fromVersion, 'v1');
+        node_assert_1.default.strictEqual(plan.toVersion, 'v2');
+        node_assert_1.default.deepStrictEqual(plan.migrate({ name: 'demo' }), { name: 'demo', enabled: true });
+        node_assert_1.default.match(plan.description ?? '', /enabled/);
+    });
+    (0, node_test_1.test)('createFieldTransformationMigration keeps custom migrate and custom description', () => {
+        const plan = (0, createFieldTransformationMigration_1.createFieldTransformationMigration)('v1', 'v2', ({ oldField, ...rest }) => ({ ...rest, newField: oldField }), 'rename oldField');
+        node_assert_1.default.strictEqual(plan.fromVersion, 'v1');
+        node_assert_1.default.strictEqual(plan.toVersion, 'v2');
+        node_assert_1.default.strictEqual(plan.description, 'rename oldField');
+        node_assert_1.default.deepStrictEqual(plan.migrate({ oldField: 'x', other: 1 }), { other: 1, newField: 'x' });
+    });
+    (0, node_test_1.test)('createTrivialMigration copies object as-is', () => {
+        const plan = (0, createTrivialMigration_1.createTrivialMigration)('v3', 'v4');
+        const source = { a: 1 };
+        const migrated = plan.migrate(source);
+        node_assert_1.default.deepStrictEqual(migrated, source);
+        node_assert_1.default.notStrictEqual(migrated, source);
+        node_assert_1.default.match(plan.description ?? '', /Trivial migration/);
+    });
+});
+(0, node_test_1.describe)('@unit: determineBestMatchingSchemaVersion', () => {
+    const mk = (schema, version) => ({
+        schema,
+        baseSchema: zod_1.z.object({}),
+        version,
+        type: Enums_1.EVersionedSchemaType.OPTIONS,
+    });
+    (0, node_test_1.test)('throws on empty schema list', () => {
+        node_assert_1.default.throws(() => (0, determineBestMatchingSchemaVersion_1.determineBestMatchingSchemaVersion)({}, []), /cannot be empty/i);
+    });
+    (0, node_test_1.test)('returns latest from multiple valid matches', () => {
+        const versionedSchemas = [
+            mk(zod_1.z.object({ a: zod_1.z.string() }), 'v1'),
+            mk(zod_1.z.object({ a: zod_1.z.string(), b: zod_1.z.string().optional() }), 'v2'),
+        ];
+        const result = (0, determineBestMatchingSchemaVersion_1.determineBestMatchingSchemaVersion)({ a: 'ok' }, versionedSchemas);
+        node_assert_1.default.deepStrictEqual(result, {
+            lastVersionIndex: 1,
+            latestVersion: 'v2',
+            firstVersion: 'v1',
+        });
+    });
+    (0, node_test_1.test)('falls back to the best key/error balance when no full match', () => {
+        const versionedSchemas = [
+            mk(zod_1.z.object({ a: zod_1.z.string() }), 'v1'),
+            mk(zod_1.z.object({ b: zod_1.z.string() }), 'v2'),
+        ];
+        const result = (0, determineBestMatchingSchemaVersion_1.determineBestMatchingSchemaVersion)({ a: 1 }, versionedSchemas);
+        node_assert_1.default.deepStrictEqual(result, {
+            lastVersionIndex: 0,
+            latestVersion: 'v1',
+            firstVersion: 'v1',
+        });
+    });
+});
+(0, node_test_1.describe)('@unit: key mapping and validation helpers', () => {
+    (0, node_test_1.test)('generateKeyMappingForInvalidKeys maps close invalid keys', () => {
+        const mapping = (0, generateKeyMappingForInvalidKeys_1.generateKeyMappingForInvalidKeys)(['nmae', 'title', 'unknown'], new Set(['name', 'title']));
+        node_assert_1.default.deepStrictEqual(Array.from(mapping.entries()), [['nmae', 'name']]);
+    });
+    (0, node_test_1.test)('validateAndSuggestKeyCorrections throws with suggestion', () => {
+        node_assert_1.default.throws(() => (0, validateAndSuggestKeyCorrections_1.validateAndSuggestKeyCorrections)(['nmae'], new Set(['name'])), /Perhaps you meant "name"/);
+    });
+    (0, node_test_1.test)('validateAndSuggestKeyCorrections does not throw for valid keys', () => {
+        node_assert_1.default.doesNotThrow(() => (0, validateAndSuggestKeyCorrections_1.validateAndSuggestKeyCorrections)(['name'], new Set(['name'])));
+    });
+});
+(0, node_test_1.describe)('@unit: getCurrentErrorMessage and getKeyByMapValue', () => {
+    (0, node_test_1.test)('getKeyByMapValue finds key by value', () => {
+        const key = (0, getKeyByMapValue_1.getKeyByMapValue)(new Map([['nmae', '--name']]), '--name');
+        node_assert_1.default.strictEqual(key, 'nmae');
+    });
+    (0, node_test_1.test)('getCurrentErrorMessage does nothing when no issues', () => {
+        node_assert_1.default.doesNotThrow(() => {
+            (0, getCurrentErrorMessage_1.getCurrentErrorMessage)({ issues: [], message: '' }, new Map());
+        });
+    });
+    (0, node_test_1.test)('getCurrentErrorMessage throws deduplicated transformed message', () => {
+        const error = {
+            message: '--name is invalid',
+            issues: [
+                { path: ['name'], message: 'wrong value' },
+                { path: ['name'], message: 'wrong value' },
+            ],
+        };
+        node_assert_1.default.throws(() => (0, getCurrentErrorMessage_1.getCurrentErrorMessage)(error, new Map([['nmae', '--name']])), /nmae is invalid/);
+    });
+});
+(0, node_test_1.describe)('@unit: collection helpers', () => {
+    (0, node_test_1.test)('getLatestVersionFromMigrationPlans returns toVersion of last plan', () => {
+        const version = (0, getLatestVersionFromMigrationPlans_1.getLatestVersionFromMigrationPlans)([
+            (0, createTrivialMigration_1.createTrivialMigration)('v1', 'v2'),
+            (0, createTrivialMigration_1.createTrivialMigration)('v2', 'v3'),
+        ]);
+        node_assert_1.default.strictEqual(version, 'v3');
+    });
+    (0, node_test_1.test)('getLatestVersionFromMigrationPlans throws for empty list', () => {
+        node_assert_1.default.throws(() => (0, getLatestVersionFromMigrationPlans_1.getLatestVersionFromMigrationPlans)([]), /empty/i);
+    });
+    (0, node_test_1.test)('getUniqueKeysFromSchemas returns keys from root and nested objects', () => {
+        const keys = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([
+            zod_1.z.object({
+                a: zod_1.z.string(),
+                nested: zod_1.z.object({ inner: zod_1.z.number() }),
+            }),
+            zod_1.z.object({ b: zod_1.z.boolean() }),
+        ]);
+        node_assert_1.default.deepStrictEqual(Array.from(keys).sort(), ['a', 'b', 'inner', 'nested']);
+    });
+    (0, node_test_1.test)('getUniqueObjectKeys returns unique keys for nested object and arrays', () => {
+        const keys = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)({
+            a: 1,
+            nested: { b: 2 },
+            items: [{ c: 3 }, { a: 4 }],
+        });
+        node_assert_1.default.deepStrictEqual(keys, ['a', 'nested', 'b', 'items', 'c']);
+    });
+    (0, node_test_1.test)('replaceInvalidKeysWithMappedNames replaces keys recursively for arrays', () => {
+        const replaced = (0, replaceInvalidKeysWithMappedNames_1.replaceInvalidKeysWithMappedNames)([{ nmae: 'a' }, { nmae: 'b', extra: [{ nmae: 'c' }] }], new Map([['nmae', 'name']]));
+        node_assert_1.default.deepStrictEqual(replaced, [
+            { name: 'a' },
+            { name: 'b', extra: [{ name: 'c' }] },
+        ]);
+    });
+});

package/dist/common/VersionedSchema/Utils/__tests__/compareShapes.test.js

@@ -9,14 +9,31 @@ const node_assert_1 = __importDefault(require("node:assert"));
 const compareShapes_1 = require("../compareShapes");
 const AllVersionedSchemas_1 = require("../../../VersionedSchema/AllVersionedSchemas/AllVersionedSchemas");
 const compatibilityCases_1 = require("../__mocks__/compatibilityCases");
+(0, node_test_1.default)('@unit: schema versions compatibility cases must cover all adjacent transitions', () => {
+    const cases = new Set(compatibilityCases_1.compatibilityCases.map(testCase => `${testCase.type}:${testCase.from}->${testCase.to}`));
+    const transitions = new Set();
+    for (let idx = 0; idx < AllVersionedSchemas_1.allVersionedSchemas.length - 1; idx++) {
+        const current = AllVersionedSchemas_1.allVersionedSchemas[idx];
+        const next = AllVersionedSchemas_1.allVersionedSchemas[idx + 1];
+        if (current.type !== next.type) {
+            continue;
+        }
+        const from = current.version.split('_').at(-1);
+        const to = next.version.split('_').at(-1);
+        if (!from || !to) {
+            continue;
+        }
+        transitions.add(`${current.type}:${from}->${to}`);
+    }
+    node_assert_1.default.deepStrictEqual([...cases].sort(), [...transitions].sort(), 'compatibilityCases must include all adjacent schema transitions');
+});
 (0, node_test_1.default)('@unit: schema versions compatibility', () => {
     for (const testCase of compatibilityCases_1.compatibilityCases) {
         const { type, from, to, expect } = testCase;
         const prev = AllVersionedSchemas_1.allVersionedSchemas.find(vs => vs.type === type && vs.version === `${type}_${from}`)?.baseSchema;
         const next = AllVersionedSchemas_1.allVersionedSchemas.find(vs => vs.type === type && vs.version === `${type}_${to}`)?.baseSchema;
-        if (!prev || !next) {
-            return;
-        }
+        node_assert_1.default.ok(prev, `Previous schema was not found for ${type} ${from}`);
+        node_assert_1.default.ok(next, `Next schema was not found for ${type} ${to}`);
         const issues = (0, compareShapes_1.compareShapes)(prev, next);
         node_assert_1.default.deepStrictEqual(issues, expect, `${type} ${from} → ${to} mismatch`);
     }

package/dist/common/VersionedSchema/Utils/__tests__/migrateDataToLatestSchemaVersion.test.js

@@ -73,3 +73,21 @@ const migrateDataToLatestSchemaVersion_1 = require("../migrateDataToLatestSchema
     node_assert_1.default.strictEqual(result?.value.httpClient, 'fetch');
     node_assert_1.default.strictEqual(result?.value.validationLibrary, ValidationLibrary_enum_1.ValidationLibrary.NONE);
 });
+(0, node_test_1.default)('@unit: migrateDataToLatestSchemaVersion (all schemas: chooses old options branch before unified)', () => {
+    const rawInput = {
+        input: './spec.json',
+        output: './dist',
+        httpClient: 'fetch',
+        exportCore: true,
+    };
+    const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+        rawInput,
+        migrationPlans: AllMigrationPlans_1.allMigrationPlans,
+        versionedSchemas: AllVersionedSchemas_1.allVersionedSchemas,
+        migrationMode: Enums_1.EMigrationMode.VALIDATE_CONFIG,
+    });
+    node_assert_1.default.ok(result);
+    node_assert_1.default.strictEqual(result?.schemaType, Enums_2.EVersionedSchemaType.UNIFIED_OPTIONS);
+    node_assert_1.default.strictEqual(result?.schemaVersion, 'UNIFIED_OPTIONS_v4');
+    node_assert_1.default.ok(result?.guessedVersion.latestVersion.startsWith('OPTIONS_'));
+});

package/dist/common/VersionedSchema/Utils/determineBestMatchingSchemaVersion.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
 import { VersionedSchema, VersionMatchResult } from '../Types';
+/**
+ * Determines the best matching schema version for input data.
+ * `invalid_value` issues are intentionally ignored to allow migration from older enum/value variants.
+ */
 export declare function determineBestMatchingSchemaVersion(inputData: Record<string, any>, versionedSchemas: VersionedSchema<z.ZodTypeAny>[]): VersionMatchResult;
 //# sourceMappingURL=determineBestMatchingSchemaVersion.d.ts.map

package/dist/common/VersionedSchema/Utils/determineBestMatchingSchemaVersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"determineBestMatchingSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/determineBestMatchingSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAK/D,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,GAAG,kBAAkB,CA4CxJ"}
+{"version":3,"file":"determineBestMatchingSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/determineBestMatchingSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAiE/D;;;GAGG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,GAAG,kBAAkB,CAgDxJ"}