lapeeh 1.0.11 → 1.0.13

package/dist/lib/utils/validator.d.ts

@@ -0,0 +1,38 @@
+import { ZodSchema } from "zod";
+export declare class Validator {
+    private data;
+    private schema;
+    private customMessages;
+    private result;
+    private errorResult;
+    private hasRun;
+    constructor(data: any, schema: ZodSchema<any> | Record<string, any>, messages?: Record<string, string>);
+    /**
+     * Create a new Validator instance
+     * @param data The input data to validate
+     * @param schema Zod schema or object of Zod schemas / string-based rules
+     * @param messages Optional custom error messages (style: 'field.rule' => 'message')
+     */
+    static make(data: any, schema: ZodSchema<any> | Record<string, any>, messages?: Record<string, string>): Validator;
+    private static parseStringRule;
+    /**
+     * Check if validation fails
+     */
+    fails(): Promise<boolean>;
+    /**
+     * Check if validation passes
+     */
+    passes(): Promise<boolean>;
+    /**
+     * Get the validation errors
+     */
+    errors(): any;
+    /**
+     * Get the validated data
+     */
+    validated(): Promise<any>;
+    private run;
+    private formatErrors;
+    private getCustomMessage;
+}
+//# sourceMappingURL=validator.d.ts.map

package/dist/lib/utils/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../lib/utils/validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,SAAS,EAAsB,MAAM,KAAK,CAAC;AAWvD,qBAAa,SAAS;IACpB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAkB;gBAG9B,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5C,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM;IAavC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CACT,IAAI,EAAE,GAAG,EACT,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5C,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM;IAiDvC,OAAO,CAAC,MAAM,CAAC,eAAe;IAsL9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAK/B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAIhC;;OAEG;IACH,MAAM;IAKN;;OAEG;IACG,SAAS;YAUD,GAAG;IAgBjB,OAAO,CAAC,YAAY;IAuBpB,OAAO,CAAC,gBAAgB;CAoDzB"}

package/dist/lib/utils/validator.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const zod_1 = require("zod");
+function isZodSchema(schema) {
+    return (schema instanceof zod_1.ZodSchema ||
+        (schema &&
+            typeof schema === "object" &&
+            typeof schema.safeParseAsync === "function"));
+}
+class Validator {
+    constructor(data, schema, messages = {}) {
+        this.result = null;
+        this.errorResult = null;
+        this.hasRun = false;
+        this.data = data;
+        this.customMessages = messages;
+        // If it's a raw object, wrap it in z.object()
+        if (isZodSchema(schema)) {
+            this.schema = schema;
+        }
+        else {
+            this.schema = zod_1.z.object(schema);
+        }
+    }
+    /**
+     * Create a new Validator instance
+     * @param data The input data to validate
+     * @param schema Zod schema or object of Zod schemas / string-based rules
+     * @param messages Optional custom error messages (style: 'field.rule' => 'message')
+     */
+    static make(data, schema, messages = {}) {
+        if (isZodSchema(schema)) {
+            return new Validator(data, schema, messages);
+        }
+        const parsedSchema = {};
+        const sameRules = [];
+        for (const [key, rule] of Object.entries(schema)) {
+            if (isZodSchema(rule)) {
+                parsedSchema[key] = rule;
+            }
+            else if (typeof rule === "string" || Array.isArray(rule)) {
+                const ruleStr = Array.isArray(rule) ? rule.join("|") : rule;
+                // Check for 'same:target'
+                const parts = ruleStr.split("|");
+                for (const part of parts) {
+                    const [name, args] = part.split(":");
+                    if (name === "same" && args) {
+                        sameRules.push({ field: key, target: args });
+                    }
+                }
+                parsedSchema[key] = Validator.parseStringRule(rule);
+            }
+            else {
+                parsedSchema[key] = rule;
+            }
+        }
+        let objectSchema = zod_1.z.object(parsedSchema);
+        if (sameRules.length > 0) {
+            objectSchema = objectSchema.superRefine((val, ctx) => {
+                sameRules.forEach(({ field, target }) => {
+                    if (val[field] !== val[target]) {
+                        ctx.addIssue({
+                            code: zod_1.z.ZodIssueCode.custom,
+                            message: `The ${field} and ${target} must match.`,
+                            path: [field],
+                        });
+                    }
+                });
+            });
+        }
+        return new Validator(data, objectSchema, messages);
+    }
+    static parseStringRule(rule) {
+        const rules = Array.isArray(rule)
+            ? rule
+            : rule.split("|").map((r) => r.trim());
+        let schema = zod_1.z.string(); // Default base
+        let isOptional = false;
+        let isNullable = false;
+        // 1. Determine Base Type
+        const isFile = rules.includes("file") ||
+            rules.includes("image") ||
+            rules.includes("mimes");
+        if (rules.includes("numeric") || rules.includes("integer")) {
+            schema = zod_1.z.coerce.number();
+            if (rules.includes("integer"))
+                schema = schema.int();
+        }
+        else if (rules.includes("boolean")) {
+            schema = zod_1.z.boolean();
+        }
+        else if (rules.includes("array")) {
+            schema = zod_1.z.array(zod_1.z.any());
+        }
+        else if (rules.includes("date")) {
+            schema = zod_1.z.coerce.date();
+        }
+        else if (isFile) {
+            schema = zod_1.z.any().refine((val) => {
+                // Check if it looks like a Multer file object
+                return (typeof val === "object" &&
+                    val !== null &&
+                    "fieldname" in val &&
+                    "originalname" in val &&
+                    "encoding" in val &&
+                    "mimetype" in val &&
+                    "size" in val);
+            }, { message: "The field must be a file." });
+        }
+        else {
+            schema = zod_1.z.string();
+        }
+        // 2. Constraints & Modifiers
+        for (const r of rules) {
+            const [name, args] = r.split(":");
+            const params = args ? args.split(",") : [];
+            switch (name) {
+                case "email":
+                    if (schema instanceof zod_1.z.ZodString)
+                        schema = schema.email();
+                    break;
+                case "url":
+                    if (schema instanceof zod_1.z.ZodString)
+                        schema = schema.url();
+                    break;
+                case "uuid":
+                    if (schema instanceof zod_1.z.ZodString)
+                        schema = schema.uuid();
+                    break;
+                case "min":
+                    if (!isNaN(Number(params[0])))
+                        schema = schema.min(Number(params[0]));
+                    break;
+                case "max":
+                    if (!isNaN(Number(params[0]))) {
+                        if (isFile) {
+                            schema = schema.refine((val) => {
+                                if (!val)
+                                    return true; // Let nullable/optional handle nulls
+                                // But wait, if we are in strict mode (not nullable), we should fail?
+                                // No, max() usually doesn't enforce existence. required() does.
+                                // But here val is the file object.
+                                // If val is missing, and it's required, Base Type would have failed (if I revert Base Type).
+                                // So here val is likely a file object.
+                                return val.size <= Number(params[0]) * 1024;
+                            }, {
+                                message: `The file may not be greater than ${params[0]} kilobytes.`,
+                            });
+                        }
+                        else {
+                            schema = schema.max(Number(params[0]));
+                        }
+                    }
+                    break;
+                case "image":
+                    schema = schema.refine((val) => {
+                        if (!val || typeof val !== "object" || !val.mimetype)
+                            return false;
+                        return val.mimetype.startsWith("image/");
+                    }, { message: "The field must be an image." });
+                    break;
+                case "in":
+                    if (params.length > 0) {
+                        // For strings, we can use regex or refine
+                        schema = schema.refine((val) => params.includes(String(val)), {
+                            message: `The selected ${name} is invalid.`,
+                        });
+                    }
+                    break;
+                case "not_in":
+                    if (params.length > 0) {
+                        schema = schema.refine((val) => !params.includes(String(val)), {
+                            message: `The selected ${name} is invalid.`,
+                        });
+                    }
+                    break;
+                case "alpha":
+                    if (schema instanceof zod_1.z.ZodString)
+                        schema = schema.regex(/^[a-zA-Z]+$/, "The field must only contain letters.");
+                    break;
+                case "alpha_dash":
+                    if (schema instanceof zod_1.z.ZodString)
+                        schema = schema.regex(/^[a-zA-Z0-9_-]+$/, "The field must only contain letters, numbers, dashes, and underscores.");
+                    break;
+                case "alpha_num":
+                    if (schema instanceof zod_1.z.ZodString)
+                        schema = schema.regex(/^[a-zA-Z0-9]+$/, "The field must only contain letters and numbers.");
+                    break;
+                case "mimes":
+                    // For file validation
+                    schema = schema.refine((val) => {
+                        if (!val || typeof val !== "object" || !val.mimetype)
+                            return false;
+                        // params are extensions (jpg, png). We need to map to mimetypes or check loosely.
+                        // Simplification: check if mimetype includes one of the params
+                        // Or better: map extensions to mimetypes? Too big.
+                        // Let's assume params are extensions, and we check if mimetype matches.
+                        // Actually, typically mimes:jpg,png means we check extension or mime.
+                        // For now, let's just check if mimetype contains the string (imperfect but simple)
+                        // OR check originalname extension.
+                        const extension = val.originalname
+                            ?.split(".")
+                            .pop()
+                            ?.toLowerCase();
+                        return params.includes(extension);
+                    }, {
+                        message: `The file must be a file of type: ${params.join(", ")}.`,
+                    });
+                    break;
+                case "unique":
+                    // unique:table,column,ignore,idColumn
+                    // NOTE: Unique check requires Database implementation.
+                    // Since v3.0.0 (No-ORM), this rule is disabled by default.
+                    // You should implement your own uniqueness check manually in the controller.
+                    break;
+            }
+        }
+        // 3. Modifiers
+        const isRequired = rules.includes("required");
+        isNullable = rules.includes("nullable");
+        isOptional = rules.includes("sometimes") || !isRequired;
+        if (isNullable) {
+            schema = schema.nullable();
+        }
+        if (isOptional) {
+            schema = schema.optional();
+        }
+        return schema;
+    }
+    /**
+     * Check if validation fails
+     */
+    async fails() {
+        await this.run();
+        return this.errorResult !== null;
+    }
+    /**
+     * Check if validation passes
+     */
+    async passes() {
+        return !(await this.fails());
+    }
+    /**
+     * Get the validation errors
+     */
+    errors() {
+        // Should be called after fails()
+        return this.errorResult || {};
+    }
+    /**
+     * Get the validated data
+     */
+    async validated() {
+        await this.run();
+        if (this.errorResult) {
+            throw new Error("Validation failed. Check errors() before calling validated().");
+        }
+        return this.result;
+    }
+    async run() {
+        if (this.hasRun)
+            return;
+        this.hasRun = true;
+        // safeParseAsync to handle async refinements (like unique)
+        const parseResult = await this.schema.safeParseAsync(this.data);
+        if (parseResult.success) {
+            this.result = parseResult.data;
+            this.errorResult = null;
+        }
+        else {
+            this.result = null;
+            this.errorResult = this.formatErrors(parseResult.error);
+        }
+    }
+    formatErrors(error) {
+        // If we have custom messages, we try to apply them
+        if (Object.keys(this.customMessages).length > 0) {
+            error.issues = error.issues.map((issue) => {
+                const message = this.getCustomMessage(issue);
+                if (message) {
+                    return { ...issue, message };
+                }
+                return issue;
+            });
+        }
+        const flattened = error.flatten();
+        const errors = flattened.fieldErrors;
+        // Add formErrors if any
+        if (flattened.formErrors.length > 0) {
+            errors.formErrors = flattened.formErrors;
+        }
+        return errors;
+    }
+    getCustomMessage(issue) {
+        const path = issue.path.join(".");
+        let rule = "";
+        // Map Zod issue codes to "Laravel-like" rules for key lookup
+        switch (issue.code) {
+            case "invalid_type":
+                if (issue.received === "undefined" || issue.received === "null") {
+                    rule = "required";
+                }
+                else {
+                    // e.g. string, number, boolean
+                    rule = issue.expected;
+                }
+                break;
+            case "invalid_string":
+                if (typeof issue.validation === "string") {
+                    rule = issue.validation; // email, url, uuid, etc.
+                }
+                else {
+                    rule = "string";
+                }
+                break;
+            case "too_small":
+                rule = "min";
+                break;
+            case "too_big":
+                rule = "max";
+                break;
+            case "custom":
+                // Custom rules often have messages already, but we can override
+                // For unique, mimes, etc.
+                // We might need to inspect the message to guess the rule?
+                // Or just use the path.
+                rule = "custom";
+                break;
+            // Add more mappings as needed
+            default:
+                rule = issue.code;
+        }
+        // Try keys: "field.rule" -> "field"
+        const specificKey = `${path}.${rule}`;
+        if (this.customMessages[specificKey]) {
+            return this.customMessages[specificKey];
+        }
+        // Fallback for generic field message "field"
+        if (this.customMessages[path]) {
+            return this.customMessages[path];
+        }
+        return undefined;
+    }
+}
+exports.Validator = Validator;

package/dist/src/config/app.d.ts

@@ -0,0 +1,10 @@
+export declare const appConfig: {
+    name: string;
+    timeout: number;
+    compression: boolean;
+    rateLimit: {
+        windowMs: number;
+        max: number;
+    };
+};
+//# sourceMappingURL=app.d.ts.map

package/dist/src/config/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../../src/config/app.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;CAQrB,CAAC"}

package/dist/src/config/app.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appConfig = void 0;
+exports.appConfig = {
+    name: "lapeeh API",
+    timeout: 30000, // 30 seconds
+    compression: true,
+    rateLimit: {
+        windowMs: 15 * 60 * 1000, // 15 minutes
+        max: 100, // Limit each IP to 100 requests per windowMs
+    },
+};

package/dist/src/config/cors.d.ts

@@ -0,0 +1,6 @@
+export declare const corsConfig: {
+    origin: string;
+    credentials: boolean;
+    exposedHeaders: string[];
+};
+//# sourceMappingURL=cors.d.ts.map

package/dist/src/config/cors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cors.d.ts","sourceRoot":"","sources":["../../../src/config/cors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;CAItB,CAAC"}

package/dist/src/config/cors.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.corsConfig = void 0;
+exports.corsConfig = {
+    origin: process.env.CORS_ORIGIN || '*',
+    credentials: true,
+    exposedHeaders: ['x-access-token', 'x-access-expires-at'],
+};

package/dist/src/modules/Auth/auth.controller.d.ts

@@ -0,0 +1,11 @@
+import { Request, Response } from "express";
+export declare const ACCESS_TOKEN_EXPIRES_IN_SECONDS: number;
+export declare function register(req: Request, res: Response): Promise<void>;
+export declare function login(req: Request, res: Response): Promise<void>;
+export declare function me(req: Request, res: Response): Promise<void>;
+export declare function logout(_req: Request, res: Response): Promise<void>;
+export declare function refreshToken(req: Request, res: Response): Promise<void>;
+export declare function updateAvatar(req: Request, res: Response): Promise<void>;
+export declare function updatePassword(req: Request, res: Response): Promise<void>;
+export declare function updateProfile(req: Request, res: Response): Promise<void>;
+//# sourceMappingURL=auth.controller.d.ts.map

package/dist/src/modules/Auth/auth.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.controller.d.ts","sourceRoot":"","sources":["../../../../src/modules/Auth/auth.controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAU5C,eAAO,MAAM,+BAA+B,QAAmB,CAAC;AA4EhE,wBAAsB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBA0DzD;AAED,wBAAsB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBA6EtD;AAED,wBAAsB,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBAuDnD;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBASxD;AAED,wBAAsB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBAoE7D;AAED,wBAAsB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBAwD7D;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBA6C/D;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,iBAkD9D"}