ts-openapi-codegen 2.0.0-beta.8 → 2.0.0

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compatibilityCases = void 0;
+const Enums_1 = require("../../Enums");
+/**
+ * ВАЖНО!
+ * Для корректной работы механизма миграции версий опций необходимо после добавления
+ * новой схемы обновлять compatibilityCases.
+ */
+exports.compatibilityCases = [
+    {
+        type: Enums_1.EVersionedSchemaType.OPTIONS,
+        from: 'v1',
+        to: 'v2',
+        expect: [
+            { type: 'removed', key: 'client' },
+            { type: 'added', key: 'httpClient' },
+        ],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.OPTIONS,
+        from: 'v2',
+        to: 'v3',
+        expect: [{ type: 'added', key: 'useCancelableRequest' }],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.OPTIONS,
+        from: 'v3',
+        to: 'v4',
+        expect: [
+            { type: 'removed', key: 'exportCore' },
+            { type: 'removed', key: 'exportServices' },
+            { type: 'removed', key: 'exportModels' },
+            { type: 'removed', key: 'exportSchemas' },
+            { type: 'removed', key: 'clean' },
+            { type: 'added', key: 'excludeCoreServiceFiles' },
+            { type: 'added', key: 'includeSchemasFiles' },
+            { type: 'added', key: 'sortByRequired' },
+            { type: 'added', key: 'useSeparatedIndexes' },
+        ],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+        from: 'v1',
+        to: 'v2',
+        expect: [
+            { type: 'removed', key: 'client' },
+            { type: 'added', key: 'httpClient' },
+        ],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+        from: 'v2',
+        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',
+        to: 'v5',
+        expect: [
+            { type: 'removed', key: 'exportCore' },
+            { type: 'removed', key: 'exportServices' },
+            { type: 'removed', key: 'exportModels' },
+            { type: 'removed', key: 'exportSchemas' },
+            { type: 'removed', key: 'clean' },
+            { type: 'added', key: 'excludeCoreServiceFiles' },
+            { type: 'added', key: 'includeSchemasFiles' },
+            { type: 'added', key: 'sortByRequired' },
+            { type: 'added', key: 'useSeparatedIndexes' },
+        ],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
+        from: 'v1',
+        to: 'v2',
+        expect: [{ type: 'added', key: 'validationLibrary' }],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
+        from: 'v2',
+        to: 'v3',
+        expect: [{ type: 'added', key: 'logLevel' }, { type: 'added', key: 'logTarget' }],
+    },
+    {
+        type: Enums_1.EVersionedSchemaType.UNIFIED_OPTIONS,
+        from: 'v3',
+        to: 'v4',
+        expect: [{ type: 'added', key: 'emptySchemaStrategy' }, { type: 'added', key: 'customExecutorPath' }]
+    }
+];

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.d.ts

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

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

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

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

@@ -0,0 +1,40 @@
+"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_test_1 = __importDefault(require("node:test"));
+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;
+        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.d.ts

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

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

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

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

@@ -0,0 +1,93 @@
+"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_test_1 = __importDefault(require("node:test"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const ValidationLibrary_enum_1 = require("../../../../core/types/enums/ValidationLibrary.enum");
+const Enums_1 = require("../../../Enums");
+const AllMigrationPlans_1 = require("../../AllVersionedSchemas/AllMigrationPlans");
+const AllVersionedSchemas_1 = require("../../AllVersionedSchemas/AllVersionedSchemas");
+const Enums_2 = require("../../Enums");
+const MultiOptionsMigrationPlan_1 = require("../../MultiOptionsVersioned/MultiOptionsMigrationPlan");
+const MultiOptionsVersionedSchemas_1 = require("../../MultiOptionsVersioned/MultiOptionsVersionedSchemas");
+const OptionsMigrationPlans_1 = require("../../OptionsVersioned/OptionsMigrationPlans");
+const OptionsVersionedSchemas_1 = require("../../OptionsVersioned/OptionsVersionedSchemas");
+const migrateDataToLatestSchemaVersion_1 = require("../migrateDataToLatestSchemaVersion");
+(0, node_test_1.default)('@unit: migrateDataToLatestSchemaVersion (options → latest options)', () => {
+    const rawInput = {
+        input: './spec.json',
+        output: './dist',
+        httpClient: 'fetch',
+    };
+    const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+        rawInput,
+        migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
+        versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+        migrationMode: Enums_1.EMigrationMode.VALIDATE_CONFIG,
+    });
+    node_assert_1.default.ok(result);
+    node_assert_1.default.strictEqual(result?.schemaType, Enums_2.EVersionedSchemaType.OPTIONS);
+    node_assert_1.default.strictEqual(result?.schemaVersion, 'v4');
+    node_assert_1.default.strictEqual(result?.value.httpClient, 'fetch');
+    node_assert_1.default.strictEqual(result?.value.httpClient, 'fetch');
+});
+(0, node_test_1.default)('@unit: migrateDataToLatestSchemaVersion (multi-options → latest multi-options)', () => {
+    const rawInput = {
+        httpClient: 'fetch',
+        items: [{ input: './spec.json', output: './dist' }],
+    };
+    const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+        rawInput,
+        migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+        versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+        migrationMode: Enums_1.EMigrationMode.VALIDATE_CONFIG,
+    });
+    node_assert_1.default.ok(result);
+    node_assert_1.default.strictEqual(result?.schemaType, Enums_2.EVersionedSchemaType.MULTI_OPTIONS);
+    node_assert_1.default.strictEqual(result?.schemaVersion, 'v5');
+    node_assert_1.default.strictEqual(result?.value.httpClient, 'fetch');
+    const item = result?.value.items?.[0];
+    node_assert_1.default.ok(item);
+    node_assert_1.default.strictEqual(item?.input, './spec.json');
+    node_assert_1.default.strictEqual(item?.output, './dist');
+});
+(0, node_test_1.default)('@unit: migrateDataToLatestSchemaVersion (unified schemas)', () => {
+    const rawInput = {
+        input: './spec.json',
+        output: './dist',
+        httpClient: 'fetch',
+        validationLibrary: ValidationLibrary_enum_1.ValidationLibrary.NONE,
+    };
+    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.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/buildVersionedSchema.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { EVersionedSchemaType } from '../Enums';
+import { VersionedSchema } from '../Types';
+type BuildVersionedSchemaParams<TBase extends z.ZodObject<any>> = {
+    base: TBase;
+    refine?: (data: z.infer<TBase>, ctx: z.RefinementCtx) => void;
+    version: string;
+    type: EVersionedSchemaType;
+};
+export declare function buildVersionedSchema<TBase extends z.ZodObject<any>>(params: BuildVersionedSchemaParams<TBase>): VersionedSchema<z.ZodTypeAny>;
+export {};
+//# sourceMappingURL=buildVersionedSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildVersionedSchema.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/buildVersionedSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,KAAK,0BAA0B,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI;IAC9D,IAAI,EAAE,KAAK,CAAC;IACZ,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,aAAa,KAAK,IAAI,CAAC;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,oBAAoB,CAAC;CAC9B,CAAC;AAEF,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAC/D,MAAM,EAAE,0BAA0B,CAAC,KAAK,CAAC,GAC1C,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,CAW/B"}

package/dist/common/VersionedSchema/Utils/buildVersionedSchema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVersionedSchema = buildVersionedSchema;
+function buildVersionedSchema(params) {
+    const { base, refine, version, type } = params;
+    const schema = refine ? base.superRefine(refine) : base;
+    return {
+        schema,
+        baseSchema: base,
+        version,
+        type,
+    };
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export type CompatibilityIssue = {
+    type: 'removed';
+    key: string;
+} | {
+    type: 'added';
+    key: string;
+} | {
+    type: 'type-changed';
+    key: string;
+} | {
+    type: 'optional-to-required';
+    key: string;
+};
+export declare function compareShapes(prev: z.ZodObject<any>, next: z.ZodObject<any>): CompatibilityIssue[];
+//# sourceMappingURL=compareShapes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compareShapes.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/compareShapes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,sBAAsB,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3L,wBAAgB,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,kBAAkB,EAAE,CAiClG"}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareShapes = compareShapes;
+function compareShapes(prev, next) {
+    const prevShape = prev.shape;
+    const nextShape = next.shape;
+    const issues = [];
+    // removed / changed / optional → required
+    for (const key of Object.keys(prevShape)) {
+        if (!(key in nextShape)) {
+            issues.push({ type: 'removed', key });
+            continue;
+        }
+        const prevField = prevShape[key];
+        const nextField = nextShape[key];
+        if (prevField._def.typeName !== nextField._def.typeName) {
+            issues.push({ type: 'type-changed', key });
+        }
+        if (prevField.isOptional() && !nextField.isOptional()) {
+            issues.push({ type: 'optional-to-required', key });
+        }
+    }
+    // added
+    for (const key of Object.keys(nextShape)) {
+        if (!(key in prevShape)) {
+            issues.push({ type: 'added', key });
+        }
+    }
+    return issues;
+}

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

@@ -1,3 +1,8 @@
+import { z } from 'zod';
 import { VersionedSchema, VersionMatchResult } from '../Types';
-export declare function determineBestMatchingSchemaVersion(inputData: Record<string, any>, versionedSchemas: VersionedSchema<Record<string, any>>[]): VersionMatchResult;
+/**
+ * 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,eAAe,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAM/D,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,gBAAgB,EAAE,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,kBAAkB,CA4C/J"}
+{"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"}