@decaf-ts/decorator-validation 1.5.5 → 1.5.7

package/lib/model/decorators.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = model;
+exports.hashedBy = hashedBy;
+exports.serializedBy = serializedBy;
+const construction_1 = require("./construction");
+const constants_1 = require("../utils/constants");
+const Model_1 = require("./Model");
+const reflection_1 = require("@decaf-ts/reflection");
+/**
+ * @summary Defines a class as a Model class
+ * @description
+ *
+ * - Registers the class under the model registry so it can be easily rebuilt;
+ * - Overrides the class constructor;
+ * - Runs the global {@link ModelBuilderFunction} if defined;
+ * - Runs the optional {@link InstanceCallback} if provided;
+ *
+ * @param {InstanceCallback} [instanceCallback] optional callback that will be called with the instance upon instantiation. defaults to undefined
+ *
+ * @function model
+ *
+ * @memberOf module:decorator-validation.Model
+ *
+ */
+function model(instanceCallback) {
+    return ((original) => {
+        // the new constructor behaviour
+        const newConstructor = function (...args) {
+            const instance = (0, construction_1.construct)(original, ...args);
+            (0, construction_1.bindModelPrototype)(instance);
+            // run a builder function if defined with the first argument (The ModelArg)
+            const builder = Model_1.Model.getBuilder();
+            if (builder)
+                builder(instance, args.length ? args[0] : undefined);
+            (0, reflection_1.metadata)(Model_1.Model.key(constants_1.ModelKeys.MODEL), original.name)(instance.constructor);
+            if (instanceCallback)
+                instanceCallback(instance, ...args);
+            return instance;
+        };
+        // copy prototype so instanceof operator still works
+        newConstructor.prototype = original.prototype;
+        // Sets the proper constructor name for type verification
+        Object.defineProperty(newConstructor, "name", {
+            writable: false,
+            enumerable: true,
+            configurable: false,
+            value: original.prototype.constructor.name,
+        });
+        (0, reflection_1.metadata)(Model_1.Model.key(constants_1.ModelKeys.MODEL), original.name)(original);
+        Model_1.Model.register(newConstructor, original.name);
+        // return new constructor (will override original)
+        return newConstructor;
+    });
+}
+function hashedBy(algorithm, ...args) {
+    return (0, reflection_1.metadata)(Model_1.Model.key(constants_1.ModelKeys.HASHING), {
+        algorithm: algorithm,
+        args: args,
+    });
+}
+function serializedBy(serializer, ...args) {
+    return (0, reflection_1.metadata)(Model_1.Model.key(constants_1.ModelKeys.SERIALIZATION), {
+        serializer: serializer,
+        args: args,
+    });
+}

package/lib/{validation/index.cjs → model/index.js}

@@ -14,9 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Validators/index.cjs"), exports);
-__exportStar(require("./decorators.cjs"), exports);
-__exportStar(require("./types.cjs"), exports);
-__exportStar(require("./Validation.cjs"), exports);
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy92YWxpZGF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwrQ0FBNkI7QUFDN0IsK0NBQTZCO0FBQzdCLDBDQUF3QjtBQUN4QiwrQ0FBNkIiLCJmaWxlIjoidmFsaWRhdGlvbi9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL1ZhbGlkYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlY29yYXRvcnNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9WYWxpZGF0aW9uXCI7XG4iXX0=
+__exportStar(require("./constants"), exports);
+__exportStar(require("./construction"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./Model"), exports);
+__exportStar(require("./ModelErrorDefinition"), exports);
+__exportStar(require("./Registry"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./validation"), exports);

package/lib/model/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/model/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPropertyModel = isPropertyModel;
+exports.isModel = isModel;
+const constants_1 = require("../utils/constants");
+const Model_1 = require("./Model");
+function isPropertyModel(target, attribute) {
+    if (isModel(target[attribute]))
+        return true;
+    const metadata = Reflect.getMetadata(constants_1.ModelKeys.TYPE, target, attribute);
+    return Model_1.Model.get(metadata.name) ? metadata.name : undefined;
+}
+/**
+ * @summary For Serialization/deserialization purposes.
+ * @description Reads the {@link ModelKeys.ANCHOR} property of a {@link Model} to discover the class to instantiate
+ *
+ * @function isModel
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function isModel(target) {
+    try {
+        return target instanceof Model_1.Model || !!Model_1.Model.getMetadata(target);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        return false;
+    }
+}

package/lib/model/validation.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = validate;
+const ModelErrorDefinition_1 = require("./ModelErrorDefinition");
+const reflection_1 = require("@decaf-ts/reflection");
+const constants_1 = require("../utils/constants");
+const strings_1 = require("../utils/strings");
+const constants_2 = require("./constants");
+const Validation_1 = require("../validation/Validation");
+const constants_3 = require("../validation/Validators/constants");
+const utils_1 = require("./utils");
+/**
+ * @summary Analyses the decorations of the properties and validates the obj according to them
+ *
+ * @typedef T extends Model
+ * @prop {T} obj Model object to validate
+ * @prop {string[]} [propsToIgnore] object properties to ignore in the validation
+ *
+ * @function validate
+ * @memberOf module:decorator-validation.Validation
+ * @category Validation
+ */
+function validate(obj, ...propsToIgnore) {
+    const decoratedProperties = [];
+    for (const prop in obj)
+        if (Object.prototype.hasOwnProperty.call(obj, prop) &&
+            propsToIgnore.indexOf(prop) === -1)
+            decoratedProperties.push(reflection_1.Reflection.getPropertyDecorators(constants_3.ValidationKeys.REFLECT, obj, prop));
+    let result = undefined;
+    for (const decoratedProperty of decoratedProperties) {
+        const { prop, decorators } = decoratedProperty;
+        if (!decorators || !decorators.length)
+            continue;
+        const defaultTypeDecorator = decorators[0];
+        // tries to find any type decorators or other decorators that already enforce type (the ones with the allowed types property defined). if so, skip the default type verification
+        if (decorators.find((d) => {
+            if (d.key === constants_3.ValidationKeys.TYPE)
+                return true;
+            return !!d.props.types?.find((t) => t === defaultTypeDecorator.props.name);
+        })) {
+            decorators.shift(); // remove the design:type decorator, since the type will already be checked
+        }
+        let errs = undefined;
+        for (const decorator of decorators) {
+            const validator = Validation_1.Validation.get(decorator.key);
+            if (!validator) {
+                throw new Error(`Missing validator for ${decorator.key}`);
+            }
+            const decoratorProps = decorator.key === constants_1.ModelKeys.TYPE
+                ? [decorator.props]
+                : (decorator.props || {});
+            const err = validator.hasErrors(obj[prop.toString()], decoratorProps);
+            if (err) {
+                errs = errs || {};
+                errs[decorator.key] = err;
+            }
+        }
+        if (errs) {
+            result = result || {};
+            result[decoratedProperty.prop.toString()] = errs;
+        }
+    }
+    // tests nested classes
+    for (const prop of Object.keys(obj).filter((k) => !result || !result[k])) {
+        let err;
+        // if a nested Model
+        const allDecorators = reflection_1.Reflection.getPropertyDecorators(constants_3.ValidationKeys.REFLECT, obj, prop).decorators;
+        const decorators = reflection_1.Reflection.getPropertyDecorators(constants_3.ValidationKeys.REFLECT, obj, prop).decorators.filter((d) => [constants_1.ModelKeys.TYPE, constants_3.ValidationKeys.TYPE].indexOf(d.key) !== -1);
+        if (!decorators || !decorators.length)
+            continue;
+        const dec = decorators.pop();
+        const clazz = dec.props.name
+            ? [dec.props.name]
+            : Array.isArray(dec.props.customTypes)
+                ? dec.props.customTypes
+                : [dec.props.customTypes];
+        const reserved = Object.values(constants_2.ReservedModels).map((v) => v.toLowerCase());
+        for (const c of clazz) {
+            if (reserved.indexOf(c.toLowerCase()) === -1) {
+                const typeDecoratorKey = Array.isArray(obj[prop])
+                    ? constants_3.ValidationKeys.LIST
+                    : constants_3.ValidationKeys.TYPE;
+                const types = allDecorators.find((d) => d.key === typeDecoratorKey) || {};
+                let allowedTypes = [];
+                if (types && types.props) {
+                    const customTypes = Array.isArray(obj[prop])
+                        ? types.props.class
+                        : types.props.customTypes;
+                    if (customTypes)
+                        allowedTypes = Array.isArray(customTypes)
+                            ? customTypes.map((t) => `${t}`.toLowerCase())
+                            : [customTypes.toLowerCase()];
+                }
+                const validate = (prop, value) => {
+                    if (typeof value === "object" || typeof value === "function")
+                        return (0, utils_1.isModel)(value)
+                            ? value.hasErrors()
+                            : allowedTypes.includes(typeof value)
+                                ? undefined
+                                : "Value has no validatable type";
+                };
+                switch (c) {
+                    case Array.name:
+                    case Set.name:
+                        if (allDecorators.length) {
+                            const listDec = allDecorators.find((d) => d.key === constants_3.ValidationKeys.LIST);
+                            if (listDec) {
+                                err = (c === Array.name
+                                    ? obj[prop]
+                                    : // If it's a Set
+                                        obj[prop].values())
+                                    .map((v) => validate(prop, v))
+                                    .filter((e) => !!e);
+                                if (!err?.length) {
+                                    // if the result is an empty list...
+                                    err = undefined;
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        try {
+                            if (obj[prop])
+                                err = validate(prop, obj[prop]);
+                        }
+                        catch (e) {
+                            console.warn((0, strings_1.sf)("Model should be validatable but its not: " + e));
+                        }
+                }
+            }
+            if (err) {
+                result = result || {};
+                result[prop] = err;
+            }
+        }
+    }
+    return result ? new ModelErrorDefinition_1.ModelErrorDefinition(result) : undefined;
+}

package/lib/utils/constants.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelKeys = void 0;
+/**
+ * @summary Defines the various Model keys used for reflection
+ *
+ * @property {string} REFLECT prefix to all other keys
+ * @property {string} TYPE type key
+ * @property {string} PARAMS method params key
+ * @property {string} RETURN method return key
+ * @property {string} MODEL model key
+ * @property {string} ANCHOR anchor key. will serve as a ghost property in the model
+ *
+ * @constant ModelKeys
+ * @memberOf module:decorator-validation.Model
+ * @category Model
+ */
+var ModelKeys;
+(function (ModelKeys) {
+    ModelKeys["REFLECT"] = "decaf.model.";
+    ModelKeys["TYPE"] = "design:type";
+    ModelKeys["PARAMS"] = "design:paramtypes";
+    ModelKeys["RETURN"] = "design:returntype";
+    ModelKeys["MODEL"] = "model";
+    ModelKeys["ANCHOR"] = "__model";
+    ModelKeys["CONSTRUCTION"] = "constructed-by";
+    ModelKeys["ATTRIBUTE"] = "__attributes";
+    ModelKeys["HASHING"] = "hashing";
+    ModelKeys["SERIALIZATION"] = "serialization";
+})(ModelKeys || (exports.ModelKeys = ModelKeys = {}));

package/lib/utils/dates.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFromFormat = dateFromFormat;
+exports.bindDateToString = bindDateToString;
+exports.isValidDate = isValidDate;
+exports.twoDigitPad = twoDigitPad;
+exports.formatDate = formatDate;
+exports.parseDate = parseDate;
+require("reflect-metadata");
+const constants_1 = require("../validation/Validators/constants");
+const strings_1 = require("./strings");
+/**
+ * @summary Reverses the process from {@link formatDate}
+ *
+ * @param {string} date the date string to be converted back into date
+ * @param {string} format the date format
+ * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)
+ *
+ * @function dateFromFormat
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+function dateFromFormat(date, format) {
+    let formatRegexp = format;
+    // Hour
+    if (formatRegexp.match(/hh/))
+        formatRegexp = formatRegexp.replace("hh", "(?<hour>\\d{2})");
+    else if (formatRegexp.match(/h/))
+        formatRegexp = formatRegexp.replace("h", "(?<hour>\\d{1,2})");
+    else if (formatRegexp.match(/HH/))
+        formatRegexp = formatRegexp.replace("HH", "(?<hour>\\d{2})");
+    else if (formatRegexp.match(/H/))
+        formatRegexp = formatRegexp.replace("H", "(?<hour>\\d{1,2})");
+    // Minutes
+    if (formatRegexp.match(/mm/))
+        formatRegexp = formatRegexp.replace("mm", "(?<minutes>\\d{2})");
+    else if (formatRegexp.match(/m/))
+        formatRegexp = formatRegexp.replace("m", "(?<minutes>\\d{1,2})");
+    // Seconds
+    if (formatRegexp.match(/ss/))
+        formatRegexp = formatRegexp.replace("ss", "(?<seconds>\\d{2})");
+    else if (formatRegexp.match(/s/))
+        formatRegexp = formatRegexp.replace("s", "(?<seconds>\\d{1,2})");
+    // Day
+    if (formatRegexp.match(/dd/))
+        formatRegexp = formatRegexp.replace("dd", "(?<day>\\d{2})");
+    else if (formatRegexp.match(/d/))
+        formatRegexp = formatRegexp.replace("d", "(?<day>\\d{1,2})");
+    // Day Of Week
+    if (formatRegexp.match(/EEEE/))
+        formatRegexp = formatRegexp.replace("EEEE", "(?<dayofweek>\\w+)");
+    // eslint-disable-next-line no-dupe-else-if
+    else if (formatRegexp.match(/EEEE/))
+        formatRegexp = formatRegexp.replace("EEE", "(?<dayofweek>\\w+)");
+    // Year
+    if (formatRegexp.match(/yyyy/))
+        formatRegexp = formatRegexp.replace("yyyy", "(?<year>\\d{4})");
+    else if (formatRegexp.match(/yy/))
+        formatRegexp = formatRegexp.replace("yy", "(?<year>\\d{2})");
+    // Month
+    if (formatRegexp.match(/MMMM/))
+        formatRegexp = formatRegexp.replace("MMMM", "(?<monthname>\\w+)");
+    else if (formatRegexp.match(/MMM/))
+        formatRegexp = formatRegexp.replace("MMM", "(?<monthnamesmall>\\w+)");
+    if (formatRegexp.match(/MM/))
+        formatRegexp = formatRegexp.replace("MM", "(?<month>\\d{2})");
+    else if (formatRegexp.match(/M/))
+        formatRegexp = formatRegexp.replace("M", "(?<month>\\d{1,2})");
+    // Milis and Am Pm
+    formatRegexp = formatRegexp
+        .replace("S", "(?<milis>\\d{1,3})")
+        .replace("aaa", "(?<ampm>\\w{2})");
+    const regexp = new RegExp(formatRegexp, "g");
+    const match = regexp.exec(date);
+    if (!match || !match.groups)
+        return new Date(date);
+    const safeParseInt = function (n) {
+        if (!n)
+            return 0;
+        const result = parseInt(n);
+        return isNaN(result) ? 0 : result;
+    };
+    const year = safeParseInt(match.groups.year);
+    const day = safeParseInt(match.groups.day);
+    const amPm = match.groups.ampm;
+    let hour = safeParseInt(match.groups.hour);
+    if (amPm)
+        hour = amPm === "PM" ? hour + 12 : hour;
+    const minutes = safeParseInt(match.groups.minutes);
+    const seconds = safeParseInt(match.groups.seconds);
+    const ms = safeParseInt(match.groups.milis);
+    const monthName = match.groups.monthname;
+    const monthNameSmall = match.groups.monthnamesmall;
+    let month = match.groups.month;
+    if (monthName)
+        month = constants_1.MONTH_NAMES.indexOf(monthName);
+    else if (monthNameSmall) {
+        const m = constants_1.MONTH_NAMES.find((m) => m.toLowerCase().startsWith(monthNameSmall.toLowerCase()));
+        if (!m)
+            return new Date(date);
+        month = constants_1.MONTH_NAMES.indexOf(m);
+    }
+    else
+        month = safeParseInt(`${month}`);
+    return new Date(year, month - 1, day, hour, minutes, seconds, ms);
+}
+/**
+ * @summary Binds a date format to a string
+ * @param {Date} [date]
+ * @param {string} [format]
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Utilities
+ */
+function bindDateToString(date, format) {
+    if (!date)
+        return;
+    const func = () => formatDate(date, format);
+    Object.defineProperty(date, "toISOString", {
+        enumerable: false,
+        configurable: false,
+        value: func,
+    });
+    Object.defineProperty(date, "toString", {
+        enumerable: false,
+        configurable: false,
+        value: func,
+    });
+    // Object.setPrototypeOf(date, Date.prototype);
+    return date;
+}
+/**
+ * @summary Helper function to be used instead of instanceOf Date
+ * @param date
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Validation
+ */
+function isValidDate(date) {
+    return (date &&
+        Object.prototype.toString.call(date) === "[object Date]" &&
+        !Number.isNaN(date));
+}
+/**
+ * @summary Util function to pad numbers
+ * @param {number} num
+ *
+ * @return {string}
+ *
+ * @function twoDigitPad
+ * @memberOf module:decorator-validation.Utils.Format
+ * @category Format
+ */
+function twoDigitPad(num) {
+    return num < 10 ? "0" + num : num.toString();
+}
+/**
+ * @summary Date Format Handling
+ * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}
+ *
+ * <pre>
+ *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
+ *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
+ *      You can display date, time, AM/PM, etc.
+ *
+ *      Date and Time Patterns
+ *      yy = 2-digit year; yyyy = full year
+ *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
+ *      EEEE = full weekday name; EEE = short weekday name
+ *      d = digit day; dd = 2-digit day
+ *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
+ *      m = minutes; mm = 2-digit minutes; aaa = AM/PM
+ *      s = seconds; ss = 2-digit seconds
+ *      S = miliseconds
+ * </pre>
+ *
+ * @param {Date} date
+ * @param {string} [patternStr] defaults to 'yyyy/MM/dd'
+ * @return {string} the formatted date
+ *
+ * @function formatDate
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+function formatDate(date, patternStr = "yyyy/MM/dd") {
+    const day = date.getDate(), month = date.getMonth(), year = date.getFullYear(), hour = date.getHours(), minute = date.getMinutes(), second = date.getSeconds(), miliseconds = date.getMilliseconds(), h = hour % 12, hh = twoDigitPad(h), HH = twoDigitPad(hour), mm = twoDigitPad(minute), ss = twoDigitPad(second), aaa = hour < 12 ? "AM" : "PM", EEEE = constants_1.DAYS_OF_WEEK_NAMES[date.getDay()], EEE = EEEE.substr(0, 3), dd = twoDigitPad(day), M = month + 1, MM = twoDigitPad(M), MMMM = constants_1.MONTH_NAMES[month], MMM = MMMM.substr(0, 3), yyyy = year + "", yy = yyyy.substr(2, 2);
+    // checks to see if month name will be used
+    patternStr = patternStr
+        .replace("hh", hh)
+        .replace("h", h.toString())
+        .replace("HH", HH)
+        .replace("H", hour.toString())
+        .replace("mm", mm)
+        .replace("m", minute.toString())
+        .replace("ss", ss)
+        .replace("s", second.toString())
+        .replace("S", miliseconds.toString())
+        .replace("dd", dd)
+        .replace("d", day.toString())
+        .replace("EEEE", EEEE)
+        .replace("EEE", EEE)
+        .replace("yyyy", yyyy)
+        .replace("yy", yy)
+        .replace("aaa", aaa);
+    if (patternStr.indexOf("MMM") > -1) {
+        patternStr = patternStr.replace("MMMM", MMMM).replace("MMM", MMM);
+    }
+    else {
+        patternStr = patternStr.replace("MM", MM).replace("M", M.toString());
+    }
+    return patternStr;
+}
+/**
+ * @summary Parses a date from a specified format
+ * @param {string} format
+ * @param {string | Date | number} [v]
+ * @memberOf module:decorator-validation.Utils.Dates
+ * @category Format
+ */
+function parseDate(format, v) {
+    let value = undefined;
+    if (!v)
+        return undefined;
+    if (v instanceof Date)
+        try {
+            value = dateFromFormat(formatDate(v, format), format);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            throw new Error((0, strings_1.sf)("Could not convert date {0} to format: {1}", v.toString(), format));
+        }
+    else if (typeof v === "string") {
+        value = dateFromFormat(v, format);
+    }
+    else if (typeof v === "number") {
+        const d = new Date(v);
+        value = dateFromFormat(formatDate(d, format), format);
+    }
+    else if (isValidDate(v)) {
+        try {
+            const d = new Date(v);
+            value = dateFromFormat(formatDate(d, format), format);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            throw new Error((0, strings_1.sf)("Could not convert date {0} to format: {1}", v, format));
+        }
+    }
+    else {
+        throw new Error(`Invalid value provided ${v}`);
+    }
+    return bindDateToString(value, format);
+}

package/lib/utils/decorators.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prop = prop;
+exports.propMetadata = propMetadata;
+const reflection_1 = require("@decaf-ts/reflection");
+const constants_1 = require("./constants");
+function prop(key = constants_1.ModelKeys.ATTRIBUTE) {
+    return (model, propertyKey) => {
+        let props;
+        if (Object.prototype.hasOwnProperty.call(model, key)) {
+            props = model[key];
+        }
+        else {
+            props = model[key] = [];
+        }
+        if (!props.includes(propertyKey))
+            props.push(propertyKey);
+    };
+}
+function propMetadata(key, value) {
+    return (0, reflection_1.apply)(prop(), (0, reflection_1.metadata)(key, value));
+}

package/lib/utils/hashing.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hashing = exports.DefaultHashingMethod = void 0;
+exports.hashCode = hashCode;
+exports.hashSerialization = hashSerialization;
+exports.hashObj = hashObj;
+const serialization_1 = require("./serialization");
+/**
+ * @summary Mimics Java's String's Hash implementation
+ *
+ * @param {string | number | symbol | Date} obj
+ * @return {number} hash value of obj
+ *
+ * @function hashCode
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+function hashCode(obj) {
+    obj = String(obj);
+    let hash = 0;
+    for (let i = 0; i < obj.length; i++) {
+        const character = obj.charCodeAt(i);
+        hash = (hash << 5) - hash + character;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString();
+}
+/**
+ * @summary Hashes an object serializing it and then hashing the string
+ * @description The Serialization algorithm used by default (JSON.stringify)
+ * is not deterministic and should not be used for hashing
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashSerialization
+ * @memberOf module:decorator-validation.Utils.Hashing
+ *
+ * @category Hashing
+ */
+function hashSerialization(obj) {
+    return hashCode(serialization_1.Serialization.serialize(obj));
+}
+/**
+ * @summary Hashes an object by combining the hash of all its properties
+ *
+ * @param {Record<string, any>} obj
+ * @return {string} the resulting hash
+ *
+ * @function hashObj
+ * @memberOf module:decorator-validation.Utils.Hashing
+ * @category Hashing
+ */
+function hashObj(obj) {
+    const hashReducer = function (h, el) {
+        const elHash = hashFunction(el);
+        if (typeof elHash === "string")
+            return hashFunction((h || "") + hashFunction(el));
+        h = h || 0;
+        h = (h << 5) - h + elHash;
+        return h & h;
+    };
+    const func = hashCode;
+    const hashFunction = function (value) {
+        if (typeof value === "undefined")
+            return "";
+        if (["string", "number", "symbol"].indexOf(typeof value) !== -1)
+            return func(value.toString());
+        if (value instanceof Date)
+            return func(value.getTime());
+        if (Array.isArray(value))
+            return value.reduce(hashReducer, undefined);
+        return Object.values(value).reduce(hashReducer, undefined);
+    };
+    const result = Object.values(obj).reduce(hashReducer, 0);
+    return (typeof result === "number" ? Math.abs(result) : result).toString();
+}
+exports.DefaultHashingMethod = "default";
+class Hashing {
+    static { this.current = exports.DefaultHashingMethod; }
+    static { this.cache = {
+        default: hashObj,
+    }; }
+    constructor() { }
+    static get(key) {
+        if (key in this.cache)
+            return this.cache[key];
+        throw new Error(`No hashing method registered under ${key}`);
+    }
+    static register(key, func, setDefault = false) {
+        if (key in this.cache)
+            throw new Error(`Hashing method ${key} already registered`);
+        this.cache[key] = func;
+        if (setDefault)
+            this.current = key;
+    }
+    static hash(obj, method, ...args) {
+        if (!method)
+            return this.get(this.current)(obj, ...args);
+        return this.get(method)(obj, ...args);
+    }
+    static setDefault(method) {
+        this.current = this.get(method);
+    }
+}
+exports.Hashing = Hashing;