lapeh 2.3.6 → 2.3.8

package/dist/lib/utils/response.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSuccess = sendSuccess;
+exports.sendFastSuccess = sendFastSuccess;
+exports.sendError = sendError;
+const logger_1 = require("./logger");
+function toJsonSafe(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => toJsonSafe(item));
+    }
+    if (value && typeof value === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = toJsonSafe(val);
+        }
+        return result;
+    }
+    return value;
+}
+function sendSuccess(res, statusCode, message, data) {
+    const body = { status: "success", message, data };
+    return res.status(statusCode).json(toJsonSafe(body));
+}
+/**
+ * Mengirim response sukses dengan performa tinggi menggunakan Schema Serialization (Fastify-style).
+ * Melewati proses JSON.stringify standar yang lambat.
+ *
+ * @param serializer Fungsi serializer yang sudah dicompile dari src/core/serializer
+ */
+function sendFastSuccess(res, statusCode, serializer, data) {
+    // Set header manual karena kita mengirim raw string
+    res.setHeader("Content-Type", "application/json");
+    res.status(statusCode);
+    // Serializer mengembalikan string JSON
+    const jsonString = serializer(data);
+    return res.send(jsonString);
+}
+function sendError(res, statusCode, message, errors) {
+    // Log the error
+    if (statusCode >= 500) {
+        logger_1.Log.error(message, { statusCode, errors });
+    }
+    else if (statusCode >= 400) {
+        logger_1.Log.warn(message, { statusCode, errors });
+    }
+    const body = { status: "error", message };
+    if (errors !== undefined) {
+        body.errors = errors;
+    }
+    return res.status(statusCode).json(toJsonSafe(body));
+}

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 / Laravel-style rules
+     * @param messages Optional custom error messages (Laravel style: 'field.rule' => 'message')
+     */
+    static make(data: any, schema: ZodSchema<any> | Record<string, any>, messages?: Record<string, string>): Validator;
+    private static parseLaravelRule;
+    /**
+     * 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;AAGvD,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,gBAAgB;IAyN/B;;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,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = void 0;
+const zod_1 = require("zod");
+const database_1 = require("../core/database");
+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 (schema instanceof zod_1.ZodSchema) {
+            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 / Laravel-style rules
+     * @param messages Optional custom error messages (Laravel style: 'field.rule' => 'message')
+     */
+    static make(data, schema, messages = {}) {
+        if (schema instanceof zod_1.ZodSchema) {
+            return new Validator(data, schema, messages);
+        }
+        const parsedSchema = {};
+        const sameRules = [];
+        for (const [key, rule] of Object.entries(schema)) {
+            if (rule instanceof zod_1.ZodSchema) {
+                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.parseLaravelRule(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 parseLaravelRule(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
+                    const [table, column = "id", ignoreValue, ignoreColumn = "id"] = params;
+                    schema = schema.refine(async (val) => {
+                        if (!val)
+                            return true;
+                        const where = { [column]: val };
+                        if (ignoreValue && ignoreValue !== "null") {
+                            // Try to handle numeric IDs if ignoreValue looks numeric
+                            const ignoreVal = !isNaN(Number(ignoreValue))
+                                ? Number(ignoreValue)
+                                : ignoreValue;
+                            // But Prisma uses BigInt for IDs often in this project?
+                            // Let's assume string or number is fine, user can cast if needed.
+                            // In this project, IDs are BigInt.
+                            if (typeof ignoreVal === "number" ||
+                                /^\d+$/.test(String(ignoreValue))) {
+                                where[ignoreColumn] = { not: BigInt(ignoreValue) };
+                            }
+                            else {
+                                where[ignoreColumn] = { not: ignoreValue };
+                            }
+                        }
+                        try {
+                            // @ts-ignore
+                            const count = await database_1.prisma[table].count({ where });
+                            return count === 0;
+                        }
+                        catch (e) {
+                            console.error(`Validator unique check failed for table ${table}:`, e);
+                            return false;
+                        }
+                    }, { message: `The ${column} has already been taken.` });
+                    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/prisma/seed.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=seed.d.ts.map

package/dist/prisma/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../prisma/seed.ts"],"names":[],"mappings":""}