@open-norantec/utilities 1.0.1-alpha.9 → 2.0.0-alpha.0

package/dist/ecdh-util.class.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as crypto from 'node:crypto';
+export declare class ECDHUtil {
+    private readonly curveName;
+    readonly ecdh: crypto.ECDH;
+    protected readonly ALGORITHM: crypto.CipherGCMTypes;
+    constructor(curveName?: string);
+    encrypt(data: string, otherPublicKey: Buffer): string;
+    decrypt(encryptedData: string, otherPublicKey: Buffer): string;
+}

package/dist/ecdh-util.class.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECDHUtil = void 0;
+const crypto = require("node:crypto");
+class ECDHUtil {
+    constructor(curveName = 'prime256v1') {
+        this.curveName = curveName;
+        this.ecdh = crypto.createECDH(this.curveName);
+        this.ALGORITHM = 'aes-256-gcm';
+    }
+    encrypt(data, otherPublicKey) {
+        const sharedKey = this.ecdh.computeSecret(new Uint8Array(otherPublicKey));
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(this.ALGORITHM, new Uint8Array(sharedKey), new Uint8Array(iv));
+        const encrypted = Buffer.concat([new Uint8Array(cipher.update(data, 'utf-8')), new Uint8Array(cipher.final())]);
+        return Buffer.concat([new Uint8Array(iv), new Uint8Array(encrypted), new Uint8Array(cipher.getAuthTag())]).toString('base64');
+    }
+    decrypt(encryptedData, otherPublicKey) {
+        const sharedKey = this.ecdh.computeSecret(new Uint8Array(otherPublicKey));
+        const data = Buffer.from(encryptedData, 'base64');
+        const iv = data.subarray(0, 16);
+        const authTag = data.subarray(data.length - 16);
+        const encrypted = data.subarray(16, data.length - 16);
+        const decipher = crypto.createDecipheriv(this.ALGORITHM, new Uint8Array(sharedKey), new Uint8Array(iv));
+        decipher.setAuthTag(new Uint8Array(authTag));
+        return Buffer.concat([
+            new Uint8Array(decipher.update(new Uint8Array(encrypted))),
+            new Uint8Array(decipher.final()),
+        ]).toString('utf-8');
+    }
+}
+exports.ECDHUtil = ECDHUtil;

package/dist/enum-util.class.d.ts

@@ -1,3 +1,4 @@
+import { z } from './zod';
 export interface IEnum {
     [x: string]: any;
 }
@@ -5,4 +6,5 @@ export declare class EnumUtil {
     static getEntries(inputEnum: IEnum): Array<[string, any]>;
     static isValidValue(inputEnum: IEnum, inputValue: any): boolean;
     static isEqual(enum1: IEnum, enum2: IEnum): boolean;
+    static createEnumSchema<const T extends Record<string, string>>(object: T, params?: Parameters<typeof z.enum>[1]): z.ZodEnum<{ [k_1 in T[keyof T]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: { [k_1 in T[keyof T]]: k_1; }[k]; } : never>;
 }

package/dist/enum-util.class.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumUtil = void 0;
+const zod_1 = require("./zod");
 class EnumUtil {
     static getEntries(inputEnum) {
         try {
@@ -34,5 +35,8 @@ class EnumUtil {
         }
         return true;
     }
+    static createEnumSchema(object, params) {
+        return zod_1.z.enum(Object.values(object), params);
+    }
 }
 exports.EnumUtil = EnumUtil;

package/dist/enums.d.ts

@@ -0,0 +1,56 @@
+export declare namespace Enums {
+    const OrderOrientation: {
+        readonly ASC: "ASC";
+        readonly DESC: "DESC";
+    };
+    const WhereClauseOp: {
+        readonly ADJACENT: "adjacent";
+        readonly ANY: "any";
+        readonly BETWEEN: "between";
+        readonly COL: "col";
+        readonly CONTAINED: "contained";
+        readonly CONTAINS: "contains";
+        readonly ENDS_WITH: "endsWith";
+        readonly EQ: "eq";
+        readonly GT: "gt";
+        readonly GTE: "gte";
+        readonly I_LIKE: "iLike";
+        readonly IN: "in";
+        readonly I_REGEXP: "iRegexp";
+        readonly IS: "is";
+        readonly LIKE: "like";
+        readonly LT: "lt";
+        readonly LTE: "lte";
+        readonly MATCH: "match";
+        readonly NE: "ne";
+        readonly NO_EXTEND_LEFT: "noExtendLeft";
+        readonly NO_EXTEND_RIGHT: "noExtendRight";
+        readonly NOT: "not";
+        readonly NOT_BETWEEN: "notBetween";
+        readonly NOT_I_LIKE: "notILike";
+        readonly NOT_IN: "notIn";
+        readonly NOT_I_REGEXP: "notIRegexp";
+        readonly NOT_LIKE: "notLike";
+        readonly NOT_REGEXP: "notRegexp";
+        readonly OVERLAP: "overlap";
+        readonly PLACEHOLDER: "placeholder";
+        readonly REGEXP: "regexp";
+        readonly STARTS_WITH: "startsWith";
+        readonly STRICT_LEFT: "strictLeft";
+        readonly STRICT_RIGHT: "strictRight";
+        readonly SUBSTRING: "substring";
+        readonly VALUES: "values";
+    };
+    const LogLevel: {
+        readonly ERROR: "error";
+        readonly WARN: "warn";
+        readonly INFO: "info";
+        readonly VERBOSE: "verbose";
+        readonly DEBUG: "debug";
+    };
+}
+export declare namespace EnumTypes {
+    type OrderOrientation = (typeof Enums.OrderOrientation)[keyof typeof Enums.OrderOrientation];
+    type WhereClauseOp = (typeof Enums.WhereClauseOp)[keyof typeof Enums.WhereClauseOp];
+    type LogLevel = (typeof Enums.LogLevel)[keyof typeof Enums.LogLevel];
+}

package/dist/enums.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Enums = void 0;
+var Enums;
+(function (Enums) {
+    Enums.OrderOrientation = {
+        ASC: 'ASC',
+        DESC: 'DESC',
+    };
+    Enums.WhereClauseOp = {
+        ADJACENT: 'adjacent',
+        ANY: 'any',
+        BETWEEN: 'between',
+        COL: 'col',
+        CONTAINED: 'contained',
+        CONTAINS: 'contains',
+        ENDS_WITH: 'endsWith',
+        EQ: 'eq',
+        GT: 'gt',
+        GTE: 'gte',
+        I_LIKE: 'iLike',
+        IN: 'in',
+        I_REGEXP: 'iRegexp',
+        IS: 'is',
+        LIKE: 'like',
+        LT: 'lt',
+        LTE: 'lte',
+        MATCH: 'match',
+        NE: 'ne',
+        NO_EXTEND_LEFT: 'noExtendLeft',
+        NO_EXTEND_RIGHT: 'noExtendRight',
+        NOT: 'not',
+        NOT_BETWEEN: 'notBetween',
+        NOT_I_LIKE: 'notILike',
+        NOT_IN: 'notIn',
+        NOT_I_REGEXP: 'notIRegexp',
+        NOT_LIKE: 'notLike',
+        NOT_REGEXP: 'notRegexp',
+        OVERLAP: 'overlap',
+        PLACEHOLDER: 'placeholder',
+        REGEXP: 'regexp',
+        STARTS_WITH: 'startsWith',
+        STRICT_LEFT: 'strictLeft',
+        STRICT_RIGHT: 'strictRight',
+        SUBSTRING: 'substring',
+        VALUES: 'values',
+    };
+    Enums.LogLevel = {
+        ERROR: 'error',
+        WARN: 'warn',
+        INFO: 'info',
+        VERBOSE: 'verbose',
+        DEBUG: 'debug',
+    };
+})(Enums || (exports.Enums = Enums = {}));

package/dist/error-util.class.d.ts

@@ -0,0 +1,16 @@
+declare class ResponseError extends Error {
+    readonly statusCode: number;
+    readonly status: number;
+    readonly code: number;
+    constructor(message?: string | undefined, statusCode?: number, status?: number, code?: number);
+}
+export declare class ErrorUtil {
+    static createResponseError(error: Error, statusCode?: number): ResponseError;
+    static formatError(error: Error): {
+        id: string;
+        message: string;
+        logs: string[];
+        response: Response;
+    };
+}
+export {};

package/dist/error-util.class.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorUtil = void 0;
+const uuid_util_class_1 = require("./uuid-util.class");
+function isZodError(error) {
+    return typeof error === 'object' && error !== null && 'issues' in error && Array.isArray(error.issues);
+}
+class ResponseError extends Error {
+    constructor(message, statusCode = 500, status = 500, code = 500) {
+        super(message);
+        this.statusCode = statusCode;
+        this.status = status;
+        this.code = code;
+    }
+}
+class ErrorUtil {
+    static createResponseError(error, statusCode = 500) {
+        return new ResponseError(error.message, statusCode, statusCode, statusCode);
+    }
+    static formatError(error) {
+        const id = uuid_util_class_1.UUIDUtil.generateV4();
+        let message;
+        let errorLogs = [];
+        if (isZodError(error)) {
+            message = JSON.stringify({
+                message: 'Failed to validate your input data ({{context.trace}})',
+                context: {
+                    trace: id,
+                },
+            });
+            errorLogs.push(JSON.stringify(error.issues));
+        }
+        else {
+            message = JSON.stringify({
+                message: `${error.message || 'An unknown error occurred'} ({{context.trace}})`,
+                context: {
+                    trace: id,
+                },
+            });
+        }
+        errorLogs.push((error === null || error === void 0 ? void 0 : error.stack) || 'No stack trace available');
+        return {
+            id,
+            message,
+            logs: errorLogs.map((log) => `[AUTO_ERROR] [${id}] [${new Date().toISOString()}] ${log}`),
+            response: new Response(message, {
+                status: (() => {
+                    if (isZodError(error))
+                        return 400;
+                    if (error instanceof ResponseError)
+                        return error.statusCode;
+                    return 500;
+                })(),
+                headers: { 'Content-Type': 'application/json' },
+            }),
+        };
+    }
+}
+exports.ErrorUtil = ErrorUtil;

package/dist/eslint-util.class.d.ts

@@ -0,0 +1,29 @@
+import * as tsParser from '@typescript-eslint/parser';
+import * as stylistic from '@stylistic/eslint-plugin';
+export declare class ESLintUtil {
+    static create({ ignores, project }: {
+        ignores?: string[];
+        project?: string;
+    }): {
+        files: string[];
+        languageOptions: {
+            parser: typeof tsParser;
+            parserOptions: {
+                project: string;
+                tsconfigRootDir: string;
+                sourceType: string;
+            };
+        };
+        ignores: string[];
+        plugins: {
+            '@typescript-eslint': {
+                configs: Record<string, ClassicConfig.Config>;
+                meta: FlatConfig.PluginMeta;
+                rules: import("@typescript-eslint/eslint-plugin/rules").TypeScriptESLintRules;
+            };
+            '@stylistic': typeof stylistic;
+            prettier: import("@eslint/core").Plugin;
+        };
+        rules: any;
+    }[];
+}

package/dist/eslint-util.class.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESLintUtil = void 0;
+const tsParser = require("@typescript-eslint/parser");
+const tsPlugin = require("@typescript-eslint/eslint-plugin");
+const stylistic = require("@stylistic/eslint-plugin");
+const prettier = require("eslint-plugin-prettier");
+class ESLintUtil {
+    static create({ ignores = [], project = './tsconfig.json' }) {
+        var _a, _b, _c, _d;
+        return [
+            {
+                files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.mts', '**/*.cts', '**/*.mjs', '**/*.cjs'],
+                languageOptions: {
+                    parser: tsParser,
+                    parserOptions: {
+                        project,
+                        tsconfigRootDir: process.cwd(),
+                        sourceType: 'module',
+                    },
+                },
+                ignores,
+                plugins: {
+                    '@typescript-eslint': tsPlugin,
+                    '@stylistic': stylistic,
+                    prettier,
+                },
+                rules: Object.assign(Object.assign(Object.assign({}, (_b = (_a = tsPlugin === null || tsPlugin === void 0 ? void 0 : tsPlugin.configs) === null || _a === void 0 ? void 0 : _a.recommended) === null || _b === void 0 ? void 0 : _b.rules), (_d = (_c = prettier === null || prettier === void 0 ? void 0 : prettier.configs) === null || _c === void 0 ? void 0 : _c.recommended) === null || _d === void 0 ? void 0 : _d.rules), { 'prettier/prettier': [
+                        'error',
+                        {
+                            singleQuote: true,
+                            trailingComma: 'all',
+                            tabWidth: 2,
+                            printWidth: 120,
+                        },
+                        {
+                            usePrettierrc: false,
+                        },
+                    ], '@typescript-eslint/interface-name-prefix': 'off', '@typescript-eslint/explicit-function-return-type': 'off', '@typescript-eslint/explicit-module-boundary-types': 'off', '@typescript-eslint/no-explicit-any': 'off', '@typescript-eslint/no-require-imports': 'off', '@typescript-eslint/no-empty-object-type': 'off', '@typescript-eslint/no-unsafe-function-type': 'off', '@typescript-eslint/no-namespace': 'off', '@stylistic/member-delimiter-style': [
+                        'error',
+                        {
+                            multiline: {
+                                delimiter: 'semi',
+                                requireLast: true,
+                            },
+                            singleline: {
+                                delimiter: 'semi',
+                                requireLast: false,
+                            },
+                        },
+                    ], 'multiline-ternary': ['error', 'always-multiline'], 'object-curly-newline': ['error', { multiline: true, consistent: true }] }),
+            },
+        ];
+    }
+}
+exports.ESLintUtil = ESLintUtil;

package/dist/index.d.ts

@@ -5,8 +5,11 @@ export * from './json-util.class';
 export * from './string-util.class';
 export * from './user-agent-util.class';
 export * from './enum-util.class';
-export * from './schema-util.class';
 export * from './log-util.class';
 export * from './crypto-util.class';
 export * from './date-util.class';
 export * from './url-util.class';
+export * from './error-util.class';
+export * from './zod';
+export * from './schemas';
+export * from './enums';

package/dist/index.js

@@ -21,8 +21,11 @@ __exportStar(require("./json-util.class"), exports);
 __exportStar(require("./string-util.class"), exports);
 __exportStar(require("./user-agent-util.class"), exports);
 __exportStar(require("./enum-util.class"), exports);
-__exportStar(require("./schema-util.class"), exports);
 __exportStar(require("./log-util.class"), exports);
 __exportStar(require("./crypto-util.class"), exports);
 __exportStar(require("./date-util.class"), exports);
 __exportStar(require("./url-util.class"), exports);
+__exportStar(require("./error-util.class"), exports);
+__exportStar(require("./zod"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./enums"), exports);

package/dist/log-util.class.d.ts

@@ -1,7 +1,7 @@
-import { Schema } from './schema-util.class';
+import { EnumTypes } from './enums';
 export declare class LogUtil {
     private readonly defaultLogLevel;
-    constructor(defaultLogLevel?: Schema.LogLevel);
-    match(bottomLogLevel: Schema.LogLevel | boolean, logLevel: Schema.LogLevel): boolean;
-    log(level: Schema.LogLevel, message: string): void;
+    constructor(defaultLogLevel?: EnumTypes.LogLevel);
+    match(bottomLogLevel: EnumTypes.LogLevel | boolean, logLevel: EnumTypes.LogLevel): boolean;
+    log(level: EnumTypes.LogLevel, message: string | Error): void;
 }

package/dist/log-util.class.js

@@ -36,9 +36,9 @@ class LogUtil {
         if (this.match(this.defaultLogLevel, level) === false)
             return;
         const finalExtraMessage = level === 'debug' || (this.defaultLogLevel === 'debug' && level === 'error')
-            ? (_d = (_c = (_b = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split) === null || _b === void 0 ? void 0 : _b.call(_a, '\n')) === null || _c === void 0 ? void 0 : _c.slice(1)) === null || _d === void 0 ? void 0 : _d.join('\n')
+            ? (_d = (_c = (_b = (_a = (message instanceof Error ? message : new Error()).stack) === null || _a === void 0 ? void 0 : _a.split) === null || _b === void 0 ? void 0 : _b.call(_a, '\n')) === null || _c === void 0 ? void 0 : _c.slice(1)) === null || _d === void 0 ? void 0 : _d.join('\n')
             : '';
-        console.log(colorizer(`[${new Date().toLocaleString()}] [${level.toUpperCase()}] ${message || ''}${string_util_class_1.StringUtil.isFalsyString(finalExtraMessage) ? '' : `\n${finalExtraMessage}`}`));
+        console.log(colorizer(`[${new Date().toLocaleString()}] [${level.toUpperCase()}] ${message instanceof Error ? message.message : message}${string_util_class_1.StringUtil.isFalsyString(finalExtraMessage) ? '' : `\n${finalExtraMessage}`}`));
     }
 }
 exports.LogUtil = LogUtil;