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

package/dist/node/esm/utils/Validator.mjs

@@ -0,0 +1,114 @@
+export 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,
+        };
+    }
+}
+(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 || (Validator = {}));

package/dist/node/esm/utils/global/between.mjs

@@ -0,0 +1,3 @@
+export const between = (value, from, to) => {
+    return value >= from && value <= to;
+};

package/dist/node/esm/utils/global/castArray.mjs

@@ -0,0 +1,3 @@
+export function castArray(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/dist/node/esm/utils/global/circularDistance.mjs

@@ -0,0 +1,11 @@
+export 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/esm/utils/global/fallbackIfEqual.mjs

@@ -0,0 +1,6 @@
+export function fallbackIfEqual(value, condition, fallback) {
+    if (typeof value === typeof condition && value === condition) {
+        return fallback;
+    }
+    return value;
+}

package/dist/node/esm/utils/global/fallbackIfNull.mjs

@@ -0,0 +1,4 @@
+import { fallbackIfEqual } from "./fallbackIfEqual.mjs";
+export function fallbackIfNull(value, fallback) {
+    return fallbackIfEqual(value, null, fallback);
+}

package/dist/node/esm/utils/global/fallbackIfUndefined.mjs

@@ -0,0 +1,4 @@
+import { fallbackIfEqual } from "./fallbackIfEqual.mjs";
+export function fallbackIfUndefined(value, fallback) {
+    return fallbackIfEqual(value, undefined, fallback);
+}

package/dist/node/esm/utils/global/firstNonNullish.mjs

@@ -0,0 +1,10 @@
+export 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/esm/utils/global/flat.mjs

@@ -0,0 +1,113 @@
+// flat.ts
+function isBuffer(obj) {
+    return !!(obj &&
+        obj.constructor &&
+        typeof obj.constructor.isBuffer === 'function' &&
+        obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+export 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;
+}
+export 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/esm/utils/global/index.mjs

@@ -0,0 +1,11 @@
+export * from './between.mjs';
+export * from './castArray.mjs';
+export * from './circularDistance.mjs';
+export * from './sleep.mjs';
+export * from './fallbackIfEqual.mjs';
+export * from './fallbackIfNull.mjs';
+export * from './fallbackIfUndefined.mjs';
+export * from './firstNonNullish.mjs';
+export * from './flat.mjs';
+export * from './processFirstNonNullish.mjs';
+export * from './pureEnum.mjs';

package/dist/node/esm/utils/global/processFirstNonNullish.mjs

@@ -0,0 +1,8 @@
+import { firstNonNullish } from "./firstNonNullish.mjs";
+export function processFirstNonNullish(processor, ...args) {
+    const fallback = firstNonNullish(...args);
+    if (fallback == null) {
+        return undefined;
+    }
+    return processor(fallback);
+}

package/dist/node/esm/utils/global/pureEnum.mjs

@@ -0,0 +1,9 @@
+export function pureEnum(e) {
+    return Object.entries(e).filter(([key, value]) => !/^-?\d+$/g.test(key) && typeof value !== 'function');
+}
+export function pureEnumKeys(e) {
+    return pureEnum(e).map(([key]) => key);
+}
+export function pureEnumValues(e) {
+    return pureEnum(e).map(([, value]) => value);
+}

package/dist/node/esm/utils/global/sleep.mjs

@@ -0,0 +1 @@
+export const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

package/dist/node/esm/utils/index.browser.mjs

@@ -0,0 +1,17 @@
+export * from './global/index.mjs';
+export * from './ArrayUtils.mjs';
+export * from './AxiosUtils.mjs';
+export * from './StringUtils.mjs';
+export * from './UuidUtils.mjs';
+export * from './BooleanUtils.mjs';
+export * from './Calc.mjs';
+export * from './CoordinateUtils.mjs';
+export * from './DateUtils.mjs';
+export * from './NumberUtils.mjs';
+export * from './ObjectIdUtils.mjs';
+export * from './Point3Utils.mjs';
+export * from './RandomUtils.mjs';
+export * from './Validator.mjs';
+export * from './JuminNumberUtils.mjs';
+export * from './Sequencer.mjs';
+export * from './try-catch/index.mjs';

package/dist/node/esm/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from './index.browser.mjs';
+export * from './nodejs/index.mjs';

package/dist/node/esm/utils/nodejs/HookUtils.mjs

@@ -0,0 +1,26 @@
+export class HookUtils {
+    static getFkChanges(pFkValue, cFkValue) {
+        const results = { pFkValue: null, cFkValue: null };
+        if (pFkValue !== undefined && cFkValue !== undefined) {
+            if (pFkValue !== cFkValue) {
+                if (pFkValue !== null) {
+                    results.pFkValue = pFkValue;
+                }
+            }
+        }
+        if (cFkValue !== null && cFkValue !== undefined) {
+            results.cFkValue = cFkValue;
+        }
+        return results;
+    }
+    static makeModelHooks(model, fns) {
+        return [
+            { model, hookType: 'afterCreate', fn: fns.create },
+            { model, hookType: 'afterBulkCreate', fn: fns.create },
+            { model, hookType: 'afterUpdate', fn: fns.update },
+            { model, hookType: 'afterBulkUpdate', fn: fns.update },
+            { model, hookType: 'afterDestroy', fn: fns.destroy },
+            { model, hookType: 'afterBulkDestroy', fn: fns.destroy },
+        ];
+    }
+}

package/dist/node/esm/utils/nodejs/index.mjs

@@ -0,0 +1,2 @@
+export * from './HookUtils.mjs';
+export { SequelizeUtils } from './sequelize-utils/index.mjs';

package/dist/node/esm/utils/nodejs/sequelize-utils/SequelizeUtils.mjs

@@ -0,0 +1,71 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { Op } from "sequelize";
+import { UuidUtils } from "../../UuidUtils.mjs";
+import { NOT_NULL } from "../../../constants/index.mjs";
+export class SequelizeUtils {
+    static decimal2Number(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        const parsed = Number(value);
+        if (isNaN(parsed)) {
+            throw new Error(`value(typeof=${typeof value}, value=${value}) iNaN(is not number)`);
+        }
+        return parsed;
+    }
+    static buildUuidColumn(options) {
+        const { columnName } = options, overrideOptions = __rest(options, ["columnName"]);
+        if (overrideOptions.allowNull) {
+            return Object.assign({ type: "binary(16)", get() {
+                    const value = this.getDataValue(columnName);
+                    if (value === null) {
+                        return value;
+                    }
+                    return UuidUtils.toString(this.getDataValue(columnName));
+                },
+                set(uuid) {
+                    this.setDataValue(columnName, uuid === null ? null : UuidUtils.toBuffer(uuid));
+                } }, overrideOptions);
+        }
+        else {
+            return Object.assign({ type: "binary(16)", get() {
+                    return UuidUtils.toString(this.getDataValue(columnName));
+                },
+                set(uuid) {
+                    this.setDataValue(columnName, UuidUtils.toBuffer(uuid));
+                } }, overrideOptions);
+        }
+    }
+    static getNullableArrayFilter(arr) {
+        return {
+            [Op.or]: arr.map(value => {
+                if (value === null) {
+                    return { [Op.is]: value };
+                }
+                else if (value === NOT_NULL) {
+                    return { [Op.not]: null };
+                }
+                else {
+                    return { [Op.eq]: value };
+                }
+            })
+        };
+    }
+}
+SequelizeUtils.buildPrimaryUuidColumn = () => (Object.assign({}, SequelizeUtils.buildUuidColumn({
+    columnName: "uuid",
+    allowNull: false,
+    primaryKey: true,
+    unique: true,
+    defaultValue: () => UuidUtils.toBuffer(UuidUtils.v4()),
+})));

package/dist/node/esm/utils/nodejs/sequelize-utils/index.mjs

@@ -0,0 +1 @@
+export { SequelizeUtils } from './SequelizeUtils.mjs';

package/dist/node/esm/utils/nodejs/sequelize-utils/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/utils/try-catch/TryCatch.mjs

@@ -0,0 +1,74 @@
+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());
+    });
+};
+/**
+ * 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).
+ */
+export 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,
+                ];
+            }
+        });
+    }
+}

package/dist/node/esm/utils/try-catch/index.mjs

@@ -0,0 +1 @@
+export * from "./TryCatch.mjs";

package/dist/node/types/constants/index.browser.d.ts

@@ -0,0 +1,6 @@
+export * from './COORDINATE';
+export * from './CRUD';
+export * from './DATE';
+export * from './DISTANCE';
+export * from './DURATION';
+export * from './NOT_NULL';

package/dist/node/types/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.browser';
+export * from './nodejs';

package/dist/node/types/constants/nodejs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TransactionManagerLogLevel';
+export * from './TransactionManagerTimeoutAction';

package/dist/node/types/index.browser.d.ts

@@ -0,0 +1,7 @@
+export * from './constants/index.browser';
+export * from './interfaces/index.browser';
+export * from './managers/index.browser';
+export * from './scripts/index.browser';
+export * from './services/index.browser';
+export * from './types/index.browser';
+export * from './utils/index.browser';

package/dist/node/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './index.browser';
+export * from './constants';
+export * from './interfaces';
+export * from './managers';
+export * from './scripts';
+export * from './services';
+export * from './types';
+export * from './utils';

package/dist/{client → node/types}/interfaces/Point3.d.ts

@@ -1,4 +1,4 @@
-import { Point2 } from "./Point2.js";
+import { Point2 } from "./Point2";
 export interface Point3 extends Point2 {
     z: number;
 }

package/dist/node/types/interfaces/index.browser.d.ts

@@ -0,0 +1,4 @@
+export * from './Coordinate';
+export * from './Point2';
+export * from './Point3';
+export * from './StorageProvider';

package/dist/node/types/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index.browser';
+export * from './nodejs';

package/dist/node/types/interfaces/nodejs/db/index.d.ts

@@ -0,0 +1 @@
+export * from './sequelize';

package/dist/{server → node/types}/interfaces/nodejs/db/sequelize/Hook.d.ts

@@ -1,6 +1,6 @@
 import { ModelCtor } from "sequelize-typescript";
-import { HookType } from "./HookType.js";
-import { HookFn } from "./HookFn.js";
+import { HookType } from "./HookType";
+import { HookFn } from "./HookFn";
 export interface Hook {
     model: ModelCtor;
     hookType: HookType;

package/dist/{server → node/types}/interfaces/nodejs/db/sequelize/HookFn.d.ts

@@ -1,4 +1,4 @@
 import { Hooks, SequelizeHooks } from "sequelize/types/hooks";
 import { Attributes, CreationAttributes } from "sequelize/types/model";
-import { HookType } from "./HookType.js";
+import { HookType } from "./HookType";
 export type HookFn = SequelizeHooks<Hooks['_model'], Attributes<Hooks>, CreationAttributes<Hooks>>[HookType];

package/dist/node/types/interfaces/nodejs/db/sequelize/UpsertOptions.d.ts

@@ -0,0 +1,4 @@
+import { ReloadOption } from "./ReloadOption";
+import { TransactionOption } from "./TransactionOption";
+export interface UpsertOptions extends ReloadOption, TransactionOption {
+}

package/dist/node/types/interfaces/nodejs/db/sequelize/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Hook';
+export * from './HookFn';
+export * from './HookType';
+export * from './ReloadOption';
+export * from './TransactionOption';
+export * from './UpsertOptions';

package/dist/node/types/interfaces/nodejs/index.d.ts

@@ -0,0 +1 @@
+export * from './db';

package/dist/{server → node/types}/managers/SessionManager.d.ts

@@ -1,7 +1,7 @@
 import { AxiosInstance } from "axios";
-import { StorageProvider } from "../interfaces/StorageProvider.js";
+import { StorageProvider } from "../interfaces/StorageProvider";
 import EventEmitter from 'eventemitter3';
-import { SessionManagerEvent, SessionManagerOptions } from "./SessionManager.type.js";
+import { SessionManagerEvent, SessionManagerOptions } from "./SessionManager.type";
 export declare class SessionManager extends EventEmitter<SessionManagerEvent> {
     private static readonly DEFAULT_AUTHORIZATION_STORAGE_KEY;
     protected api: AxiosInstance;

package/dist/{server → node/types}/managers/SessionManager.type.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from "axios";
-import { StorageProvider } from "../interfaces/StorageProvider.js";
+import { StorageProvider } from "../interfaces/StorageProvider";
 export interface SessionManagerOptions {
     api: AxiosInstance;
     storageProvider: StorageProvider;

package/dist/{server → node/types}/managers/TransactionManager.d.ts

@@ -1,7 +1,7 @@
 import { Transaction } from "sequelize";
 import EventEmitter from 'eventemitter3';
-import { TransactionManagerLogLevel, TransactionManagerTimeoutAction } from "../constants/index.js";
-import { TransactionManagerAddOption, TransactionManagerEventTypes } from "./TransactionManager.types.js";
+import { TransactionManagerLogLevel, TransactionManagerTimeoutAction } from "../constants";
+import { TransactionManagerAddOption, TransactionManagerEventTypes } from "./TransactionManager.types";
 export declare class TransactionManager {
     static DEFAULT_TIMEOUT: number;
     static DEFAULT_ACTION: TransactionManagerTimeoutAction;