@powfix/core-js 0.15.0-beta-2 → 0.15.0-beta-4

package/dist/node/cjs/utils/UuidUtils.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UuidUtils = void 0;
+const uuid = __importStar(require("uuid"));
+function binaryToString(binary) {
+    return Buffer.from(binary).toString('hex');
+}
+class UuidUtils {
+    static v4() {
+        return uuid.v4();
+    }
+    static format(uuid) {
+        if (uuid.length === 32) {
+            // Without dash: ca23c587d7f84c76be59f53bbc9f91f8
+            return `${uuid.substring(0, 8)}-${uuid.substring(8, 12)}-${uuid.substring(12, 16)}-${uuid.substring(16, 20)}-${uuid.substring(20, 32)}`.toUpperCase();
+        }
+        else if (uuid.length === 36) {
+            // With dash: ca23c587-d7f8-4c76-be59-f53bbc9f91f8
+            return uuid.toUpperCase();
+        }
+        else {
+            // Unexpected uuid
+            console.warn('Unexpected uuid length', uuid);
+            return uuid;
+        }
+    }
+    static toString(binary) {
+        if (!binary)
+            return null;
+        return UuidUtils.format(binaryToString(binary));
+    }
+    static toBuffer(uuid) {
+        if (!uuid) {
+            return null;
+        }
+        return Buffer.from(uuid.replace(/-/g, ''), 'hex');
+    }
+    static isValidUUID(uuid) {
+        if (!uuid)
+            return false;
+        if (typeof uuid !== 'string')
+            return false;
+        return RegExp(/^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$/i).test(uuid);
+    }
+}
+exports.UuidUtils = UuidUtils;

package/dist/node/cjs/utils/Validator.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+class Validator {
+    static validate(value, options) {
+        value = value || '';
+        const validations = [];
+        const errors = [];
+        const { length } = value;
+        const spaceCount = (value.match(/\s/g) || []).length;
+        const numberCount = (value.match(/\d/g) || []).length;
+        const alphabetCount = (value.match(/[A-Za-z]/g) || []).length;
+        const alphabetLowerCaseCount = (value.match(/[a-z]/g) || []).length;
+        const alphabetUpperCaseCount = (value.match(/[A-Z]/g) || []).length;
+        const specialCount = (value.match(/[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/g) || []).length;
+        const startsWithNumber = /^\d/.test(value);
+        const startsWithAlphabet = /^[A-Za-z]/.test(value);
+        const startsWithSpecialCharacter = /^[~`!@#$%^&*()\-+={[}\]|\\:;"'<,>.?/]/.test(value);
+        // 최소 길이
+        if (options.minLength !== undefined && options.minLength > -1) {
+            validations.push(Validator.VALIDATION.MIN_LENGTH);
+            if (length < options.minLength) {
+                errors.push(Validator.VALIDATION.MIN_LENGTH);
+            }
+        }
+        // 최대 길이
+        if (options.maxLength !== undefined && options.maxLength > -1) {
+            validations.push(Validator.VALIDATION.MAX_LENGTH);
+            if (length > options.maxLength) {
+                errors.push(Validator.VALIDATION.MAX_LENGTH);
+            }
+        }
+        const validateMin = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value < option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        const validateMax = (option, value, validation) => {
+            if (option !== undefined && option > -1) {
+                validations.push(validation);
+                if (value > option) {
+                    errors.push(validation);
+                }
+            }
+        };
+        // 공백 개수
+        validateMin(options.spaceMinCount, spaceCount, Validator.VALIDATION.SPACE_MIN_COUNT);
+        validateMax(options.spaceMaxCount, spaceCount, Validator.VALIDATION.SPACE_MAX_COUNT);
+        // 숫자 개수
+        validateMin(options.numberMinCount, numberCount, Validator.VALIDATION.NUMBER_MIN_COUNT);
+        validateMax(options.numberMaxCount, numberCount, Validator.VALIDATION.NUMBER_MAX_COUNT);
+        // 알파벳 개수
+        validateMin(options.alphabetMinCount, alphabetCount, Validator.VALIDATION.ALPHABET_MIN_COUNT);
+        validateMax(options.alphabetMaxCount, alphabetCount, Validator.VALIDATION.ALPHABET_MAX_COUNT);
+        // 알파벳(소문자) 개수
+        validateMin(options.alphabetLowerCaseMinCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MIN_COUNT);
+        validateMax(options.alphabetLowerCaseMaxCount, alphabetLowerCaseCount, Validator.VALIDATION.ALPHABET_LOWER_CASE_MAX_COUNT);
+        // 알파벳(대문자) 개수
+        validateMin(options.alphabetUpperCaseMinCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MIN_COUNT);
+        validateMax(options.alphabetUpperCaseMaxCount, alphabetUpperCaseCount, Validator.VALIDATION.ALPHABET_UPPER_CASE_MAX_COUNT);
+        // 특수문자 개수
+        validateMin(options.specialCharacterMinCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MIN_COUNT);
+        validateMax(options.specialCharacterMaxCount, specialCount, Validator.VALIDATION.SPECIAL_CHARACTER_MAX_COUNT);
+        // 숫자로 시작
+        if (options.startsWithNumber) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
+            if (!startsWithNumber) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_NUMBER);
+            }
+        }
+        // 영문으로 시작
+        if (options.startsWithAlphabet) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
+            if (!startsWithAlphabet) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_ALPHABET);
+            }
+        }
+        // 특수문자로 시작
+        if (options.startsWithSpecialCharacter) {
+            validations.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+            if (!startsWithSpecialCharacter) {
+                errors.push(Validator.VALIDATION.STARTS_WITH_SPECIAL_CHARACTER);
+            }
+        }
+        return {
+            result: errors.length === 0,
+            validations,
+            passes: validations.filter(e => !errors.includes(e)),
+            errors,
+        };
+    }
+}
+exports.Validator = Validator;
+(function (Validator) {
+    let VALIDATION;
+    (function (VALIDATION) {
+        VALIDATION["MIN_LENGTH"] = "MIN_LENGTH";
+        VALIDATION["MAX_LENGTH"] = "MAX_LENGTH";
+        VALIDATION["SPACE_MIN_COUNT"] = "SPACE_MIN_COUNT";
+        VALIDATION["SPACE_MAX_COUNT"] = "SPACE_MAX_COUNT";
+        VALIDATION["NUMBER_MIN_COUNT"] = "NUMBER_MIN_COUNT";
+        VALIDATION["NUMBER_MAX_COUNT"] = "NUMBER_MAX_COUNT";
+        VALIDATION["ALPHABET_MIN_COUNT"] = "ALPHABET_MIN_COUNT";
+        VALIDATION["ALPHABET_MAX_COUNT"] = "ALPHABET_MAX_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MIN_COUNT"] = "ALPHABET_LOWER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_LOWER_CASE_MAX_COUNT"] = "ALPHABET_LOWER_CASE_MAX_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MIN_COUNT"] = "ALPHABET_UPPER_CASE_MIN_COUNT";
+        VALIDATION["ALPHABET_UPPER_CASE_MAX_COUNT"] = "ALPHABET_UPPER_CASE_MAX_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MIN_COUNT"] = "SPECIAL_CHARACTER_MIN_COUNT";
+        VALIDATION["SPECIAL_CHARACTER_MAX_COUNT"] = "SPECIAL_CHARACTER_MAX_COUNT";
+        VALIDATION["STARTS_WITH_ALPHABET"] = "STARTS_WITH_ALPHABET";
+        VALIDATION["STARTS_WITH_NUMBER"] = "STARTS_WITH_NUMBER";
+        VALIDATION["STARTS_WITH_SPECIAL_CHARACTER"] = "STARTS_WITH_SPECIAL_CHARACTER";
+    })(VALIDATION = Validator.VALIDATION || (Validator.VALIDATION = {}));
+})(Validator || (exports.Validator = Validator = {}));

package/dist/node/cjs/utils/global/between.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.between = void 0;
+const between = (value, from, to) => {
+    return value >= from && value <= to;
+};
+exports.between = between;

package/dist/node/cjs/utils/global/castArray.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castArray = castArray;
+function castArray(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/dist/node/cjs/utils/global/circularDistance.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circularDistance = circularDistance;
+function circularDistance(value, target, min, max) {
+    const range = max - min;
+    const from = value - min;
+    const to = target - min;
+    if (to >= from) {
+        return to - from;
+    }
+    else {
+        return range - from + to;
+    }
+}

package/dist/node/cjs/utils/global/fallbackIfEqual.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackIfEqual = fallbackIfEqual;
+function fallbackIfEqual(value, condition, fallback) {
+    if (typeof value === typeof condition && value === condition) {
+        return fallback;
+    }
+    return value;
+}

package/dist/node/cjs/utils/global/fallbackIfNull.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackIfNull = fallbackIfNull;
+const fallbackIfEqual_1 = require("./fallbackIfEqual");
+function fallbackIfNull(value, fallback) {
+    return (0, fallbackIfEqual_1.fallbackIfEqual)(value, null, fallback);
+}

package/dist/node/cjs/utils/global/fallbackIfUndefined.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fallbackIfUndefined = fallbackIfUndefined;
+const fallbackIfEqual_1 = require("./fallbackIfEqual");
+function fallbackIfUndefined(value, fallback) {
+    return (0, fallbackIfEqual_1.fallbackIfEqual)(value, undefined, fallback);
+}

package/dist/node/cjs/utils/global/firstNonNullish.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstNonNullish = firstNonNullish;
+function firstNonNullish(...args) {
+    if (args == null || !Array.isArray(args) || args.length === 0) {
+        return undefined;
+    }
+    if (args[0] != null) {
+        // Not Nullish
+        return args[0];
+    }
+    return firstNonNullish(...args.slice(1));
+}

package/dist/node/cjs/utils/global/flat.js

@@ -0,0 +1,117 @@
+"use strict";
+// flat.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = flatten;
+exports.unflatten = unflatten;
+function isBuffer(obj) {
+    return !!(obj &&
+        obj.constructor &&
+        typeof obj.constructor.isBuffer === 'function' &&
+        obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+function flatten(target, opts = {}) {
+    const delimiter = opts.delimiter || '.';
+    const maxDepth = opts.maxDepth;
+    const transformKey = opts.transformKey || keyIdentity;
+    const output = {};
+    function step(object, prev, currentDepth = 1) {
+        Object.keys(object).forEach((key) => {
+            const value = object[key];
+            const isarray = opts.safe && Array.isArray(value);
+            const type = Object.prototype.toString.call(value);
+            const isbuffer = isBuffer(value);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            const newKey = prev
+                ? `${prev}${delimiter}${transformKey(key)}`
+                : transformKey(key);
+            if (!isarray &&
+                !isbuffer &&
+                isobject &&
+                Object.keys(value).length &&
+                (!maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+        });
+    }
+    step(target);
+    return output;
+}
+function unflatten(target, opts = {}) {
+    const delimiter = opts.delimiter || '.';
+    const overwrite = opts.overwrite || false;
+    const transformKey = opts.transformKey || keyIdentity;
+    const result = {};
+    if (isBuffer(target) ||
+        Object.prototype.toString.call(target) !== '[object Object]') {
+        return target;
+    }
+    function getkey(key) {
+        const parsedKey = Number(key);
+        return isNaN(parsedKey) || key.indexOf('.') !== -1 || opts.object
+            ? key
+            : parsedKey;
+    }
+    function addKeys(keyPrefix, recipient, target) {
+        return Object.keys(target).reduce((res, key) => {
+            res[`${keyPrefix}${delimiter}${key}`] = target[key];
+            return res;
+        }, recipient);
+    }
+    function isEmpty(val) {
+        const type = Object.prototype.toString.call(val);
+        const isArray = type === '[object Array]';
+        const isObject = type === '[object Object]';
+        if (!val) {
+            return true;
+        }
+        else if (isArray) {
+            return !val.length;
+        }
+        else if (isObject) {
+            return !Object.keys(val).length;
+        }
+        return false;
+    }
+    const target2 = Object.keys(target).reduce((res, key) => {
+        const value = target[key];
+        const type = Object.prototype.toString.call(value);
+        const isObject = type === '[object Object]' || type === '[object Array]';
+        if (!isObject || isEmpty(value)) {
+            res[key] = value;
+            return res;
+        }
+        else {
+            return addKeys(key, res, flatten(value, opts));
+        }
+    }, {});
+    Object.keys(target2).forEach((key) => {
+        const split = key.split(delimiter).map(transformKey);
+        let key1 = getkey(split.shift());
+        let key2 = getkey(split[0]);
+        let recipient = result;
+        while (key2 !== undefined) {
+            if (key1 === '__proto__')
+                return;
+            const type = Object.prototype.toString.call(recipient[key1]);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            if (!overwrite && !isobject && typeof recipient[key1] !== 'undefined') {
+                return;
+            }
+            if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+                recipient[key1] =
+                    typeof key2 === 'number' && !opts.object ? [] : {};
+            }
+            recipient = recipient[key1];
+            if (split.length > 0) {
+                key1 = getkey(split.shift());
+                key2 = getkey(split[0]);
+            }
+        }
+        recipient[key1] = unflatten(target2[key], opts);
+    });
+    return result;
+}

package/dist/node/cjs/utils/global/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./between"), exports);
+__exportStar(require("./castArray"), exports);
+__exportStar(require("./circularDistance"), exports);
+__exportStar(require("./sleep"), exports);
+__exportStar(require("./fallbackIfEqual"), exports);
+__exportStar(require("./fallbackIfNull"), exports);
+__exportStar(require("./fallbackIfUndefined"), exports);
+__exportStar(require("./firstNonNullish"), exports);
+__exportStar(require("./flat"), exports);
+__exportStar(require("./processFirstNonNullish"), exports);
+__exportStar(require("./pureEnum"), exports);

package/dist/node/cjs/utils/global/processFirstNonNullish.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFirstNonNullish = processFirstNonNullish;
+const firstNonNullish_1 = require("./firstNonNullish");
+function processFirstNonNullish(processor, ...args) {
+    const fallback = (0, firstNonNullish_1.firstNonNullish)(...args);
+    if (fallback == null) {
+        return undefined;
+    }
+    return processor(fallback);
+}

package/dist/node/cjs/utils/global/pureEnum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pureEnum = pureEnum;
+exports.pureEnumKeys = pureEnumKeys;
+exports.pureEnumValues = pureEnumValues;
+function pureEnum(e) {
+    return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
+}
+function pureEnumKeys(e) {
+    return pureEnum(e).map(([key]) => key);
+}
+function pureEnumValues(e) {
+    return pureEnum(e).map(([, value]) => value);
+}

package/dist/node/cjs/utils/global/sleep.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+exports.sleep = sleep;

package/dist/node/cjs/utils/index.browser.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./global"), exports);
+__exportStar(require("./ArrayUtils"), exports);
+__exportStar(require("./AxiosUtils"), exports);
+__exportStar(require("./StringUtils"), exports);
+__exportStar(require("./UuidUtils"), exports);
+__exportStar(require("./BooleanUtils"), exports);
+__exportStar(require("./Calc"), exports);
+__exportStar(require("./CoordinateUtils"), exports);
+__exportStar(require("./DateUtils"), exports);
+__exportStar(require("./NumberUtils"), exports);
+__exportStar(require("./ObjectIdUtils"), exports);
+__exportStar(require("./Point3Utils"), exports);
+__exportStar(require("./RandomUtils"), exports);
+__exportStar(require("./Validator"), exports);
+__exportStar(require("./JuminNumberUtils"), exports);
+__exportStar(require("./Sequencer"), exports);
+__exportStar(require("./try-catch"), exports);

package/dist/node/cjs/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./index.browser"), exports);
+__exportStar(require("./nodejs"), exports);

package/dist/{server → node/cjs}/utils/nodejs/index.js

@@ -15,6 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequelizeUtils = void 0;
-__exportStar(require("./HookUtils.js"), exports);
-var index_js_1 = require("./sequelize-utils/index.js");
-Object.defineProperty(exports, "SequelizeUtils", { enumerable: true, get: function () { return index_js_1.SequelizeUtils; } });
+__exportStar(require("./HookUtils"), exports);
+var sequelize_utils_1 = require("./sequelize-utils");
+Object.defineProperty(exports, "SequelizeUtils", { enumerable: true, get: function () { return sequelize_utils_1.SequelizeUtils; } });

package/dist/{server → node/cjs}/utils/nodejs/sequelize-utils/SequelizeUtils.js

@@ -13,8 +13,8 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequelizeUtils = void 0;
 const sequelize_1 = require("sequelize");
-const UuidUtils_js_1 = require("../../UuidUtils.js");
-const index_js_1 = require("../../../constants/index.js");
+const UuidUtils_1 = require("../../UuidUtils");
+const constants_1 = require("../../../constants");
 class SequelizeUtils {
     static decimal2Number(value) {
         if (value === null || value === undefined) {
@@ -34,18 +34,18 @@ class SequelizeUtils {
                     if (value === null) {
                         return value;
                     }
-                    return UuidUtils_js_1.UuidUtils.toString(this.getDataValue(columnName));
+                    return UuidUtils_1.UuidUtils.toString(this.getDataValue(columnName));
                 },
                 set(uuid) {
-                    this.setDataValue(columnName, uuid === null ? null : UuidUtils_js_1.UuidUtils.toBuffer(uuid));
+                    this.setDataValue(columnName, uuid === null ? null : UuidUtils_1.UuidUtils.toBuffer(uuid));
                 } }, overrideOptions);
         }
         else {
             return Object.assign({ type: "binary(16)", get() {
-                    return UuidUtils_js_1.UuidUtils.toString(this.getDataValue(columnName));
+                    return UuidUtils_1.UuidUtils.toString(this.getDataValue(columnName));
                 },
                 set(uuid) {
-                    this.setDataValue(columnName, UuidUtils_js_1.UuidUtils.toBuffer(uuid));
+                    this.setDataValue(columnName, UuidUtils_1.UuidUtils.toBuffer(uuid));
                 } }, overrideOptions);
         }
     }
@@ -55,7 +55,7 @@ class SequelizeUtils {
                 if (value === null) {
                     return { [sequelize_1.Op.is]: value };
                 }
-                else if (value === index_js_1.NOT_NULL) {
+                else if (value === constants_1.NOT_NULL) {
                     return { [sequelize_1.Op.not]: null };
                 }
                 else {
@@ -71,5 +71,5 @@ SequelizeUtils.buildPrimaryUuidColumn = () => (Object.assign({}, SequelizeUtils.
     allowNull: false,
     primaryKey: true,
     unique: true,
-    defaultValue: () => UuidUtils_js_1.UuidUtils.toBuffer(UuidUtils_js_1.UuidUtils.v4()),
+    defaultValue: () => UuidUtils_1.UuidUtils.toBuffer(UuidUtils_1.UuidUtils.v4()),
 })));

package/dist/{server → node/cjs}/utils/nodejs/sequelize-utils/index.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequelizeUtils = void 0;
-var SequelizeUtils_js_1 = require("./SequelizeUtils.js");
-Object.defineProperty(exports, "SequelizeUtils", { enumerable: true, get: function () { return SequelizeUtils_js_1.SequelizeUtils; } });
+var SequelizeUtils_1 = require("./SequelizeUtils");
+Object.defineProperty(exports, "SequelizeUtils", { enumerable: true, get: function () { return SequelizeUtils_1.SequelizeUtils; } });

package/dist/node/cjs/utils/nodejs/sequelize-utils/types.js

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

package/dist/node/cjs/utils/try-catch/TryCatch.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TryCatch = void 0;
+/**
+ * Provides a utility class for handling synchronous and asynchronous operations with a consistent try-catch pattern.
+ * It returns a tuple where the first element is the error (or null on success) and the second element is the result (or undefined on error).
+ */
+class TryCatch {
+    /**
+     * Executes a synchronous function within a try-catch block.
+     * @template T The return type of the function.
+     * @template E The type of the error that might be thrown (defaults to Error).
+     * @param fn The synchronous function to execute.
+     *@param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the result of the function and an error (null if successful).
+     */
+    static function(fn, disableLogging) {
+        try {
+            return [
+                null,
+                fn(),
+            ];
+        }
+        catch (e) {
+            if (!disableLogging) {
+                console.error("ERROR in TryCatch: ", e);
+            }
+            if (e == null) {
+                e = new Error("Unknown error");
+            }
+            return [
+                e,
+                undefined,
+            ];
+        }
+    }
+    /**
+     * Executes an asynchronous function (Promise) within a try-catch block.
+     * @template T The resolved value type of the Promise.
+     * @template E The type of the error that might be rejected (defaults to Error).
+     * @param fn The Promise to await.
+     * @param disableLogging console.error is default way of logging on error. You can disable it by setting it true
+     * @returns A tuple containing the resolved value of the Promise and an error (null if successful).
+     */
+    static asyncFunction(fn, disableLogging) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield fn;
+                return [
+                    null,
+                    data,
+                ];
+            }
+            catch (e) {
+                if (!disableLogging) {
+                    console.error("ERROR in TryCatch: ", e);
+                }
+                if (e == null) {
+                    e = new Error("Unknown error");
+                }
+                return [
+                    e,
+                    undefined,
+                ];
+            }
+        });
+    }
+}
+exports.TryCatch = TryCatch;