lapeh 2.3.6 → 2.3.8

package/dist/src/utils/logger.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const winston_1 = __importDefault(require("winston"));
+require("winston-daily-rotate-file");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const logDirectory = path_1.default.join(process.cwd(), "storage", "logs");
+// Ensure log directory exists
+if (!fs_1.default.existsSync(logDirectory)) {
+    fs_1.default.mkdirSync(logDirectory, { recursive: true });
+}
+const dailyRotateFileTransport = new winston_1.default.transports.DailyRotateFile({
+    filename: "lapeh-%DATE%.log",
+    dirname: logDirectory,
+    datePattern: "YYYY-MM-DD",
+    zippedArchive: true,
+    maxSize: "20m",
+    maxFiles: "3d",
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston_1.default.format.printf((info) => {
+        let log = `[${info.timestamp}] ${info.level.toUpperCase()}: ${info.message}`;
+        // Handle metadata (errors, etc)
+        const { timestamp, level, message, service, ...meta } = info;
+        if (Object.keys(meta).length > 0) {
+            // If meta has 'errors', nicely format it
+            if (meta.errors) {
+                log += `\nErrors: ${JSON.stringify(meta.errors, null, 2)}`;
+                delete meta.errors;
+            }
+            // If there are other meta properties remaining, log them
+            if (Object.keys(meta).length > 0 && !meta.stack && !meta.error) {
+                log += `\nMeta: ${JSON.stringify(meta)}`;
+            }
+        }
+        if (info.stack) {
+            log += `\n${info.stack}`;
+        }
+        else if (info.error && info.error.stack) {
+            log += `\n${info.error.stack}`;
+        }
+        return log;
+    })),
+});
+const logger = winston_1.default.createLogger({
+    level: process.env.LOG_LEVEL || "info",
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston_1.default.format.errors({ stack: true }), winston_1.default.format.splat(), winston_1.default.format.json()),
+    defaultMeta: { service: "lapeh-service" },
+    transports: [
+        // Write all logs with importance level of `error` or less to `error.log`
+        // new winston.transports.File({ filename: 'error.log', level: 'error' }),
+        // Write all logs to `combined.log`
+        // new winston.transports.File({ filename: 'combined.log' }),
+        dailyRotateFileTransport,
+    ],
+});
+// If we're not in production then log to the `console` with the format:
+// `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
+if (process.env.NODE_ENV !== "production") {
+    logger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.simple()),
+    }));
+}
+class Log {
+    static info(message, meta) {
+        logger.info(message, meta);
+    }
+    static error(message, meta) {
+        logger.error(message, meta);
+    }
+    static warn(message, meta) {
+        logger.warn(message, meta);
+    }
+    static debug(message, meta) {
+        logger.debug(message, meta);
+    }
+}
+exports.Log = Log;
+exports.default = logger;

package/dist/src/utils/pagination.d.ts

@@ -0,0 +1,19 @@
+export type PaginationQuery = {
+    page?: string | string[] | number;
+    per_page?: string | string[] | number;
+};
+export type PaginationParams = {
+    page: number;
+    perPage: number;
+    skip: number;
+    take: number;
+};
+export type PaginationMeta = {
+    page: number;
+    perPage: number;
+    total: number;
+    lastPage: number;
+};
+export declare function getPagination(query: PaginationQuery): PaginationParams;
+export declare function buildPaginationMeta(page: number, perPage: number, total: number): PaginationMeta;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/src/utils/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../src/utils/pagination.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmBF,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,gBAAgB,CAStE;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,cAAc,CAGhB"}

package/dist/src/utils/pagination.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPagination = getPagination;
+exports.buildPaginationMeta = buildPaginationMeta;
+function toNumber(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return undefined;
+        return toNumber(value[0]);
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const n = parseInt(value, 10);
+        if (!Number.isNaN(n)) {
+            return n;
+        }
+    }
+    return undefined;
+}
+function getPagination(query) {
+    const pageRaw = toNumber(query.page);
+    const perPageRaw = toNumber(query.per_page);
+    const page = pageRaw && pageRaw > 0 ? pageRaw : 1;
+    const perPage = perPageRaw && perPageRaw > 0 && perPageRaw <= 100 ? perPageRaw : 10;
+    const skip = (page - 1) * perPage;
+    const take = perPage;
+    return { page, perPage, skip, take };
+}
+function buildPaginationMeta(page, perPage, total) {
+    const lastPage = total === 0 ? 1 : Math.ceil(total / perPage);
+    return { page, perPage, total, lastPage };
+}

package/dist/src/utils/response.d.ts

@@ -0,0 +1,11 @@
+import { Response } from "express";
+export declare function sendSuccess<T>(res: Response, statusCode: number, message: string, data: T): Response<any, Record<string, any>>;
+/**
+ * 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
+ */
+export declare function sendFastSuccess(res: Response, statusCode: number, serializer: (doc: any) => string, data: any): Response<any, Record<string, any>>;
+export declare function sendError<T = unknown>(res: Response, statusCode: number, message: string, errors?: T): Response<any, Record<string, any>>;
+//# sourceMappingURL=response.d.ts.map

package/dist/src/utils/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/utils/response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAsCnC,wBAAgB,WAAW,CAAC,CAAC,EAC3B,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,CAAC,sCAIR;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,EAChC,IAAI,EAAE,GAAG,sCASV;AAED,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EACnC,GAAG,EAAE,QAAQ,EACb,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,CAAC,sCAcX"}

package/dist/src/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("../utils/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/src/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/src/utils/validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.d.ts","sourceRoot":"","sources":["../../../src/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/src/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/lib/bootstrap.ts

@@ -1,6 +1,7 @@
 import dotenv from "dotenv";
 dotenv.config();
 
+import moduleAlias from "module-alias";
 import express, { Request, Response, NextFunction } from "express";
 import cors from "cors";
 import helmet from "helmet";
@@ -17,6 +18,11 @@ import { requestLogger } from "./middleware/requestLogger";
 import { sendSuccess } from "./utils/response";
 
 export async function bootstrap() {
+  // Register aliases for production runtime
+  // Since user code (compiled JS) uses require('@lapeh/...')
+  // We map '@lapeh' to the directory containing this file (lib/ or dist/lib/)
+  moduleAlias.addAlias("@lapeh", __dirname);
+
   // Validasi Environment Variables
   const requiredEnvs = ["DATABASE_URL", "JWT_SECRET"];
   const missingEnvs = requiredEnvs.filter((key) => !process.env[key]);