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

package/dist/cli/generate/runGenerateOpenApi.js

@@ -42,7 +42,7 @@ const MultiOptionsMigrationPlan_1 = require("../../common/VersionedSchema/MultiO
 const MultiOptionsVersionedSchemas_1 = require("../../common/VersionedSchema/MultiOptionsVersionedSchemas");
 const OptionsMigrationPlans_1 = require("../../common/VersionedSchema/OptionsMigrationPlans");
 const OptionsVersionedSchemas_1 = require("../../common/VersionedSchema/OptionsVersionedSchemas");
-const migrateToLatestVersion_1 = require("../../common/VersionedSchema/Utils/migrateToLatestVersion");
+const migrateDataToLatestSchemaVersion_1 = require("../../common/VersionedSchema/Utils/migrateDataToLatestSchemaVersion");
 const OpenAPI = __importStar(require("../../core"));
 const isInstanceOfMultiOptions_1 = require("../../core/utils/isInstanceOfMultiOptions");
 /**
@@ -71,12 +71,12 @@ async function runGenerateOpenApi(options) {
         const preparedOptions = (0, Utils_1.convertArrayToObject)(configData);
         const isMultiOptions = (0, isInstanceOfMultiOptions_1.isInstanceOfMultioptions)(preparedOptions);
         const migratedOptions = isMultiOptions
-            ? (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            ? (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
                 rawInput: preparedOptions,
                 migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
                 versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
             })
-            : (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            : (0, migrateDataToLatestSchemaVersion_1.migrateDataToLatestSchemaVersion)({
                 rawInput: preparedOptions,
                 migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
                 versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,

package/dist/common/VersionedSchema/Types.d.ts

@@ -14,5 +14,5 @@ export type GuessVersion = {
     version: string;
     index: number;
 };
-export type TraverseHandler = (value: any, recurse: (v: any) => void, result: Set<string>) => boolean;
+export type TraverseHandler<T> = (value: any, recurse: (v: any) => void, result: T) => boolean;
 //# sourceMappingURL=Types.d.ts.map

package/dist/common/VersionedSchema/Types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../../src/common/VersionedSchema/Types.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;IAC7B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,CAAC,IAAI,EAAE,EAAE,IAAI;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC;CAChC,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACjB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAC5B,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,EACzB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,KAChB,OAAO,CAAC"}
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../../src/common/VersionedSchema/Types.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;IAC7B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,CAAC,IAAI,EAAE,EAAE,IAAI;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC;CAChC,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACjB,CAAA;AAGD,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC"}

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

@@ -0,0 +1,9 @@
+import { VersionedSchema } from '../Types';
+type VersionMatchResult = {
+    lastVersionIndex: number;
+    latestVersion: string;
+    firstVersion: string;
+};
+export declare function determineBestMatchingSchemaVersion(inputData: Record<string, any>, versionedSchemas: VersionedSchema<Record<string, any>>[]): VersionMatchResult;
+export {};
+//# sourceMappingURL=determineBestMatchingSchemaVersion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"determineBestMatchingSchemaVersion.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/determineBestMatchingSchemaVersion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAK3C,KAAK,kBAAkB,GAAG;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACxB,CAAC;AAGF,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"}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineBestMatchingSchemaVersion = determineBestMatchingSchemaVersion;
+const getErrorFieldsFromValidation_1 = require("./getErrorFieldsFromValidation");
+const getUniqueKeysFromSchemas_1 = require("./getUniqueKeysFromSchemas");
+const getUniqueObjectKeys_1 = require("./getUniqueObjectKeys");
+// Determining the most appropriate schema version
+function determineBestMatchingSchemaVersion(inputData, versionedSchemas) {
+    if (!versionedSchemas.length) {
+        throw new Error('The list of schemes cannot be empty');
+    }
+    const inputKeys = (0, getUniqueObjectKeys_1.getUniqueObjectKeys)(inputData);
+    const matchingSchemas = versionedSchemas
+        .map(({ schema, version }, idx) => {
+        const { error } = schema.validate(inputData, { allowUnknown: true });
+        const errorFields = (0, getErrorFieldsFromValidation_1.getErrorFieldsFromValidation)(error).filter(err => err.type !== 'any.only');
+        return errorFields.length === 0 ? { version, index: idx } : null;
+    })
+        .filter((match) => match !== null);
+    if (matchingSchemas.length > 0) {
+        const latestMatch = matchingSchemas.reduce((prev, curr) => (curr.index > prev.index ? curr : prev));
+        return {
+            lastVersionIndex: latestMatch.index,
+            latestVersion: latestMatch.version,
+            firstVersion: matchingSchemas[0].version,
+        };
+    }
+    const schemaMatches = versionedSchemas.map(({ schema, version }, idx) => {
+        const schemaKeys = (0, getUniqueKeysFromSchemas_1.getUniqueKeysFromSchemas)([schema]);
+        const { error } = schema.validate(inputData, { allowUnknown: true });
+        const errorFields = (0, getErrorFieldsFromValidation_1.getErrorFieldsFromValidation)(error).filter(err => err.type !== 'any.only');
+        const matchingKeys = inputKeys.filter(key => schemaKeys.has(key));
+        return { index: idx, version, errorFields, matchingKeys };
+    });
+    const bestMatch = schemaMatches.reduce((best, current) => {
+        const isBetterMatch = current.matchingKeys.length >= best.matchingKeys.length && current.errorFields.length <= best.errorFields.length;
+        return isBetterMatch ? current : best;
+    }, schemaMatches[0]);
+    return {
+        lastVersionIndex: bestMatch.index,
+        latestVersion: bestMatch.version,
+        firstVersion: bestMatch.version,
+    };
+}

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

@@ -0,0 +1,2 @@
+export declare function generateKeyMappingForInvalidKeys(rawInputKeys: string[], allowedKeys: Set<string>): Map<string, string>;
+//# sourceMappingURL=generateKeyMappingForInvalidKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateKeyMappingForInvalidKeys.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/generateKeyMappingForInvalidKeys.ts"],"names":[],"mappings":"AAGA,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAiBtH"}

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

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateKeyMappingForInvalidKeys = generateKeyMappingForInvalidKeys;
+const leven_1 = __importDefault(require("leven"));
+// Generating a key replacement card
+function generateKeyMappingForInvalidKeys(rawInputKeys, allowedKeys) {
+    const result = new Map();
+    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 && d <= 3) {
+                    bestDistance = d;
+                    bestMatch = candidate;
+                }
+            }
+            if (bestMatch)
+                result.set(key, bestMatch);
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,6 @@
+import Joi from 'joi';
+export declare function getErrorFieldsFromValidation(error: Joi.ValidationError | undefined): {
+    path: string;
+    type: string;
+}[];
+//# sourceMappingURL=getErrorFieldsFromValidation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getErrorFieldsFromValidation.d.ts","sourceRoot":"","sources":["../../../../src/common/VersionedSchema/Utils/getErrorFieldsFromValidation.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAGtB,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,GAAG,CAAC,eAAe,GAAG,SAAS;;;IAElF"}

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/{getUniqueAllShemasKeys.d.ts → getUniqueKeysFromSchemas.d.ts}

@@ -1,8 +1,8 @@
-import Joi from "joi";
+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 getUniqueAllShemasKeys(schemas: Joi.Schema[]): Set<string>;
-//# sourceMappingURL=getUniqueAllShemasKeys.d.ts.map
+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/{getUniqueAllShemasKeys.js → getUniqueKeysFromSchemas.js}

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUniqueAllShemasKeys = getUniqueAllShemasKeys;
+exports.getUniqueKeysFromSchemas = getUniqueKeysFromSchemas;
 const joiHandlers_1 = require("./joiHandlers");
-const traverseGeneric_1 = require("./traverseGeneric");
+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 getUniqueAllShemasKeys(schemas) {
+function getUniqueKeysFromSchemas(schemas) {
     const result = new Set();
     for (const schema of schemas) {
-        (0, traverseGeneric_1.traverseGeneric)(schema, [joiHandlers_1.joiSchemaHandler, joiHandlers_1.joiDescHandler], result);
+        (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__/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":""}

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