fiberx-backend-toolkit 0.0.34 → 0.0.36

package/dist/config/constants.d.ts

@@ -18,3 +18,4 @@ export declare const REQUEST_RATE_LIMITTER_OPTIONS: {
     max_requests: number;
     message: string;
 };
+export declare const ALPHABET_CORPUS: string[];

package/dist/config/constants.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUEST_RATE_LIMITTER_OPTIONS = exports.CORS_MAX_AGE_IN_MICRO_SECONDS = exports.CORS_MAX_AGE_IN_SECONDS = exports.CORS_ALLOWED_HEADERS = exports.CORS_ALLOWED_METHODS = exports.REQUEST_ID_COOKIE_MAX_AGE = exports.SEQUELIZE_SEEDER_META_TABLE_NAME = exports.SEQUELIZE_META_TABLE_NAME = exports.SEEDERS_DIR = exports.MIGRATIONS_DIR = exports.MODELS_DIR = exports.SCHEMA_SNAPSHOTS_DIR = exports.SCHEMAS_DIR = exports.ENV_VAR_DIR = exports.LOG_DIR = exports.BASE_DIR = void 0;
+exports.ALPHABET_CORPUS = exports.REQUEST_RATE_LIMITTER_OPTIONS = exports.CORS_MAX_AGE_IN_MICRO_SECONDS = exports.CORS_MAX_AGE_IN_SECONDS = exports.CORS_ALLOWED_HEADERS = exports.CORS_ALLOWED_METHODS = exports.REQUEST_ID_COOKIE_MAX_AGE = exports.SEQUELIZE_SEEDER_META_TABLE_NAME = exports.SEQUELIZE_META_TABLE_NAME = exports.SEEDERS_DIR = exports.MIGRATIONS_DIR = exports.MODELS_DIR = exports.SCHEMA_SNAPSHOTS_DIR = exports.SCHEMAS_DIR = exports.ENV_VAR_DIR = exports.LOG_DIR = exports.BASE_DIR = void 0;
 const path_1 = __importDefault(require("path"));
 // Database constants
 exports.BASE_DIR = process.cwd();
@@ -28,3 +28,4 @@ exports.REQUEST_RATE_LIMITTER_OPTIONS = {
     max_requests: 50,
     message: "⏳ Too many requests from this IP, please try again later"
 };
+exports.ALPHABET_CORPUS = ["6", ";", "s", "[", "w", "*", "n", "K", "h", "U", "#", "P", "T", "&", "M", "2", "}", "x", ")", "{", "|", "i", "%", "m", ":", "E", "q", "?", "0", "@", "1", "v", "A", "W", "<", "y", "Y", "4", "5", ".", "e", "G", ",", "D", "7", "I", "j", ">", "g", "t", "k", "c", "V", "9", "J", "L", "u", "H", "b", "Z", "+", '"', "'", "a", "f"];

package/dist/types/main.d.ts

@@ -3,3 +3,4 @@ export * from "./migration_type";
 export * from "./util_type";
 export * from "./middle_ware_type";
 export * from "./database_type";
+export * from "./module_type";

package/dist/types/main.js

@@ -19,3 +19,4 @@ __exportStar(require("./migration_type"), exports);
 __exportStar(require("./util_type"), exports);
 __exportStar(require("./middle_ware_type"), exports);
 __exportStar(require("./database_type"), exports);
+__exportStar(require("./module_type"), exports);

package/dist/types/module_type.d.ts

@@ -0,0 +1,12 @@
+export interface ServiceMethodRetrunInterface<T> {
+    status: boolean;
+    msg: string;
+    data?: T;
+    status_code?: number;
+}
+export interface ValidatorMethodReturnInterface<T> {
+    v_state: boolean;
+    v_msg: string;
+    v_data?: T;
+    v_code?: number;
+}

package/dist/types/module_type.js

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

package/dist/utils/encryptor_decryptor_util.d.ts

@@ -0,0 +1,27 @@
+declare class EncryptorDecryptorUtil {
+    readonly name = "encrypt_decrypt_util";
+    private static instance;
+    readonly encrypt_secret_key?: string;
+    readonly corpus_shift_key: number;
+    readonly corpus: string[];
+    private algorithm;
+    private iv_length;
+    private jwt_secret_key?;
+    private logger;
+    private env_manger;
+    private constructor();
+    private verifyJWT;
+    static getInstance(encrypt_secret_key?: string): EncryptorDecryptorUtil;
+    static generateEncryptSecretKey(): string;
+    setEncryptSecretKey(key?: string): string;
+    encryptV1<T>(data: T): string;
+    decryptV1<T>(encrypted_data: string): T;
+    encryptV2<T>(data: T): string;
+    decryptV2<T>(encrypted_data: string): T | string;
+    compressPayload<T = string>(payload: T): string;
+    decompressPayload<T = string>(compressed_base64: string): T;
+    dataToTimedEncryptedString<T = string>(data: T, time_in_mins?: number): string;
+    timedEncryptedStringToData<T>(encrypted_string: string, ignore_expiration?: boolean): T | string | boolean;
+    hashString(input: string, algorithm?: string): string;
+}
+export default EncryptorDecryptorUtil;

package/dist/utils/encryptor_decryptor_util.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const zlib_1 = __importDefault(require("zlib"));
+const logger_util_1 = __importDefault(require("./logger_util"));
+const env_manager_util_1 = __importDefault(require("./env_manager_util"));
+const constants_1 = require("../config/constants");
+class EncryptorDecryptorUtil {
+    name = "encrypt_decrypt_util";
+    static instance;
+    encrypt_secret_key;
+    corpus_shift_key;
+    corpus = constants_1.ALPHABET_CORPUS;
+    algorithm = "aes-256-cbc";
+    iv_length = 16;
+    jwt_secret_key;
+    logger = new logger_util_1.default(this.name);
+    env_manger = env_manager_util_1.default.getInstance();
+    constructor(encrypt_secret_key) {
+        this.encrypt_secret_key = this.setEncryptSecretKey(encrypt_secret_key);
+        this.corpus_shift_key = this.env_manger.getEnvVar("CORPUS_SHIFT_KEY", 4) || 4;
+        this.jwt_secret_key = this.env_manger.getEnvVar("JWT_SECRET_KEY", "");
+        if (!this.encrypt_secret_key ||
+            !this.jwt_secret_key) {
+            const msg = `Secret Key Variables are missing please set in envrionment variable`;
+            const data = { encrypt_secret_key: this.encrypt_secret_key, jwt_secret_key: this.jwt_secret_key };
+            this.logger.error(msg, { data });
+            throw new Error(msg);
+        }
+    }
+    verifyJWT(jwt_string, secret_key, ignore_expiration = false) {
+        try {
+            const jwt_data = jsonwebtoken_1.default.verify(jwt_string, secret_key, { ignoreExpiration: ignore_expiration });
+            return jwt_data;
+        }
+        catch (error) {
+            this.logger.error(`[${this.name}] JWT string has expired`, { jwt_string, ignore_expiration });
+            return null;
+        }
+    }
+    // ✅ Global access point
+    static getInstance(encrypt_secret_key) {
+        if (!EncryptorDecryptorUtil.instance) {
+            EncryptorDecryptorUtil.instance = new EncryptorDecryptorUtil(encrypt_secret_key);
+        }
+        return EncryptorDecryptorUtil.instance;
+    }
+    // ==============================
+    // AES-256 (V1)
+    // ==============================
+    // Method to generate Encrypt Secret Key
+    static generateEncryptSecretKey() {
+        return crypto_1.default.randomBytes(32).toString("hex");
+    }
+    // Method to set encrypt secret key
+    setEncryptSecretKey(key) {
+        const secret_key = key || this.env_manger.getEnvVar("ENCRYPT_SECRET_KEY", "");
+        if (!secret_key || Buffer.from(secret_key, "hex").length !== 32) {
+            throw new Error("Invalid encryption key check it is set in environment file and the length is correct. Expected 32 bytes (64 hex characters).");
+        }
+        return secret_key;
+    }
+    // Method to convert data type T to encrypted string s using encryption method V1
+    encryptV1(data) {
+        if (!this.encrypt_secret_key) {
+            throw new Error("Encryption key not set. Use setEncryptionV1Key() first.");
+        }
+        const iv = crypto_1.default.randomBytes(this.iv_length);
+        const iv_base_64 = iv.toString("base64");
+        const buffer_data = Buffer.from(this.encrypt_secret_key, "hex");
+        const cipher = crypto_1.default.createCipheriv(this.algorithm, buffer_data, iv);
+        const stringified_data = typeof data === "string" ? data : JSON.stringify(data);
+        let encrypted = cipher.update(stringified_data, "utf-8", "base64");
+        encrypted += cipher.final("base64");
+        return `${iv_base_64}:${encrypted}`;
+    }
+    // Method to convert encrypted string data s to data type T using decryption method v1
+    decryptV1(encrypted_data) {
+        try {
+            if (!this.encrypt_secret_key) {
+                throw new Error("Encryption key not set. Use setEncryptionV1Key() first.");
+            }
+            const [iv_base_64, encrypted] = encrypted_data.split(":");
+            const iv = Buffer.from(iv_base_64, "base64");
+            const buffer_data = Buffer.from(this.encrypt_secret_key, "hex");
+            const decipher = crypto_1.default.createDecipheriv(this.algorithm, buffer_data, iv);
+            let decrypted = decipher.update(encrypted, "base64", "utf-8");
+            decrypted += decipher.final("utf-8");
+            try {
+                return JSON.parse(decrypted);
+            }
+            catch {
+                return decrypted;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    // ==============================
+    // Shift Cipher (V2)
+    // ==============================
+    // Method to convert data type T to encrypted string s using encryption method v2
+    encryptV2(data) {
+        if (!this.corpus || !this.corpus_shift_key) {
+            throw new Error("Environment not initialized.");
+        }
+        const input_data = typeof data === "string" ? data : JSON.stringify(data);
+        const array_input_data = input_data.split("");
+        let encrypted_data = "";
+        for (const char of array_input_data) {
+            const index = this.corpus.indexOf(char);
+            if (index !== -1) {
+                const new_index = (index + this.corpus_shift_key) % this.corpus.length;
+                encrypted_data += this.corpus[new_index];
+            }
+            else {
+                encrypted_data += char;
+            }
+        }
+        return encrypted_data;
+    }
+    // Method to convert encrypted string data s to data type T using decryption method v1
+    decryptV2(encrypted_data) {
+        try {
+            if (!this.corpus || !this.corpus_shift_key) {
+                throw new Error("Environment not initialized.");
+            }
+            const array_input_data = encrypted_data.split("");
+            let decrypted_data = "";
+            for (const char of array_input_data) {
+                const index = this.corpus.indexOf(char);
+                if (index !== -1) {
+                    const calc_shift = (index - this.corpus_shift_key);
+                    const new_index = calc_shift < 0 ? (this.corpus.length + calc_shift) : calc_shift;
+                    decrypted_data += this.corpus[new_index];
+                }
+                else {
+                    decrypted_data += char; // keep characters not in corpus
+                }
+            }
+            try {
+                return JSON.parse(decrypted_data);
+            }
+            catch {
+                return decrypted_data;
+            }
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    // ==============================
+    // Compression
+    // ==============================
+    // Method to help compress a data payload
+    compressPayload(payload) {
+        const stringified_data = typeof payload === "string" ? payload : JSON.stringify(payload);
+        const buffer = Buffer.from(stringified_data);
+        const compression_config = { level: 9, strategy: zlib_1.default.constants.Z_DEFAULT_STRATEGY };
+        const compressed = zlib_1.default.deflateSync(buffer, compression_config);
+        return compressed.toString("base64");
+    }
+    // Method to decompress payload
+    decompressPayload(compressed_base64) {
+        const buffer = Buffer.from(compressed_base64, "base64");
+        const json_string = zlib_1.default.inflateSync(buffer).toString();
+        try {
+            return JSON.parse(json_string);
+        }
+        catch (error) {
+            return json_string;
+        }
+    }
+    // ==============================
+    // JWT + Compression
+    // ==============================
+    // Method to convert a data payload  to a time encrypted string
+    dataToTimedEncryptedString(data, time_in_mins = 60) {
+        const encoded_data = this.compressPayload(this.encryptV2(data));
+        if (!this.jwt_secret_key) {
+            throw new Error("No secret key provided");
+        }
+        const json_web_config = { expiresIn: time_in_mins * 60 };
+        const jwt_token = jsonwebtoken_1.default.sign({ encoded_data }, this.jwt_secret_key, json_web_config);
+        return this.compressPayload(jwt_token);
+    }
+    // Method to convert times encrypted string data s to data payload T
+    timedEncryptedStringToData(encrypted_string, ignore_expiration = false) {
+        try {
+            if (!this.jwt_secret_key) {
+                throw new Error("No secret key provided");
+            }
+            const uncompressed_string = this.decompressPayload(encrypted_string);
+            if (!uncompressed_string) {
+                return false;
+            }
+            const jwt_data = this.verifyJWT(uncompressed_string, this.jwt_secret_key, ignore_expiration);
+            if (!jwt_data) {
+                return false;
+            }
+            const decompressed_data = this.decompressPayload(jwt_data?.encoded_data);
+            if (!decompressed_data) {
+                return false;
+            }
+            const decoded_data = this.decryptV2(decompressed_data);
+            return decoded_data || false;
+        }
+        catch (error) {
+            this.logger.error(`[${this.name}] Failed to convert encrypted string to data`, { encrypted_string, error });
+            return false;
+        }
+    }
+    // ==============================
+    // Hash
+    // ==============================
+    // Method to hash a string
+    hashString(input, algorithm = "sha256") {
+        return crypto_1.default.createHash(algorithm).update(input).digest("hex");
+    }
+}
+exports.default = EncryptorDecryptorUtil;

package/dist/utils/main.d.ts

@@ -7,4 +7,5 @@ import ServerUtil from "./server_util";
 import SafeExecuteUtil from "./safe_execute_util";
 import InMemoryCache from "./cache_util";
 import UUIDGeneratorUtil from "./uuid_gen_util";
-export { LoggerUtil, InputTransformerUtil, InputValidatorUtil, EnvManagerUtil, SqlFormatterUtil, ServerUtil, SafeExecuteUtil, InMemoryCache, UUIDGeneratorUtil };
+import EncryptorDecryptorUtil from "./encryptor_decryptor_util";
+export { LoggerUtil, InputTransformerUtil, InputValidatorUtil, EnvManagerUtil, SqlFormatterUtil, ServerUtil, SafeExecuteUtil, InMemoryCache, UUIDGeneratorUtil, EncryptorDecryptorUtil };

package/dist/utils/main.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UUIDGeneratorUtil = exports.InMemoryCache = exports.SafeExecuteUtil = exports.ServerUtil = exports.SqlFormatterUtil = exports.EnvManagerUtil = exports.InputValidatorUtil = exports.InputTransformerUtil = exports.LoggerUtil = void 0;
+exports.EncryptorDecryptorUtil = exports.UUIDGeneratorUtil = exports.InMemoryCache = exports.SafeExecuteUtil = exports.ServerUtil = exports.SqlFormatterUtil = exports.EnvManagerUtil = exports.InputValidatorUtil = exports.InputTransformerUtil = exports.LoggerUtil = void 0;
 const logger_util_1 = __importDefault(require("./logger_util"));
 exports.LoggerUtil = logger_util_1.default;
 const input_transformer_util_1 = __importDefault(require("./input_transformer_util"));
@@ -22,3 +22,5 @@ const cache_util_1 = __importDefault(require("./cache_util"));
 exports.InMemoryCache = cache_util_1.default;
 const uuid_gen_util_1 = __importDefault(require("./uuid_gen_util"));
 exports.UUIDGeneratorUtil = uuid_gen_util_1.default;
+const encryptor_decryptor_util_1 = __importDefault(require("./encryptor_decryptor_util"));
+exports.EncryptorDecryptorUtil = encryptor_decryptor_util_1.default;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fiberx-backend-toolkit",
-    "version": "0.0.34",
+    "version": "0.0.36",
     "description": "A TypeScript backend toolkit providing shared domain logic, infrastructure helpers, and utilities for FiberX server-side applications and services.",
     "type": "commonjs",
     "main": "./dist/index.js",