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

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorFieldsFromValidation = getErrorFieldsFromValidation;
+// Auxiliary function for getting error fields from the Joi validation result
+function getErrorFieldsFromValidation(error) {
+    return error?.details.map(detail => ({ path: Array.isArray(detail.path) ? detail.path.join('.') : detail.path, type: detail.type })) ?? [];
+}

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

@@ -0,0 +1,8 @@
+import Joi from 'joi';
+/**
+ * Get all the unique parameter keys of all Joi schemes in the array
+ * @param schemas array of joi schemes
+ * @returns All the unique parameter keys of all Joi schemes in the array
+ */
+export declare function getUniqueKeysFromSchemas(schemas: Joi.Schema[]): Set<string>;
+//# sourceMappingURL=getUniqueKeysFromSchemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getUniqueKeysFromSchemas.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/getUniqueKeysFromSchemas.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAKtB;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,eAQ7D"}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueKeysFromSchemas = getUniqueKeysFromSchemas;
+const joiHandlers_1 = require("./joiHandlers");
+const traverseObjectStructure_1 = require("./traverseObjectStructure");
+/**
+ * Get all the unique parameter keys of all Joi schemes in the array
+ * @param schemas array of joi schemes
+ * @returns All the unique parameter keys of all Joi schemes in the array
+ */
+function getUniqueKeysFromSchemas(schemas) {
+    const result = new Set();
+    for (const schema of schemas) {
+        (0, traverseObjectStructure_1.traverseObjectStructure)(schema, [joiHandlers_1.handleJoiSchema, joiHandlers_1.handleJoiDescription], result);
+    }
+    return result;
+}

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getUniqueObjectKeys = getUniqueObjectKeys;
-const traverseGeneric_1 = require("./traverseGeneric");
+const traverseObjectStructure_1 = require("./traverseObjectStructure");
 /**
  * Get unique keys from object properties (set of options)
  * @param rawInput object properties (set of options)
@@ -9,6 +9,6 @@ const traverseGeneric_1 = require("./traverseGeneric");
  */
 function getUniqueObjectKeys(rawInput) {
     const result = new Set();
-    (0, traverseGeneric_1.traverseGeneric)(rawInput, [], result);
+    (0, traverseObjectStructure_1.traverseObjectStructure)(rawInput, [], result);
     return Array.from(result);
 }

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

@@ -1,6 +1,6 @@
-import { TraverseHandler } from "../Types";
+import { TraverseHandler } from '../Types';
 /** Handler for Joi.Schema: only the launch remains .describe() */
-export declare const joiSchemaHandler: TraverseHandler;
+export declare const handleJoiSchema: TraverseHandler<Set<string>>;
 /** Handler for the result of describe(): pulls out only the real keys of the field */
-export declare const joiDescHandler: TraverseHandler;
+export declare const handleJoiDescription: TraverseHandler<Set<string>>;
 //# sourceMappingURL=joiHandlers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"joiHandlers.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/joiHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,EAAE,eAM9B,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,cAAc,EAAE,eAsC5B,CAAC"}
+{"version":3,"file":"joiHandlers.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/joiHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,kEAAkE;AAClE,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAOxD,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,oBAAoB,EAAE,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAgD7D,CAAC"}

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

@@ -1,52 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.joiDescHandler = exports.joiSchemaHandler = void 0;
+exports.handleJoiDescription = exports.handleJoiSchema = void 0;
 /** Handler for Joi.Schema: only the launch remains .describe() */
-const joiSchemaHandler = (value, recurse) => {
+const handleJoiSchema = (value, recurse) => {
     if (value && typeof value.describe === 'function') {
         recurse(value.describe());
-        return true; // then the default bypass to the scheme itself is not needed.
+        // then the default bypass to the scheme itself is not needed.
+        return true;
     }
     return false;
 };
-exports.joiSchemaHandler = joiSchemaHandler;
+exports.handleJoiSchema = handleJoiSchema;
 /** Handler for the result of describe(): pulls out only the real keys of the field */
-const joiDescHandler = (value, recurse, result) => {
+const handleJoiDescription = (value, recurse, result) => {
     if (!value || typeof value !== 'object') {
         return false;
     }
-    let did = false;
+    let processed = false;
     // only if there are keys/items/matches/patterns, we assume that this description
     if (value.keys && typeof value.keys === 'object') {
-        did = true;
+        processed = true;
         for (const key of Object.keys(value.keys)) {
             result.add(key);
             recurse(value.keys[key]);
         }
     }
     if (Array.isArray(value.items)) {
-        did = true;
-        for (const item of value.items)
+        processed = true;
+        for (const item of value.items) {
             recurse(item);
+        }
     }
     if (Array.isArray(value.matches)) {
-        did = true;
+        processed = true;
         for (const m of value.matches) {
-            if (m.schema)
+            if (m.schema) {
                 recurse(m.schema);
-            if (m.then)
+            }
+            if (m.then) {
                 recurse(m.then);
-            if (m.otherwise)
+            }
+            if (m.otherwise) {
                 recurse(m.otherwise);
+            }
         }
     }
     if (Array.isArray(value.patterns)) {
-        did = true;
+        processed = true;
         for (const p of value.patterns) {
-            if (p.rule)
+            if (p.rule) {
                 recurse(p.rule);
+            }
         }
     }
-    return did; // if this is the description, the default bypass is not needed.
+    // if this is the description, the default bypass is not needed.
+    return processed;
 };
-exports.joiDescHandler = joiDescHandler;
+exports.handleJoiDescription = handleJoiDescription;

package/dist/common/VersionedSchema/Utils/{migrateToLatestVersion.d.ts → migrateDataToLatestSchemaVersion.d.ts}

@@ -1,15 +1,15 @@
-import { EVersionedSchemaType } from "../Enums";
-import { SchemaMigrationPlan, VersionedSchema } from "../Types";
+import { EVersionedSchemaType } from '../Enums';
+import { SchemaMigrationPlan, VersionedSchema } from '../Types';
 type MigrateToLatestProps = {
     rawInput: Record<string, any>;
-    versionedSchemas: VersionedSchema<Record<string, any>>[];
     migrationPlans: SchemaMigrationPlan<Record<string, any>, Record<string, any>>[];
+    versionedSchemas: VersionedSchema<Record<string, any>>[];
 };
 type MigrateToLatestResult = {
     value: Record<string, any>;
     schemaVersion: string;
     schemaType: EVersionedSchemaType;
 };
-export declare function migrateToLatestVersion({ rawInput, migrationPlans, versionedSchemas }: MigrateToLatestProps): MigrateToLatestResult | null;
+export declare function migrateDataToLatestSchemaVersion({ rawInput, migrationPlans, versionedSchemas }: MigrateToLatestProps): MigrateToLatestResult | null;
 export {};
-//# sourceMappingURL=migrateToLatestVersion.d.ts.map
+//# sourceMappingURL=migrateDataToLatestSchemaVersion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrateDataToLatestSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAQhE,KAAK,oBAAoB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,cAAc,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;IAChF,gBAAgB,EAAE,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;CAC5D,CAAC;AAEF,KAAK,qBAAqB,GAAG;IACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF,wBAAgB,gCAAgC,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,EAAE,oBAAoB,GAAG,qBAAqB,GAAG,IAAI,CAwCnJ"}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateDataToLatestSchemaVersion = migrateDataToLatestSchemaVersion;
+const determineBestMatchingSchemaVersion_1 = require("./determineBestMatchingSchemaVersion");
+const generateKeyMappingForInvalidKeys_1 = require("./generateKeyMappingForInvalidKeys");
+const getUniqueKeysFromSchemas_1 = require("./getUniqueKeysFromSchemas");
+const getUniqueObjectKeys_1 = require("./getUniqueObjectKeys");
+const replaceInvalidKeysWithMappedNames_1 = require("./replaceInvalidKeysWithMappedNames");
+const validateAndSuggestKeyCorrections_1 = require("./validateAndSuggestKeyCorrections");
+function migrateDataToLatestSchemaVersion({ rawInput, migrationPlans, versionedSchemas }) {
+    const schemas = versionedSchemas.map(el => el.schema);
+    const allUniqueKeysFromSchemas = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)(schemas);
+    const allUniqueKeysFromRawInput = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)(rawInput);
+    (0, validateAndSuggestKeyCorrections_1.validateAndSuggestKeyCorrections)(allUniqueKeysFromRawInput, allUniqueKeysFromSchemas);
+    const guessedVersion = (0, determineBestMatchingSchemaVersion_1.determineBestMatchingSchemaVersion)(rawInput, versionedSchemas);
+    const guessedValidationSchema = schemas[guessedVersion.lastVersionIndex];
+    const schemaPossibleKeys = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([guessedValidationSchema]);
+    const replacingKeysMap = (0, generateKeyMappingForInvalidKeys_1.generateKeyMappingForInvalidKeys)(allUniqueKeysFromRawInput, schemaPossibleKeys);
+    let currentData = replacingKeysMap.size ? (0, replaceInvalidKeysWithMappedNames_1.replaceInvalidKeysWithMappedNames)(rawInput, replacingKeysMap) : rawInput;
+    for (let idx = guessedVersion.lastVersionIndex; idx < versionedSchemas.length - 1; idx++) {
+        const fromVersion = versionedSchemas[idx].version;
+        const migrationPlan = migrationPlans.find(p => p.fromVersion === fromVersion);
+        if (!migrationPlan) {
+            throw new Error(`No migration plan from ${fromVersion}`);
+        }
+        try {
+            const migratedRaw = migrationPlan.migrate(currentData);
+            const { error } = versionedSchemas[idx + 1].schema.validate(migratedRaw, { allowUnknown: false });
+            if (error) {
+                throw new Error(`Error during post-migration validation ${fromVersion}->${migrationPlan.toVersion}: ${error.message}`);
+            }
+            currentData = { ...migratedRaw };
+        }
+        catch (e) {
+            throw new Error(e.message);
+        }
+    }
+    const currentSchema = versionedSchemas[versionedSchemas.length - 1];
+    const { error, value } = currentSchema.schema.validate(currentData, { allowUnknown: false });
+    if (error)
+        return null;
+    return { value, schemaVersion: currentSchema.version, schemaType: currentSchema.type };
+}

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

@@ -0,0 +1,2 @@
+export declare function replaceInvalidKeysWithMappedNames(input: Record<string, any> | Record<string, any>[], keyMap: Map<string, string>): Record<string, any> | Record<string, any>[];
+//# sourceMappingURL=replaceInvalidKeysWithMappedNames.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replaceInvalidKeysWithMappedNames.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/replaceInvalidKeysWithMappedNames.ts"],"names":[],"mappings":"AAEA,wBAAgB,iCAAiC,CAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAClD,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAe7C"}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceInvalidKeysWithMappedNames = replaceInvalidKeysWithMappedNames;
+// Replacing incorrect keys
+function replaceInvalidKeysWithMappedNames(input, keyMap) {
+    if (!input) {
+        throw new Error("The input data cannot be null or undefined.");
+    }
+    if (Array.isArray(input)) {
+        return input.map(item => replaceInvalidKeysWithMappedNames(item, keyMap));
+    }
+    const replacedKeys = Object.entries(input).map(([key, value]) => {
+        const newKey = keyMap.get(key) ?? key;
+        const newValue = Array.isArray(value) ? replaceInvalidKeysWithMappedNames(value, keyMap) : value;
+        return [newKey, newValue];
+    });
+    return Object.fromEntries(replacedKeys);
+}

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

@@ -0,0 +1,3 @@
+import { TraverseHandler } from "../Types";
+export declare function traverseObjectStructure<T>(root: any, handlers: TraverseHandler<T>[], result: T): void;
+//# sourceMappingURL=traverseObjectStructure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"traverseObjectStructure.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/traverseObjectStructure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,IAAI,EAAE,GAAG,EACT,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,EAC9B,MAAM,EAAE,CAAC,QA6BV"}

package/dist/common/VersionedSchema/Utils/{traverseGeneric.js → traverseObjectStructure.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseGeneric = traverseGeneric;
-function traverseGeneric(root, handlers, result) {
-    const recurse = (v) => traverseGeneric(v, handlers, result);
+exports.traverseObjectStructure = traverseObjectStructure;
+function traverseObjectStructure(root, handlers, result) {
+    const recurse = (v) => traverseObjectStructure(v, handlers, result);
     // We try "special" handlers
     let handled = false;
     for (const handler of handlers) {
@@ -21,7 +21,9 @@ function traverseGeneric(root, handlers, result) {
         }
         else {
             for (const key of Object.keys(root)) {
-                result.add(key);
+                if (result instanceof Set) {
+                    result.add(key);
+                }
                 recurse(root[key]);
             }
         }

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

@@ -0,0 +1,8 @@
+/**
+ * Optimized unknown key verification function using Levenshtein distance map.
+ *
+ * @param rawInputKeys Array of raw input keys
+ * @param allowedKeys Set of allowed (required) keys
+ */
+export declare function validateAndSuggestKeyCorrections(rawInputKeys: string[], allowedKeys: Set<string>): void;
+//# sourceMappingURL=validateAndSuggestKeyCorrections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateAndSuggestKeyCorrections.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/validateAndSuggestKeyCorrections.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,QAiChG"}

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndSuggestKeyCorrections = validateAndSuggestKeyCorrections;
+const leven_1 = __importDefault(require("leven"));
+/**
+ * Optimized unknown key verification function using Levenshtein distance map.
+ *
+ * @param rawInputKeys Array of raw input keys
+ * @param allowedKeys Set of allowed (required) keys
+ */
+function validateAndSuggestKeyCorrections(rawInputKeys, allowedKeys) {
+    const errors = [];
+    const distanceMap = new Map();
+    // Creating a distance map once for all keys
+    for (const key of rawInputKeys) {
+        if (!allowedKeys.has(key)) {
+            let bestMatch = null;
+            let bestDistance = Infinity;
+            for (const candidate of allowedKeys) {
+                const d = (0, leven_1.default)(key, candidate);
+                if (d < bestDistance) {
+                    bestDistance = d;
+                    bestMatch = candidate;
+                }
+            }
+            distanceMap.set(key, { bestMatch, bestDistance });
+        }
+    }
+    // Generating error messages
+    for (const [key, { bestMatch, bestDistance }] of distanceMap) {
+        if (bestMatch && bestDistance <= 3) {
+            errors.push(`The "${key}" field is not recognized. Perhaps you meant "${bestMatch}".`);
+        }
+        else {
+            errors.push(`The "${key}" field is not recognized.`);
+        }
+    }
+    if (errors.length) {
+        throw new Error(errors.join('\n'));
+    }
+}

package/dist/common/__tests__/__mock__/mockJoiSchema.d.ts

@@ -0,0 +1,19 @@
+export declare const mockJoiSchema: (keys: string[], isValid: boolean, errors?: {
+    path: string;
+    type: string;
+}[], isArray?: boolean) => {
+    validate: (input: any, options: any) => {
+        error: {
+            details: {
+                path: string;
+                type: string;
+            }[];
+        } | null;
+        value: any;
+    };
+    describe: () => {
+        keys: {} | undefined;
+        items: {}[] | undefined;
+    };
+};
+//# sourceMappingURL=mockJoiSchema.d.ts.map

package/dist/common/__tests__/__mock__/mockJoiSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockJoiSchema.d.ts","sourceRoot":"","sources":["../../../../src/common/__tests__/__mock__/mockJoiSchema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,EAAE,SAAS,OAAO,EAAE,SAAQ;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAO,EAAE,iBAAe;sBACxG,GAAG,WAAW,GAAG;;;sBADyC,MAAM;sBAAQ,MAAM;;;;;;;;;CASlG,CAAC"}

package/dist/common/__tests__/__mock__/mockJoiSchema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockJoiSchema = void 0;
+const mockJoiSchema = (keys, isValid, errors = [], isArray = false) => ({
+    validate: (input, options) => ({
+        error: isValid ? null : { details: errors },
+        value: input,
+    }),
+    describe: () => ({
+        keys: isArray ? undefined : keys.reduce((acc, key) => ({ ...acc, [key]: {} }), {}),
+        items: isArray ? [{}] : undefined,
+    }),
+});
+exports.mockJoiSchema = mockJoiSchema;

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

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

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

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

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

@@ -0,0 +1,227 @@
+"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 Utils_1 = require("common/Utils");
+(0, node_test_1.describe)('convertArrayToObject', () => {
+    (0, node_test_1.test)('@unit: Empty array', () => {
+        const input = [];
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        const expected = {
+            items: [],
+            exportCore: undefined,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            request: undefined,
+            useOptions: undefined,
+            useCancelableRequest: undefined,
+        };
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: An array with one element', () => {
+        const input = [
+            {
+                input: 'url1',
+                output: 'res1',
+                exportCore: true,
+                request: 'req1',
+                useOptions: true,
+            },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: true,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: 'req1',
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: Multiple elements with the same outer margins', () => {
+        const input = [
+            { input: 'url1', output: 'res1', exportCore: true, request: 'req1', useOptions: true },
+            { input: 'url2', output: 'res2', exportCore: true, request: 'req1', useOptions: true },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: true,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: 'req1',
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: Multiple elements with different external margins', () => {
+        const input = [
+            { input: 'url1', output: 'res1', exportCore: true, request: 'req1', useOptions: true },
+            { input: 'url2', output: 'res2', exportCore: false, request: 'req2', useOptions: false },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: true,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: 'req1',
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: No optional fields', () => {
+        const input = [
+            { input: 'url1', output: 'res1' },
+            { input: 'url2', output: 'res2' },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: undefined,
+            useUnionTypes: undefined,
+            exportCore: undefined,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: undefined,
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: Mixed presence of optional fields', () => {
+        const input = [
+            { input: 'url1', output: 'res1', exportCore: true },
+            { input: 'url2', output: 'res2', request: 'req2' },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: undefined,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: undefined,
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+});

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

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

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

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