fiberx-backend-toolkit 0.1.8 → 0.1.10

package/dist/types/main.d.ts

@@ -7,3 +7,4 @@ export * from "./module_type";
 export * from "./express_decelaration";
 export * from "./rbac_type";
 export * from "./mailer_type";
+export * from "./validator_type";

package/dist/types/main.js

@@ -23,3 +23,4 @@ __exportStar(require("./module_type"), exports);
 __exportStar(require("./express_decelaration"), exports);
 __exportStar(require("./rbac_type"), exports);
 __exportStar(require("./mailer_type"), exports);
+__exportStar(require("./validator_type"), exports);

package/dist/types/validator_type.d.ts

@@ -0,0 +1,15 @@
+export type QueryValueType = "string" | "number" | "boolean" | "enum" | "date" | "date-range" | "array" | "object";
+export interface QueryFieldSchemaInterface<T = any> {
+    key: string;
+    type: QueryValueType;
+    required?: boolean;
+    default?: T;
+    enum_values?: readonly any[];
+    min?: number;
+    max?: number;
+}
+export interface QueryValidationResultInterface<T> {
+    v_state: boolean;
+    v_msg: string;
+    v_data?: T;
+}

package/dist/types/validator_type.js

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

package/dist/utils/input_validator_util.d.ts

@@ -51,5 +51,6 @@ declare class InputValidatorUtil {
     static dirExists(directory: string, create_directory?: boolean, return_dir_path?: boolean): boolean | string;
     static isSafeHashCompare(a: string, b: string): boolean;
     static isDeepEqual(a: any, b: any): boolean;
+    static hasInputChanged(new_input: Record<string, any>, existing_data: Record<string, any>, keys_to_check: string[]): boolean;
 }
 export default InputValidatorUtil;

package/dist/utils/input_validator_util.js

@@ -174,5 +174,40 @@ class InputValidatorUtil {
         }
         return false;
     }
+    static hasInputChanged(new_input, existing_data, keys_to_check) {
+        // Normalize values (booleans, "true"/"false", "1"/"0", null-like)
+        const normalize = (val) => {
+            if (val === "true")
+                return true;
+            if (val === "false")
+                return false;
+            if (val === "1")
+                return true;
+            if (val === "0")
+                return false;
+            return val;
+        };
+        // Utility to get nested value by dot notation
+        const getNestedValue = (obj, path) => {
+            return path.split('.').reduce((acc, part) => {
+                if (acc && typeof acc === 'object' && part in acc) {
+                    return acc[part];
+                }
+                return undefined;
+            }, obj);
+        };
+        for (const key of keys_to_check) {
+            if (!(key in new_input)) {
+                continue;
+            }
+            const new_val = normalize(getNestedValue(new_input, key));
+            const old_val = normalize(getNestedValue(existing_data, key));
+            if (!InputValidatorUtil.isDeepEqual(new_val, old_val)) {
+                console.log("🔺 CHANGED:", key, { new_val, old_val });
+                return true;
+            }
+        }
+        return false;
+    }
 }
 exports.default = InputValidatorUtil;

package/dist/validators/main.d.ts

@@ -0,0 +1,2 @@
+import QueryValidatorUtil from "./query_validator_util";
+export { QueryValidatorUtil };

package/dist/validators/main.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryValidatorUtil = void 0;
+const query_validator_util_1 = __importDefault(require("./query_validator_util"));
+exports.QueryValidatorUtil = query_validator_util_1.default;

package/dist/validators/query_validator_util.d.ts

@@ -0,0 +1,6 @@
+import { QueryFieldSchemaInterface, QueryValidationResultInterface } from "../types/validator_type";
+declare class QueryValidatorUtil {
+    private constructor();
+    static validate<T extends Record<string, any>>(query: Record<string, any>, schema: QueryFieldSchemaInterface[]): QueryValidationResultInterface<T>;
+}
+export default QueryValidatorUtil;

package/dist/validators/query_validator_util.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+class QueryValidatorUtil {
+    constructor() { }
+    static validate(query, schema) {
+        const result = {};
+        for (const field of schema) {
+            const raw_value = query[field.key];
+            // Handle missing value
+            if (raw_value === undefined || raw_value === null || raw_value === "") {
+                if (field.required) {
+                    return {
+                        v_state: false,
+                        v_msg: `missing_required_query_${field.key}`
+                    };
+                }
+                result[field.key] = field.default ?? null;
+                continue;
+            }
+            switch (field.type) {
+                case "string": {
+                    result[field.key] = String(raw_value);
+                    break;
+                }
+                case "number": {
+                    const num = Number(raw_value);
+                    if (isNaN(num)) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    if (field.min !== undefined && num < field.min) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    if (field.max !== undefined && num > field.max) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    result[field.key] = num;
+                    break;
+                }
+                case "boolean": {
+                    const val = String(raw_value).toLowerCase();
+                    if (!["true", "false"].includes(val)) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    result[field.key] = val === "true";
+                    break;
+                }
+                case "enum": {
+                    if (!field.enum_values?.includes(raw_value)) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    result[field.key] = raw_value;
+                    break;
+                }
+                case "date": {
+                    const parsed = (0, dayjs_1.default)(raw_value);
+                    if (!parsed.isValid()) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    // Return as native Date (recommended for DB usage)
+                    result[field.key] = parsed.toDate();
+                    break;
+                }
+                case "date-range": {
+                    const parts = String(raw_value).split(",");
+                    if (parts.length !== 2) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    const start = (0, dayjs_1.default)(parts[0]);
+                    const end = (0, dayjs_1.default)(parts[1]);
+                    if (!start.isValid() || !end.isValid()) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    // ✅ Ensure end is after start
+                    if (!end.isAfter(start)) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}_range` };
+                    }
+                    result[field.key] = {
+                        start_date: start.toDate(),
+                        end_date: end.toDate()
+                    };
+                    break;
+                }
+                case "array": {
+                    if (!Array.isArray(raw_value)) {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    result[field.key] = raw_value;
+                    break;
+                }
+                case "object": {
+                    if (typeof raw_value !== "object") {
+                        return { v_state: false, v_msg: `invalid_query_${field.key}` };
+                    }
+                    result[field.key] = raw_value;
+                    break;
+                }
+            }
+        }
+        return {
+            v_state: true,
+            v_msg: "valid_query_params",
+            v_data: result
+        };
+    }
+}
+exports.default = QueryValidatorUtil;

package/package.json

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