ts-openapi-codegen 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/common/__tests__/determineBestMatchingSchemaVersion.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const Enums_1 = require("../../common/VersionedSchema/Enums");
+const determineBestMatchingSchemaVersion_1 = require("../VersionedSchema/Utils/determineBestMatchingSchemaVersion");
+const mockJoiSchema_1 = require("./__mock__/mockJoiSchema");
+(0, node_test_1.describe)('determineBestMatchingSchemaVersion', () => {
+    (0, node_test_1.test)('@unit: it should return the latest version if there is an exact match.', async () => {
+        const schemas = [
+            { schema: (0, mockJoiSchema_1.mockJoiSchema)(['name'], true), version: '1.0', type: Enums_1.EVersionedSchemaType.OPTIONS },
+            { schema: (0, mockJoiSchema_1.mockJoiSchema)(['name', 'age'], true), version: '2.0', type: Enums_1.EVersionedSchemaType.OPTIONS },
+        ];
+        const input = { name: 'John', age: 30 };
+        const result = (0, determineBestMatchingSchemaVersion_1.determineBestMatchingSchemaVersion)(input, schemas);
+        node_assert_1.default.deepEqual(result, {
+            lastVersionIndex: 1,
+            latestVersion: '2.0',
+            firstVersion: '1.0',
+        });
+    });
+    (0, node_test_1.test)('@unit: should return the best scheme in the absence of exact matches.', async () => {
+        const schemas = [
+            { schema: (0, mockJoiSchema_1.mockJoiSchema)(['name'], false, [{ path: 'age', type: 'string' }]), version: '1.0', type: Enums_1.EVersionedSchemaType.OPTIONS },
+            { schema: (0, mockJoiSchema_1.mockJoiSchema)(['name', 'age'], true), version: '2.0', type: Enums_1.EVersionedSchemaType.OPTIONS },
+        ];
+        const input = { name: 'John', age: 30 };
+        const result = (0, determineBestMatchingSchemaVersion_1.determineBestMatchingSchemaVersion)(input, schemas);
+        node_assert_1.default.deepEqual(result, {
+            lastVersionIndex: 1,
+            latestVersion: '2.0',
+            firstVersion: '2.0',
+        });
+    });
+});

package/dist/common/__tests__/generateKeyMappingForInvalidKeys.test.d.ts

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

package/dist/common/__tests__/generateKeyMappingForInvalidKeys.test.d.ts.map

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

package/dist/common/__tests__/generateKeyMappingForInvalidKeys.test.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const generateKeyMappingForInvalidKeys_1 = require("../VersionedSchema/Utils/generateKeyMappingForInvalidKeys");
+(0, node_test_1.describe)('generateKeyMappingForInvalidKeys', () => {
+    (0, node_test_1.test)('@unit: must create a replacement card for invalid keys', async () => {
+        const inputKeys = ['nmae', 'title'];
+        const allowedKeys = new Set(['name', 'title']);
+        const result = (0, generateKeyMappingForInvalidKeys_1.generateKeyMappingForInvalidKeys)(inputKeys, allowedKeys);
+        node_assert_1.default.deepEqual(result, new Map([['nmae', 'name']]));
+    });
+    (0, node_test_1.test)('@unit: must return an empty card if all keys are valid.', async () => {
+        const inputKeys = ['name', 'title'];
+        const allowedKeys = new Set(['name', 'title']);
+        const result = (0, generateKeyMappingForInvalidKeys_1.generateKeyMappingForInvalidKeys)(inputKeys, allowedKeys);
+        node_assert_1.default.deepEqual(result, new Map());
+    });
+});

package/dist/common/__tests__/getUniqueKeysFromSchemas.test.d.ts

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

package/dist/common/__tests__/getUniqueKeysFromSchemas.test.d.ts.map

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

package/dist/common/__tests__/getUniqueKeysFromSchemas.test.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const getUniqueKeysFromSchemas_1 = require("../VersionedSchema/Utils/getUniqueKeysFromSchemas");
+const mockJoiSchema_1 = require("./__mock__/mockJoiSchema");
+(0, node_test_1.describe)('getUniqueKeysFromSchemas', () => {
+    (0, node_test_1.test)('@unit: must return unique keys from the schema', async () => {
+        const schema = (0, mockJoiSchema_1.mockJoiSchema)(['name', 'age'], true);
+        const result = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([schema]);
+        node_assert_1.default.deepEqual(result, new Set(['name', 'age']));
+    });
+    (0, node_test_1.test)('@unit: should return an empty set for an empty list of schemas', async () => {
+        const result = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([]);
+        node_assert_1.default.deepEqual(result, new Set());
+    });
+});

package/dist/common/__tests__/getUniqueObjectKeys.test.d.ts

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

package/dist/common/__tests__/getUniqueObjectKeys.test.d.ts.map

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

package/dist/common/__tests__/getUniqueObjectKeys.test.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const getUniqueObjectKeys_1 = require("../VersionedSchema/Utils/getUniqueObjectKeys");
+(0, node_test_1.describe)('getUniqueObjectKeys', () => {
+    (0, node_test_1.test)('@unit: must return unique keys from the object', async () => {
+        const input = { name: 'John', age: 30, nested: { id: 1 } };
+        const result = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)(input);
+        node_assert_1.default.deepEqual(result, ['name', 'age', 'nested', 'id']);
+    });
+    (0, node_test_1.test)('@unit: must return unique keys from an array of objects', async () => {
+        const input = [{ name: 'John' }, { age: 30 }];
+        const result = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)(input);
+        node_assert_1.default.deepEqual(result, ['name', 'age']);
+    });
+    (0, node_test_1.test)('@unit: must return an empty array for an empty object', async () => {
+        const result = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)({});
+        node_assert_1.default.deepEqual(result, []);
+    });
+});

package/dist/common/__tests__/migrationForMultiOptions.test.js

@@ -3,79 +3,100 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_assert_1 = __importDefault(require("node:assert"));
+const strict_1 = __importDefault(require("node:assert/strict"));
 const node_test_1 = require("node:test");
-const MultiOptionsMigrationPlan_1 = require("common/VersionedSchema/MultiOptionsMigrationPlan");
-const MultiOptionsVersionedSchemas_1 = require("common/VersionedSchema/MultiOptionsVersionedSchemas");
-const core_1 = require("../../core");
 const Enums_1 = require("../VersionedSchema/Enums");
-const migrateToLatestVersion_1 = require("../VersionedSchema/Utils/migrateToLatestVersion");
-(0, node_test_1.describe)('migrateToLatestVersion for Multioptions', () => {
-    node_test_1.test.skip('@unit: should migrate Multioptions data from 1.0.0 to 2.0.0', () => {
-        const dataMultiV1 = {
-            input: 'source/path',
-            output: 'generated/path',
-            client: core_1.HttpClient.AXIOS,
-            items: [{ input: 'item1', output: 'generated/path', }, { input: 'item2', output: 'generated/path', }],
-        };
-        const expectedDataMultiV3 = {
-            input: 'source/path',
-            httpClient: core_1.HttpClient.AXIOS,
-            items: [{ input: 'item1' }, { input: 'item2' }],
-            useCancelableRequest: false,
-        };
-        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-            rawInput: dataMultiV1,
-            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+const MultiOptionsMigrationPlan_1 = require("../VersionedSchema/MultiOptionsMigrationPlan");
+const MultiOptionsVersionedSchemas_1 = require("../VersionedSchema/MultiOptionsVersionedSchemas");
+const migrateDataToLatestSchemaVersion_1 = require("../VersionedSchema/Utils/migrateDataToLatestSchemaVersion");
+const mockJoiSchema_1 = require("./__mock__/mockJoiSchema");
+(0, node_test_1.describe)('migrationForMultiOptions', () => {
+    (0, node_test_1.test)('@unit: must successfully migrate MULTI_OPTIONS data to the latest version', async () => {
+        const input = { input: 'input/path', output: 'output/path', client: 'fetch', items: [{ input: 'path/item1' }] };
+        const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
             migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+        });
+        strict_1.default.deepEqual(result, {
+            value: {
+                httpClient: 'fetch',
+                useCancelableRequest: false,
+                items: [
+                    {
+                        input: 'input/path',
+                        output: 'output/path',
+                        outputCore: undefined,
+                        outputModels: undefined,
+                        outputSchemas: undefined,
+                        outputServices: undefined,
+                    },
+                ],
+            },
+            schemaVersion: '2.0.0',
+            schemaType: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
         });
-        node_assert_1.default.deepEqual(result, { value: expectedDataMultiV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.MULTI_OPTIONS }, 'Should migrate Multioptions V1 data to V3 correctly');
     });
-    node_test_1.test.skip('@unit: should migrate Multioptions data from 1.0.1 to 2.0.0', () => {
-        const dataMultiV2 = {
-            input: 'source/path',
-            output: 'generated/path',
-            httpClient: core_1.HttpClient.FETCH,
-            items: [{ input: 'item1' }, { input: 'item2' }],
-        };
-        const expectedDataMultiV3 = {
-            httpClient: core_1.HttpClient.FETCH,
-            items: [{ input: 'item1', output: 'generated/path', }, { input: 'item2', output: 'generated/path' }],
-        };
-        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-            rawInput: dataMultiV2,
-            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+    (0, node_test_1.test)('@unit: should return null in case of validation error of the last MULTI_OPTIONS scheme', async () => {
+        const input = { input: 'input/path' };
+        const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
             migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
         });
-        node_assert_1.default.deepEqual(result, { value: expectedDataMultiV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.MULTI_OPTIONS }, 'Should migrate Multioptions V2 data to V3 correctly');
+        strict_1.default.equal(result, null);
     });
-    node_test_1.test.skip('@unit: should return null for invalid Multioptions data after migration', () => {
-        const dataMultiV1 = {
-            input: 'source/path',
-            output: 'generated/path',
-            client: 'invalid-client', // Некорректное значение
-            items: [{ input: 'item1' }, { input: 'item2' }],
-        };
-        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-            rawInput: dataMultiV1,
+    (0, node_test_1.test)('@unit: should throw an error if the migration plan for MULTI_OPTIONS is not found.', async () => {
+        const input = { input: 'input/path', output: 'output/path', client: 'fetch', items: [{ input: 'path/item1' }] };
+        strict_1.default.throws(() => (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
+            migrationPlans: [],
             versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
-            migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
-        });
-        node_assert_1.default.equal(result, null, 'Should return null for invalid Multioptions data');
+        }), /No migration plan from 1.0.0/);
     });
-    node_test_1.test.skip('@unit: should throw error if no migration plan exists for Multioptions', () => {
-        const dataMultiV1 = {
-            input: 'source/path',
-            output: 'generated/path',
-            client: 'axios',
-            items: [{ input: 'item1' }, { input: 'item2' }],
+    (0, node_test_1.test)('@unit: should throw an error on unrecognized fields in MULTI_OPTIONS', async () => {
+        const input = {
+            input: 'input/path',
+            output: 'output/path',
+            client: 'fetch',
+            items: [{ input: 'path/item1', name: 'Item1' }],
         };
-        node_assert_1.default.throws(() => {
-            (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-                rawInput: dataMultiV1,
-                versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
-                migrationPlans: [],
-            });
-        }, /No migration plan from 1.0.0/, 'Should throw for missing migration plan in Multioptions');
+        strict_1.default.throws(() => (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
+            migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+        }), /The "name" field is not recognized./);
+    });
+    (0, node_test_1.test)('@unit: must process an empty array of MULTI_OPTIONS data', async () => {
+        const schemas = [
+            {
+                schema: (0, mockJoiSchema_1.mockJoiSchema)(['name'], true, [], true),
+                version: '1.0',
+                type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+            },
+            {
+                schema: (0, mockJoiSchema_1.mockJoiSchema)(['name', 'options'], true, [], true),
+                version: '2.0',
+                type: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+            },
+        ];
+        const migrationPlans = [
+            {
+                fromVersion: '1.0',
+                toVersion: '2.0',
+                migrate: (input) => input.map((item) => ({ ...item, options: [] })),
+            },
+        ];
+        const input = [];
+        const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
+            migrationPlans,
+            versionedSchemas: schemas,
+        });
+        strict_1.default.deepEqual(result, {
+            value: [],
+            schemaVersion: '2.0',
+            schemaType: Enums_1.EVersionedSchemaType.MULTI_OPTIONS,
+        });
     });
 });

package/dist/common/__tests__/migrationForOptions.test.js

@@ -3,60 +3,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_assert_1 = __importDefault(require("node:assert"));
+const strict_1 = __importDefault(require("node:assert/strict"));
 const node_test_1 = require("node:test");
-const OptionsMigrationPlans_1 = require("common/VersionedSchema/OptionsMigrationPlans");
-const OptionsVersionedSchemas_1 = require("common/VersionedSchema/OptionsVersionedSchemas");
-const core_1 = require("../../core");
 const Enums_1 = require("../VersionedSchema/Enums");
-const migrateToLatestVersion_1 = require("../VersionedSchema/Utils/migrateToLatestVersion");
-(0, node_test_1.describe)('migrateToLatestVersion', () => {
-    (0, node_test_1.test)('@unit: should migrate data from 1.0.0 to 2.0.0', () => {
-        const dataV1 = { input: 'source/path', output: 'generated/path', client: core_1.HttpClient.AXIOS };
-        const expectedDataV3 = {
-            input: 'source/path',
-            output: 'generated/path',
-            httpClient: core_1.HttpClient.AXIOS,
-            useCancelableRequest: false,
-        };
-        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-            rawInput: dataV1,
-            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+const OptionsMigrationPlans_1 = require("../VersionedSchema/OptionsMigrationPlans");
+const OptionsVersionedSchemas_1 = require("../VersionedSchema/OptionsVersionedSchemas");
+const migrateDataToLatestSchemaVersion_1 = require("../VersionedSchema/Utils/migrateDataToLatestSchemaVersion");
+(0, node_test_1.describe)('migrationForOptions', () => {
+    (0, node_test_1.test)('@unit: must migrate data to the latest schema version', async () => {
+        const input = { input: "input/path", output: "output/path", client: "fetch" };
+        const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
             migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
-        });
-        node_assert_1.default.deepEqual(result, { value: expectedDataV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.OPTIONS }, 'Should migrate 1.0.0 data to 2.0.0 correctly');
-    });
-    (0, node_test_1.test)('@unit: should migrate data from 1.0.1 to 2.0.0', () => {
-        const dataV2 = { input: 'source/path', output: 'generated/path', httpClient: core_1.HttpClient.FETCH };
-        const expectedDataV3 = {
-            input: 'source/path',
-            output: 'generated/path',
-            httpClient: core_1.HttpClient.FETCH,
-        };
-        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-            rawInput: dataV2,
             versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
-            migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
         });
-        node_assert_1.default.deepEqual(result, { value: expectedDataV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.OPTIONS }, 'Should migrate 1.0.1 data to 2.0.0 correctly');
+        strict_1.default.deepEqual(result, {
+            value: { input: 'input/path', output: 'output/path', httpClient: 'fetch', useCancelableRequest: false },
+            schemaVersion: '2.0.0',
+            schemaType: Enums_1.EVersionedSchemaType.OPTIONS,
+        });
     });
-    node_test_1.test.skip('@unit: should return null for invalid data after migration', () => {
-        const dataV1 = { input: 'source/path', output: 'generated/path', client: 'invalid-client' };
-        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-            rawInput: dataV1,
-            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+    (0, node_test_1.test)('@unit: should return null if the validation error occurred for the last schema.', async () => {
+        const input = { input: "input/path", };
+        const result = (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
             migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
+            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
         });
-        node_assert_1.default.equal(result, null, 'Should return null for invalid data');
+        strict_1.default.equal(result, null);
     });
-    (0, node_test_1.test)('@unit: should throw error if no migration plan exists', () => {
-        const dataV1 = { input: 'source/path', output: 'generated/path', client: core_1.HttpClient.AXIOS };
-        node_assert_1.default.throws(() => {
-            (0, migrateToLatestVersion_1.migrateToLatestVersion)({
-                rawInput: dataV1,
-                versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
-                migrationPlans: [],
-            });
-        }, /No migration plan from 1.0.0/, 'Should throw for missing migration plan');
+    (0, node_test_1.test)('@unit: It should throw an error if the migration plan is not found.', async () => {
+        const input = { input: "input/path", output: "output/path", client: "fetch" };
+        strict_1.default.throws(() => (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
+            rawInput: input,
+            migrationPlans: [],
+            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+        }), /No migration plan from 1.0.0/);
     });
 });

package/dist/common/__tests__/replaceInvalidKeysWithMappedNames.test.d.ts

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

package/dist/common/__tests__/replaceInvalidKeysWithMappedNames.test.d.ts.map

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

package/dist/common/__tests__/replaceInvalidKeysWithMappedNames.test.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const replaceInvalidKeysWithMappedNames_1 = require("../VersionedSchema/Utils/replaceInvalidKeysWithMappedNames");
+(0, node_test_1.describe)('replaceInvalidKeysWithMappedNames', () => {
+    (0, node_test_1.test)('@unit: must replace invalid keys in the object', async () => {
+        const input = { nmae: 'John', title: 'Mr' };
+        const keyMap = new Map([['nmae', 'name']]);
+        const result = (0, replaceInvalidKeysWithMappedNames_1.replaceInvalidKeysWithMappedNames)(input, keyMap);
+        node_assert_1.default.deepEqual(result, { name: 'John', title: 'Mr' });
+    });
+    (0, node_test_1.test)('@unit: must replace invalid keys in an array of objects', async () => {
+        const input = [{ nmae: 'John' }, { nmae: 'Jane' }];
+        const keyMap = new Map([['nmae', 'name']]);
+        const result = (0, replaceInvalidKeysWithMappedNames_1.replaceInvalidKeysWithMappedNames)(input, keyMap);
+        node_assert_1.default.deepEqual(result, [{ name: 'John' }, { name: 'Jane' }]);
+    });
+    (0, node_test_1.test)('@unit: should throw an error for null or undefined', async () => {
+        node_assert_1.default.throws(() => (0, replaceInvalidKeysWithMappedNames_1.replaceInvalidKeysWithMappedNames)(null, new Map()), /The input data cannot be null or undefined./);
+    });
+});

package/dist/common/__tests__/validateAndSuggestKeyCorrections.test.d.ts

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

package/dist/common/__tests__/validateAndSuggestKeyCorrections.test.d.ts.map

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

package/dist/common/__tests__/validateAndSuggestKeyCorrections.test.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const validateAndSuggestKeyCorrections_1 = require("../VersionedSchema/Utils/validateAndSuggestKeyCorrections");
+(0, node_test_1.describe)('validateAndSuggestKeyCorrections', () => {
+    (0, node_test_1.test)('@unit: should throw an error for unknown keys with a suggestion for correction', async () => {
+        const inputKeys = ['nmae'];
+        const allowedKeys = new Set(['name', 'title']);
+        node_assert_1.default.throws(() => (0, validateAndSuggestKeyCorrections_1.validateAndSuggestKeyCorrections)(inputKeys, allowedKeys), /The "nmae" field is not recognized. Perhaps you meant "name"./);
+    });
+    (0, node_test_1.test)('@unit: should throw an error without suggestions for keys with a large distance', async () => {
+        const inputKeys = ['unknown'];
+        const allowedKeys = new Set(['name', 'title']);
+        node_assert_1.default.throws(() => (0, validateAndSuggestKeyCorrections_1.validateAndSuggestKeyCorrections)(inputKeys, allowedKeys), /The "unknown" field is not recognized./);
+    });
+    (0, node_test_1.test)('@unit: should not throw an error for valid keys', async () => {
+        const inputKeys = ['name', 'title'];
+        const allowedKeys = new Set(['name', 'title']);
+        node_assert_1.default.doesNotThrow(() => (0, validateAndSuggestKeyCorrections_1.validateAndSuggestKeyCorrections)(inputKeys, allowedKeys));
+    });
+});

package/dist/common/defaultOptions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultOptions.d.ts","sourceRoot":"","sources":["../../src/common/defaultOptions.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,cAAc,uBAA8B,CAAC"}
+{"version":3,"file":"defaultOptions.d.ts","sourceRoot":"","sources":["../../src/common/defaultOptions.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAItB,eAAO,MAAM,cAAc,uBA0BV,CAAC"}

package/dist/common/defaultOptions.js

@@ -5,5 +5,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultOptions = void 0;
 const joi_1 = __importDefault(require("joi"));
-// Заполнить
-exports.defaultOptions = joi_1.default.object().unknown(false);
+const Enums_1 = require("../core/types/Enums");
+exports.defaultOptions = joi_1.default.object({
+    input: joi_1.default.string().required(),
+    output: joi_1.default.string().required(),
+    httpClient: joi_1.default.string().valid(...Object.values(Enums_1.HttpClient)),
+    outputCore: joi_1.default.string().optional(),
+    outputServices: joi_1.default.string().optional(),
+    outputModels: joi_1.default.string().optional(),
+    outputSchemas: joi_1.default.string().optional(),
+    useOptions: joi_1.default.boolean().optional(),
+    useUnionTypes: joi_1.default.boolean().optional(),
+    exportCore: joi_1.default.boolean().optional(),
+    exportServices: joi_1.default.boolean().optional(),
+    exportModels: joi_1.default.boolean().optional(),
+    exportSchemas: joi_1.default.boolean().optional(),
+    clean: joi_1.default.boolean().optional(),
+    request: joi_1.default.string().optional(),
+    interfacePrefix: joi_1.default.string().optional(),
+    enumPrefix: joi_1.default.string().optional(),
+    typePrefix: joi_1.default.string().optional(),
+    useCancelableRequest: joi_1.default.boolean().optional(),
+}).unknown(false);

package/dist/core/index.d.ts

@@ -1,4 +1,4 @@
-import { MultiOptions, Options } from '../common/Options';
+import { TMultiOptions, TOptions } from '../common/Options';
 export { HttpClient } from './types/Enums';
-export declare function generate(options: Options | Options[] | MultiOptions): Promise<void>;
+export declare function generate(options: TOptions | TOptions[] | TMultiOptions): Promise<void>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAmB1D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAmH3C,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,GAAG,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCzF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAmB5D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAsH3C,wBAAsB,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,QAAQ,EAAE,GAAG,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAmD5F"}

package/dist/core/index.js

@@ -1,7 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
 exports.generate = generate;
+/* istanbul ignore file */
+const path_1 = __importDefault(require("path"));
 const Parser_1 = require("./api/v2/Parser");
 const Parser_2 = require("./api/v3/Parser");
 const Context_1 = require("./Context");
@@ -59,12 +64,14 @@ async function generateFrom({ input, output, outputCore, outputServices, outputM
         useUnionTypes,
         useOptions,
     });
+    writeClient.logger.info('Defining the version of the openapi specification (2 or 3)');
     switch (openApiVersion) {
         case getOpenApiVersion_1.OpenApiVersion.V2: {
             const client = new Parser_1.Parser(context).parse(openApi);
             const clientFinal = (0, postProcessClient_1.postProcessClient)(client);
             if (!write)
                 break;
+            writeClient.logger.info('Write our OpenAPI client version 2 to disk.');
             await writeClient.writeClient({
                 client: clientFinal,
                 templates,
@@ -87,6 +94,7 @@ async function generateFrom({ input, output, outputCore, outputServices, outputM
             const clientFinal = (0, postProcessClient_1.postProcessClient)(client);
             if (!write)
                 break;
+            writeClient.logger.info('Write our OpenAPI client version 3 to disk.');
             await writeClient.writeClient({
                 client: clientFinal,
                 templates,
@@ -118,27 +126,41 @@ async function generate(options) {
     else {
         preparedOptions = Array.of(options);
     }
-    const optionsFinal = preparedOptions.map((op) => (0, prepareOptions_1.prepareOptions)(op));
-    for (const option of optionsFinal) {
-        if (option.output) {
-            await fileSystem_1.fileSystem.rmdir(option.output);
-        }
-        if (option.outputCore) {
-            await fileSystem_1.fileSystem.rmdir(option.outputCore);
-        }
-        if (option.outputSchemas) {
-            await fileSystem_1.fileSystem.rmdir(option.outputSchemas);
-        }
-        if (option.outputModels) {
-            await fileSystem_1.fileSystem.rmdir(option.outputModels);
+    const optionsFinal = preparedOptions.map(op => (0, prepareOptions_1.prepareOptions)(op));
+    const writeClient = new writeClient_1.WriteClient();
+    writeClient.logger.forceInfo(`Generation has begun. Total number of specification files: ${optionsFinal.length}`);
+    try {
+        const start = process.hrtime();
+        for (const option of optionsFinal) {
+            if (option.output) {
+                await fileSystem_1.fileSystem.rmdir(option.output);
+            }
+            if (option.outputCore) {
+                await fileSystem_1.fileSystem.rmdir(option.outputCore);
+            }
+            if (option.outputSchemas) {
+                await fileSystem_1.fileSystem.rmdir(option.outputSchemas);
+            }
+            if (option.outputModels) {
+                await fileSystem_1.fileSystem.rmdir(option.outputModels);
+            }
+            if (option.outputServices) {
+                await fileSystem_1.fileSystem.rmdir(option.outputServices);
+            }
         }
-        if (option.outputServices) {
-            await fileSystem_1.fileSystem.rmdir(option.outputServices);
+        for (const option of optionsFinal) {
+            await generateFrom(option, writeClient);
+            writeClient.logger.info(`Generation from "${option.input}" was finished`);
+            writeClient.logger.info(`Output folder: ${path_1.default.resolve(process.cwd(), option.output)}`, true);
         }
+        await writeClient.combineAndWrite();
+        writeClient.logger.forceInfo("Generation from has been finished");
+        const [seconds, nanoseconds] = process.hrtime(start);
+        const durationInMs = seconds + nanoseconds / 1e6;
+        writeClient.logger.forceInfo(`Lead time: ${durationInMs.toFixed(2)} sec`);
     }
-    const writeClient = new writeClient_1.WriteClient();
-    for (const option of optionsFinal) {
-        await generateFrom(option, writeClient);
+    catch (error) {
+        writeClient.logger.error(error.message);
     }
-    await writeClient.combineAndWrite();
+    writeClient.logger.shutdownLogger();
 }