@xrystal/core 3.3.7 → 3.4.3

package/x/dist/loader/events/index.d.ts

@@ -0,0 +1,6 @@
+export default class EventsService {
+    private logger;
+    load: ({}: {}) => any;
+    private _globalLoader;
+    get global(): any;
+}

package/x/dist/loader/events/index.js

@@ -0,0 +1,25 @@
+import LoggersLoader from '../logger/index';
+import { x, LoggerLayerEnum } from '../../utils/index';
+export default class EventsService {
+    logger = x.get(LoggersLoader);
+    load = ({}) => {
+        this._globalLoader();
+    };
+    _globalLoader = () => {
+        process.on("uncaughtException", (exception) => {
+            this.logger.winston.log({
+                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                message: `UncaughtException: ${exception}`,
+            });
+        });
+        process.on("unhandledRejection", (exception) => {
+            this.logger.winston.log({
+                level: LoggerLayerEnum[LoggerLayerEnum.CRITICAL].toLowerCase(),
+                message: `UnhandledRejection: ${exception}`,
+            });
+        });
+    };
+    get global() {
+        return this._globalLoader();
+    }
+}

package/x/dist/loader/index.d.ts

@@ -0,0 +1,6 @@
+import SystemService from "./system";
+import ConfigsService from "./configs";
+import LoggerService from "./logger";
+import EventsService from "./events";
+import LocalizationsService from "./localizations";
+export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService };

package/x/dist/loader/index.js

@@ -0,0 +1,6 @@
+import SystemService from "./system";
+import ConfigsService from "./configs";
+import LoggerService from "./logger";
+import EventsService from "./events";
+import LocalizationsService from "./localizations";
+export { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService };

package/x/dist/loader/localizations/index.d.ts

@@ -0,0 +1,14 @@
+export default class LocalizationsService {
+    _instance: any;
+    load: ({ loadPath, fallbackLang, preloadLang, }: {
+        loadPath: string;
+        fallbackLang: string;
+        preloadLang: string;
+    }) => any;
+    i18next: ({ loadPath, fallbackLang, preloadLang, }: {
+        loadPath?: string;
+        fallbackLang?: string;
+        preloadLang?: any;
+    }) => any;
+    get instance(): any;
+}

package/x/dist/loader/localizations/index.js

@@ -0,0 +1,32 @@
+import i18next from "i18next";
+import Backend from 'i18next-fs-backend';
+import * as middleware from 'i18next-http-middleware';
+export default class LocalizationsService {
+    _instance = null;
+    load = ({ loadPath, fallbackLang, preloadLang, }) => {
+        this.i18next({
+            loadPath,
+            fallbackLang,
+            preloadLang,
+        });
+    };
+    i18next = ({ loadPath, fallbackLang, preloadLang, }) => {
+        if (this._instance) {
+            return this._instance;
+        }
+        i18next
+            .use(Backend)
+            .use(middleware.LanguageDetector)
+            .init({
+            fallbackLng: fallbackLang,
+            preload: preloadLang,
+            backend: { loadPath: `${loadPath}/{{lng}}.json` }
+        });
+        if (i18next)
+            this._instance = i18next;
+        return i18next;
+    };
+    get instance() {
+        return this._instance;
+    }
+}

package/x/dist/loader/logger/index.d.ts

@@ -0,0 +1,23 @@
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+interface CustomLogger extends winston.Logger {
+    critical: winston.LeveledLogMethod;
+    http: winston.LeveledLogMethod;
+}
+export default class LoggerService {
+    private serviceName;
+    private environment;
+    private kafkaProducer;
+    private kafkaTopic;
+    private isKafkaReady;
+    private getConsoleFormat;
+    winston: CustomLogger;
+    constructor();
+    load: (config: any) => Promise<void>;
+    winstonLoader: ({ loadPath, loggerLevel }: {
+        loadPath: string;
+        loggerLevel: string;
+    }) => CustomLogger;
+    private logToKafka;
+}
+export {};

package/x/dist/loader/logger/index.js

@@ -0,0 +1,126 @@
+import winston, { format } from 'winston';
+import 'winston-daily-rotate-file';
+import path from 'path';
+import { Kafka, Partitioners } from 'kafkajs';
+import { LoggerLayerEnum } from '../../utils';
+const customLevels = {
+    critical: LoggerLayerEnum.CRITICAL, // 0
+    error: LoggerLayerEnum.ERROR, // 1
+    info: LoggerLayerEnum.INFO, // 2
+    http: LoggerLayerEnum.HTTP, // 4
+    debug: LoggerLayerEnum.DEBUG, // 5
+};
+const customColors = {
+    critical: 'red',
+    error: 'magenta',
+    warn: 'yellow',
+    info: 'green',
+    http: 'cyan',
+    debug: 'blue'
+};
+export default class LoggerService {
+    serviceName = "";
+    environment = "";
+    kafkaProducer = null;
+    kafkaTopic = "";
+    isKafkaReady = false;
+    getConsoleFormat() {
+        return format.combine(format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), format.colorize({ all: true }), format.printf((info) => {
+            const msg = typeof info.message === 'object' ? JSON.stringify(info.message) : info.message;
+            return `${info.timestamp} [${this.serviceName}] ${info.level}: ${msg}`;
+        }));
+    }
+    winston = winston.createLogger({
+        level: 'debug',
+        levels: customLevels,
+        transports: [
+            new winston.transports.Console({
+                format: this.getConsoleFormat()
+            })
+        ]
+    });
+    constructor() {
+        winston.addColors(customColors);
+    }
+    load = async (config) => {
+        this.serviceName = config?.serviceName || "service";
+        this.environment = config?.env || "dev";
+        this.kafkaTopic = config?.kafkaTopic || "logs";
+        this.winstonLoader({
+            loadPath: config?.loadPath || "./logs",
+            loggerLevel: config?.loggerLevel || "debug"
+        });
+        const rawBrokers = config?.kafkaBrokers;
+        const brokers = rawBrokers ? String(rawBrokers).split(',').map((b) => b.trim()) : [];
+        if (brokers.length > 0) {
+            try {
+                const kafka = new Kafka({
+                    clientId: this.serviceName,
+                    brokers: brokers,
+                    retry: { initialRetryTime: 100, retries: 3 }
+                });
+                this.kafkaProducer = kafka.producer({ createPartitioner: Partitioners.LegacyPartitioner });
+                await this.kafkaProducer.connect();
+                this.isKafkaReady = true;
+                this.winston.info('Logger connected to Kafka');
+            }
+            catch (err) {
+                console.error(`Kafka error: ${err.message}`);
+            }
+        }
+    };
+    winstonLoader = ({ loadPath, loggerLevel }) => {
+        const { combine, timestamp, json, errors } = format;
+        const jsonFileFormat = combine(timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), errors({ stack: true }), json());
+        const winstonLogger = winston.createLogger({
+            level: loggerLevel,
+            levels: customLevels,
+            transports: [
+                new winston.transports.Console({
+                    format: this.getConsoleFormat()
+                }),
+                new winston.transports.DailyRotateFile({
+                    filename: path.resolve(loadPath, 'error', '%DATE%_error.log'),
+                    level: 'error',
+                    format: jsonFileFormat,
+                    maxSize: '2mb',
+                    maxFiles: '7d'
+                }),
+                new winston.transports.DailyRotateFile({
+                    filename: path.resolve(loadPath, 'critical', '%DATE%_critical.log'),
+                    level: 'critical',
+                    format: jsonFileFormat,
+                    maxSize: '2mb',
+                    maxFiles: '14d'
+                })
+            ]
+        });
+        winstonLogger.on('data', (info) => {
+            if (this.isKafkaReady) {
+                this.logToKafka(info);
+            }
+        });
+        this.winston = winstonLogger;
+        return winstonLogger;
+    };
+    async logToKafka(info) {
+        if (!this.kafkaProducer || !this.isKafkaReady)
+            return;
+        try {
+            await this.kafkaProducer.send({
+                topic: this.kafkaTopic,
+                messages: [{
+                        value: JSON.stringify({
+                            ...info,
+                            service: this.serviceName,
+                            env: this.environment,
+                            timestamp: new Date().toISOString()
+                        })
+                    }]
+            });
+        }
+        catch (err) {
+            this.isKafkaReady = false;
+        }
+    }
+}

package/x/dist/loader/system/index.d.ts

@@ -0,0 +1,8 @@
+export default class SystemService {
+    private static _tmp;
+    load: ({ tmp, }: {
+        tmp: any;
+    }) => Promise<void>;
+    private _systemLoader;
+    static get tmp(): any;
+}

package/x/dist/loader/system/index.js

@@ -0,0 +1,14 @@
+export default class SystemService {
+    static _tmp;
+    load = async ({ tmp, }) => {
+        SystemService._tmp = tmp;
+        await this._systemLoader({});
+    };
+    _systemLoader = async ({}) => {
+        //console.log(this._tmp)
+    };
+    // => getters
+    static get tmp() {
+        return SystemService._tmp;
+    }
+}

package/x/dist/project/index.d.ts

@@ -0,0 +1,6 @@
+declare const coreLoader: () => Promise<{
+    _?: undefined;
+} | {
+    _: any;
+}>;
+export default coreLoader;

package/x/dist/project/index.js

@@ -0,0 +1,63 @@
+// => import dependencies
+import path from 'path';
+import { SystemService, ConfigsService, LoggerService, EventsService, LocalizationsService } from '../loader/index';
+import { packageName, tmpFileDefaultName, tmpFileDefaultExt, findFileRecursively, TmpFileLoader, x, kafkaBrokers, systemLoggerLayer, } from '../utils/index';
+//
+let coreHasRun = false;
+const coreLoader = async () => {
+    if (coreHasRun)
+        return {};
+    try {
+        const ownerTmpFilePath = findFileRecursively(".", tmpFileDefaultName, tmpFileDefaultExt);
+        if (!ownerTmpFilePath) {
+            throw new Error(`${tmpFileDefaultName} file not found`);
+        }
+        const tmpFileObject = new TmpFileLoader({ filePath: ownerTmpFilePath });
+        const r = tmpFileObject.getResolvedTmpFile();
+        const { configs } = r;
+        const rootFolderPath = configs.rootFolderPath;
+        const services = [
+            SystemService,
+            ConfigsService,
+            LoggerService,
+            EventsService,
+            LocalizationsService
+        ];
+        services.forEach(service => x.set({ service, reference: service }));
+        const system = x.get(SystemService);
+        const configService = x.get(ConfigsService);
+        const logger = x.get(LoggerService);
+        const events = x.get(EventsService);
+        const i18n = x.get(LocalizationsService);
+        await system.load({
+            tmp: { _: r }
+        });
+        await configService.load({
+            tmpFolderPath: rootFolderPath,
+            systemService: system,
+            envLoadPath: path.join(rootFolderPath, configs.loaders.configs.envLoadPath),
+            ...(configs.loaders.configs.globalEnvFileName && { globalEnvFileName: configs.loaders.configs.globalEnvFileName })
+        });
+        await logger.load({
+            loadPath: path.join(rootFolderPath, configs.loaders.loggers.loadPath),
+            loggerLevel: systemLoggerLayer ?? configs.loaders.loggers.logLevel,
+            serviceName: configs.service,
+            env: process.env.NODE_ENV,
+            kafkaBrokers: kafkaBrokers ?? "",
+            kafkaTopic: configs.loaders.loggers.topic
+        });
+        await events.load({});
+        await i18n.load({
+            loadPath: path.resolve(rootFolderPath, configs.loaders.localization.loadPath),
+            fallbackLang: configs.loaders.localization.fallbackLang,
+            preloadLang: configs.loaders.localization.preloadLangs
+        });
+        coreHasRun = true;
+        return { _: r };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[${packageName} core failure]: ${errorMessage}`);
+    }
+};
+export default coreLoader;

package/x/dist/utils/constants/index.d.ts

@@ -0,0 +1,8 @@
+export declare const packageName: string;
+export declare const tmpFileDefaultMainFolderName: string;
+export declare const tmpFileDefaultName: string;
+export declare const tmpFileDefaultExt = ".yml";
+export declare const defaultTmpFilePath: string;
+export declare const defaultOwnerTmpFilePath: string;
+export declare const systemLoggerLayer: string;
+export declare const kafkaBrokers: string;

package/x/dist/utils/constants/index.js

@@ -0,0 +1,10 @@
+import path from 'path';
+import { __dirname } from '../helpers/path';
+export const packageName = 'x';
+export const tmpFileDefaultMainFolderName = 'x';
+export const tmpFileDefaultName = 'tmp';
+export const tmpFileDefaultExt = '.yml';
+export const defaultTmpFilePath = path.resolve(__dirname(import.meta.url), `../../${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
+export const defaultOwnerTmpFilePath = path.resolve(`./${tmpFileDefaultMainFolderName}/${tmpFileDefaultName}.yml`);
+export const systemLoggerLayer = process.env.SYSTEM_LOGGER_LAYER;
+export const kafkaBrokers = process.env.KAFKA_BROKERS;

package/x/dist/utils/helpers/date/index.d.ts

@@ -0,0 +1,16 @@
+import { PolarityTypeEnum } from "../../models";
+export declare function dateZoneConverter({ polarity, date, zone, factor }: {
+    polarity: PolarityTypeEnum;
+    date: Date;
+    zone: number;
+    factor?: number;
+}): string;
+export declare function convertDate(date: string, splitCharacter?: string, replaceCharacter?: string): string[];
+export declare function convertTime(time: string, splitCharacter?: string, replaceCharacter?: string): string[];
+export declare function getDateAndTime({ getDate, getTime, dateCharacter, timeCharacter, separatorCharacter }: {
+    getDate: boolean;
+    getTime: boolean;
+    dateCharacter: string;
+    timeCharacter: string;
+    separatorCharacter: string;
+}): string;

package/x/dist/utils/helpers/date/index.js

@@ -0,0 +1,48 @@
+import { PolarityTypeEnum } from "../../models";
+export function dateZoneConverter({ polarity, date, zone, factor = 1000 }) {
+    let convertedZoneTime = null;
+    if (polarity === PolarityTypeEnum.NEGATIVE) {
+        convertedZoneTime = date.getTime() - factor * zone;
+    }
+    else {
+        convertedZoneTime = date.getTime() + factor * zone;
+    }
+    return new Date(convertedZoneTime).toISOString();
+}
+export function convertDate(date, splitCharacter = '/', replaceCharacter = '-') {
+    const convertDate = date.split(splitCharacter).map((value, index) => index !== 2 ? replaceCharacter : value);
+    return convertDate;
+}
+export function convertTime(time, splitCharacter = ':', replaceCharacter = '-') {
+    const convertDate = time.split(splitCharacter).map((value, index) => index !== 2 ? replaceCharacter : value);
+    return convertDate;
+}
+export function getDateAndTime({ getDate = true, getTime = true, dateCharacter = '-', timeCharacter = ':', separatorCharacter = '&' }) {
+    const date = new Date();
+    let formattedDate = '';
+    if (!getDate && !getTime) {
+        throw new Error("Invalid options! Required one true value");
+    }
+    if (getDate) {
+        const day = date.getDate().toString().padStart(2, '0');
+        const month = (date.getMonth() + 1).toString().padStart(2, '0');
+        const year = date.getFullYear();
+        formattedDate = `${year}${dateCharacter}${month}${dateCharacter}${day}`;
+    }
+    if (getTime) {
+        const hours = date.getHours().toString().padStart(2, '0');
+        const minutes = date.getMinutes().toString().padStart(2, '0');
+        const seconds = date.getSeconds().toString().padStart(2, '0');
+        formattedDate = `${hours}${timeCharacter}${minutes}${timeCharacter}${seconds}`;
+    }
+    if (getDate && getTime) {
+        const day = date.getDate().toString().padStart(2, '0');
+        const month = (date.getMonth() + 1).toString().padStart(2, '0');
+        const year = date.getFullYear();
+        const hours = date.getHours().toString().padStart(2, '0');
+        const minutes = date.getMinutes().toString().padStart(2, '0');
+        const seconds = date.getSeconds().toString().padStart(2, '0');
+        formattedDate = `${year}${dateCharacter}${month}${dateCharacter}${day}${separatorCharacter}${hours}${timeCharacter}${minutes}${timeCharacter}${seconds}`;
+    }
+    return formattedDate;
+}

package/x/dist/utils/helpers/filters/index.d.ts

@@ -0,0 +1,17 @@
+declare function mongoFilter(start: any, end: any, objPath: string): any;
+declare function filterUniqueOnce<T extends Record<string, any>>({ arr, key, uniqueOnceValues }: {
+    arr: T[];
+    key: keyof T;
+    uniqueOnceValues: (T[keyof T])[];
+}): T[];
+declare function filterSortByPropOrder<T extends Record<string, any>>({ arr, key, desiredOrder }: {
+    arr: T[];
+    key: keyof T;
+    desiredOrder: T[keyof T][];
+}): T[];
+declare function filterRemoveItemsByProps<T extends Record<string, any>>({ arr, key, valuesToRemove }: {
+    arr: T[];
+    key: keyof T;
+    valuesToRemove: (T[keyof T])[];
+}): T[];
+export { mongoFilter, filterUniqueOnce, filterSortByPropOrder, filterRemoveItemsByProps };

package/x/dist/utils/helpers/filters/index.js

@@ -0,0 +1,44 @@
+function mongoFilter(start, end, objPath) {
+    const filter = {};
+    if (!objPath) {
+        throw new Error('MongoFilter helper property is required.');
+    }
+    filter[objPath] = filter[objPath] || {};
+    if (start && end) {
+        filter[objPath].$gte = start;
+        filter[objPath].$lte = end;
+    }
+    else if (start) {
+        filter[objPath].$gte = start;
+    }
+    else if (end) {
+        filter[objPath].$lte = end;
+    }
+    return filter;
+}
+function filterUniqueOnce({ arr, key, uniqueOnceValues }) {
+    const seen = new Set();
+    return arr.filter(item => {
+        const val = item[key];
+        if (uniqueOnceValues.includes(val)) {
+            if (seen.has(val))
+                return false;
+            seen.add(val);
+            return true;
+        }
+        return true;
+    });
+}
+function filterSortByPropOrder({ arr, key, desiredOrder }) {
+    const orderMap = new Map();
+    desiredOrder.forEach((value, index) => orderMap.set(value, index));
+    return [...arr].sort((a, b) => {
+        const aIndex = orderMap.get(a[key]) ?? Infinity;
+        const bIndex = orderMap.get(b[key]) ?? Infinity;
+        return aIndex - bIndex;
+    });
+}
+function filterRemoveItemsByProps({ arr, key, valuesToRemove }) {
+    return arr.filter(item => !valuesToRemove.includes(item[key]));
+}
+export { mongoFilter, filterUniqueOnce, filterSortByPropOrder, filterRemoveItemsByProps };

package/x/dist/utils/helpers/hash/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function generateSHA256Hash(secret: any, payload?: any): string;
+export declare function generateNumberAndLetter(length?: number): string;
+export declare function generateCodeChallenge(codeVerifier: string): string;

package/x/dist/utils/helpers/hash/crypto.js

@@ -0,0 +1,22 @@
+import crypto from 'crypto';
+export function generateSHA256Hash(secret, payload) {
+    return crypto
+        .createHmac('sha256', secret)
+        .update(payload ? payload : '')
+        .digest('hex');
+}
+export function generateNumberAndLetter(length = 8) {
+    const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array, byte => charset[byte % charset.length]).join('');
+}
+export function generateCodeChallenge(codeVerifier) {
+    return crypto
+        .createHash('sha256')
+        .update(codeVerifier)
+        .digest('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+}

package/x/dist/utils/helpers/id/index.d.ts

@@ -0,0 +1,13 @@
+export declare const serverIdNameGenerator: ({ prefix, payload, suffix }: {
+    prefix?: string;
+    payload: any;
+    suffix?: string;
+}) => string;
+export declare function generateRandomKey(options: {
+    length?: number;
+    format?: 'hex' | 'base64';
+    prefix?: string;
+    suffix?: string;
+    separator?: string;
+}): string;
+export declare function generateReferenceCode(length: number, prefix?: string, middle?: string, suffix?: string): string;

package/x/dist/utils/helpers/id/index.js

@@ -0,0 +1,24 @@
+import crypto from 'crypto';
+export const serverIdNameGenerator = ({ prefix, payload, suffix }) => {
+    return `${prefix}-${payload.toString()}-${suffix}`;
+};
+export function generateRandomKey(options) {
+    const { length = 48, format = 'hex', prefix = '', suffix = '', separator = '-', } = options;
+    const randomPart = crypto.randomBytes(length).toString(format);
+    const parts = [prefix, randomPart, suffix].filter(Boolean);
+    return parts.join(separator);
+}
+export function generateReferenceCode(length, prefix = "", middle = "", suffix = "") {
+    const totalLength = prefix.length + length + middle.length + suffix.length;
+    if (totalLength <= 0) {
+        throw new Error("The total length (including prefix, middle, and suffix) must be greater than 0.");
+    }
+    let referenceCode = "";
+    for (let i = 0; i < length; i++) {
+        const randomDigit = Math.floor(Math.random() * 10);
+        referenceCode += randomDigit.toString();
+    }
+    const middleIndex = Math.floor(referenceCode.length / 2);
+    const referenceWithMiddle = referenceCode.slice(0, middleIndex) + middle + referenceCode.slice(middleIndex);
+    return `${prefix}${referenceWithMiddle}${suffix}`;
+}

package/x/dist/utils/helpers/index.d.ts

@@ -0,0 +1,16 @@
+export * from './tmp/index';
+export * from './path/index';
+export * from './is/index';
+export * from './id/index';
+export * from './validates/index';
+export * from './ip/index';
+export * from './hash/crypto';
+export * from './string/index';
+export * from './objects/index';
+export * from './locales/index';
+export * from './timer/index';
+export * from './date/index';
+export * from './math/index';
+export * from './regex/checkSpecialRegexControl';
+export * from './filters/index';
+export * from './locales/index';

package/x/dist/utils/helpers/index.js

@@ -0,0 +1,16 @@
+export * from './tmp/index';
+export * from './path/index';
+export * from './is/index';
+export * from './id/index';
+export * from './validates/index';
+export * from './ip/index';
+export * from './hash/crypto';
+export * from './string/index';
+export * from './objects/index';
+export * from './locales/index';
+export * from './timer/index';
+export * from './date/index';
+export * from './math/index';
+export * from './regex/checkSpecialRegexControl';
+export * from './filters/index';
+export * from './locales/index';

package/x/dist/utils/helpers/ip/index.d.ts

@@ -0,0 +1 @@
+export declare const getClientIp: (req: any) => any;

package/x/dist/utils/helpers/ip/index.js

@@ -0,0 +1,3 @@
+export const getClientIp = (req) => {
+    return req.headers["x-forwarded-for"]?.split(",")[0] || req.socket.remoteAddress;
+};

package/x/dist/utils/helpers/is/index.d.ts

@@ -0,0 +1,11 @@
+export declare function isFalsy(value: unknown, options: {
+    ignoreFalse?: boolean;
+    ignoreZero?: boolean;
+    ignoreEmptyString?: boolean;
+    ignoreNull?: boolean;
+    ignoreUndefined?: boolean;
+    ignoreNaN?: boolean;
+}): boolean;
+export declare function isType(data: any, type: any): boolean;
+export declare function isInstance(data: any, type: any): boolean;
+export declare function isBcryptHash(value: string): boolean;

package/x/dist/utils/helpers/is/index.js

@@ -0,0 +1,35 @@
+export function isFalsy(value, options) {
+    if (!options.ignoreFalse && value === false)
+        return true;
+    if (!options.ignoreZero && value === 0)
+        return true;
+    if (!options.ignoreEmptyString && value === '')
+        return true;
+    if (!options.ignoreNull && value === null)
+        return true;
+    if (!options.ignoreUndefined && value === undefined)
+        return true;
+    if (!options.ignoreNaN && typeof value === 'number' && isNaN(value))
+        return true;
+    return false;
+}
+export function isType(data, type) {
+    if (typeof data === type) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function isInstance(data, type) {
+    if (data instanceof type) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export function isBcryptHash(value) {
+    const bcryptRegex = /^\$2[aby]\$\d{2}\$.{53}$/;
+    return bcryptRegex.test(value);
+}