fiberx-backend-toolkit 1.0.14 → 1.0.15

package/dist/utils/input_validator_util.d.ts

@@ -11,6 +11,14 @@ declare class InputValidatorUtil {
     private static readonly uuid_regex_reg_exp;
     private static readonly custom_uuid_regex_reg_exp;
     private static get env_manager();
+    static isValidDecimalString(value: string | null | undefined, max_whole_digits?: number, max_fraction_digits?: number, allow_zero?: boolean): boolean;
+    static compareDecimalStrings(first_value: string, second_value: string): number;
+    static isValidUpperCode(value: string, min_length?: number, max_length?: number): boolean;
+    static hasUnsafeControlCharacter(value: string): boolean;
+    static stableSerialize(value: unknown): string;
+    static hashString(value: string, algorithm?: "sha256" | "sha384" | "sha512"): string;
+    static hasSensitiveObjectKey(value: unknown): boolean;
+    static getJsonByteLength(value: unknown): number;
     static isValidateIn: (value: any, allowed: any[]) => boolean;
     /** ✅ Check member roles */
     static isAdmin(name: string): boolean;

package/dist/utils/input_validator_util.js

@@ -25,6 +25,87 @@ class InputValidatorUtil {
     static get env_manager() {
         return env_manager_util_1.default.getInstance();
     }
+    // Method to validate a non-negative decimal string with bounded precision.
+    static isValidDecimalString(value, max_whole_digits = 18, max_fraction_digits = 18, allow_zero = true) {
+        if (value === null ||
+            value === undefined ||
+            max_whole_digits < 1 ||
+            max_fraction_digits < 0) {
+            return false;
+        }
+        const decimal_pattern = new RegExp(`^\\d{1,${max_whole_digits}}${max_fraction_digits > 0 ? `(?:\\.\\d{1,${max_fraction_digits}})?` : ""}$`);
+        return (decimal_pattern.test(value) &&
+            (allow_zero || this.compareDecimalStrings(value, "0") > 0));
+    }
+    // Method to compare unsigned decimal strings without floating-point conversion.
+    static compareDecimalStrings(first_value, second_value) {
+        const normalize_value = (value) => {
+            const [whole_value = "0", fraction_value = ""] = value.split(".");
+            return [whole_value.replace(/^0+(?=\d)/, "") || "0", fraction_value.replace(/0+$/, "")];
+        };
+        const [first_whole, first_fraction] = normalize_value(first_value);
+        const [second_whole, second_fraction] = normalize_value(second_value);
+        if (first_whole.length !== second_whole.length) {
+            return first_whole.length > second_whole.length ? 1 : -1;
+        }
+        if (first_whole !== second_whole) {
+            return first_whole > second_whole ? 1 : -1;
+        }
+        const fraction_length = Math.max(first_fraction.length, second_fraction.length);
+        const normalized_first_fraction = first_fraction.padEnd(fraction_length, "0");
+        const normalized_second_fraction = second_fraction.padEnd(fraction_length, "0");
+        if (normalized_first_fraction === normalized_second_fraction) {
+            return 0;
+        }
+        return normalized_first_fraction > normalized_second_fraction ? 1 : -1;
+    }
+    // Method to validate an uppercase code containing letters, numbers, underscores, or hyphens.
+    static isValidUpperCode(value, min_length = 2, max_length = 80) {
+        if (min_length < 1 ||
+            max_length < min_length ||
+            value.length < min_length ||
+            value.length > max_length) {
+            return false;
+        }
+        return /^[A-Z0-9_-]+$/.test(value);
+    }
+    // Method to detect unsafe control characters while allowing tab and line breaks.
+    static hasUnsafeControlCharacter(value) {
+        return [...value].some((character) => {
+            const character_code = character.charCodeAt(0);
+            return character_code < 32 && ![9, 10, 13].includes(character_code);
+        });
+    }
+    // Method to serialize JSON-compatible data using stable object-key ordering.
+    static stableSerialize(value) {
+        if (Array.isArray(value)) {
+            return `[${value.map((item) => this.stableSerialize(item)).join(",")}]`;
+        }
+        if (value && typeof value === "object") {
+            const entries = Object.entries(value).sort(([first_key], [second_key]) => first_key.localeCompare(second_key));
+            return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${this.stableSerialize(item)}`).join(",")}}`;
+        }
+        return JSON.stringify(value) ?? "null";
+    }
+    // Method to hash a string with a supported cryptographic digest algorithm.
+    static hashString(value, algorithm = "sha256") {
+        return crypto_1.default.createHash(algorithm).update(value).digest("hex");
+    }
+    // Method to detect sensitive property names recursively in object or array data.
+    static hasSensitiveObjectKey(value) {
+        if (Array.isArray(value)) {
+            return value.some((item) => this.hasSensitiveObjectKey(item));
+        }
+        if (!value || typeof value !== "object") {
+            return false;
+        }
+        const sensitive_key_pattern = /(password|secret|credential|token|api[_-]?key|card|cvv|pin)/i;
+        return Object.entries(value).some(([key, item]) => sensitive_key_pattern.test(key) || this.hasSensitiveObjectKey(item));
+    }
+    // Method to return the UTF-8 byte size of JSON-compatible data.
+    static getJsonByteLength(value) {
+        return Buffer.byteLength(JSON.stringify(value), "utf8");
+    }
     static isValidateIn = (value, allowed) => allowed.includes(value);
     /** ✅ Check member roles */
     static isAdmin(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fiberx-backend-toolkit",
-    "version": "1.0.14",
+    "version": "1.0.15",
     "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",