fiberx-backend-toolkit 0.1.7 → 0.1.9

package/dist/code_templates/sequelize_code_template.js

@@ -431,7 +431,7 @@ ${attributes}
             ${schema_model_name}Schema.columns,
             {
                 sequelize,
-                table_name: ${schema_model_name}Schema.table_name,
+                tableName: ${schema_model_name}Schema.table_name,
                 modelName: ${schema_model_name}Schema.model_name,
                 timestamps: ${schema_model_name}Schema.timestamps,
                 indexes: ${schema_model_name}Schema.indexes,

package/dist/middle_ware/authentication_middle_ware.d.ts

@@ -19,5 +19,6 @@ declare class AuthenicationMiddleWare<TRequestInfo extends DefaultRequestInfo =
     requireNoAuth(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
     requirePartialAuth(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
     requireFullAuth(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
+    requireAppAuthMiddleWareMethod(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
 }
 export default AuthenicationMiddleWare;

package/dist/middle_ware/authentication_middle_ware.js

@@ -112,6 +112,13 @@ class AuthenicationMiddleWare {
         return this.options?.requireFullAuthMiddleWareMethod(req, res, next);
     }
     ;
+    async requireAppAuthMiddleWareMethod(req, res, next) {
+        if (!this.options?.requireAppAuthMiddleWareMethod) {
+            return next();
+        }
+        return this.options?.requireAppAuthMiddleWareMethod(req, res, next);
+    }
+    ;
 }
 __decorate([
     main_1.SafeExecuteUtil.safeExecuteReturn("authentication_middle_ware", null),
@@ -179,4 +186,10 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object, Function]),
     __metadata("design:returntype", Promise)
 ], AuthenicationMiddleWare.prototype, "requireFullAuth", null);
+__decorate([
+    main_1.SafeExecuteUtil.safeExecuteThrow("authentication_middle_ware"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Function]),
+    __metadata("design:returntype", Promise)
+], AuthenicationMiddleWare.prototype, "requireAppAuthMiddleWareMethod", null);
 exports.default = AuthenicationMiddleWare;

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/middle_ware_type.d.ts

@@ -90,4 +90,5 @@ export interface AuthenticatorOptions<TRequestInfo extends DefaultRequestInfo =
     requireNoAuthMiddleWareMethod(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
     requirePartialAuthMiddleWareMethod(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
     requireFullAuthMiddleWareMethod(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
+    requireAppAuthMiddleWareMethod(req: Request, res: Response, next: NextFunction): Promise<void | Response>;
 }

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.7",
+    "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",