fiberx-backend-toolkit 0.1.8 → 0.1.9

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/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.9",
     "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",