@syntay/fastay 0.2.9 → 1.0.0

package/dist/error-hanler2.js

@@ -0,0 +1,180 @@
+import { logger } from "./logger.js";
+import fs from "fs/promises";
+import path from "path";
+// Cache para arquivos lidos (evita leitura repetida)
+const fileCache = new Map();
+/**
+ * Extrai informações do stack trace de forma otimizada
+ */
+function extractErrorInfo(err) {
+    if (!err.stack)
+        return null;
+    // Pega a primeira linha relevante do stack (ignora a linha do erro)
+    const stackLines = err.stack.split("\n");
+    const relevantLine = stackLines.find((line) => line.includes("(") &&
+        line.includes(".ts:") &&
+        !line.includes("node_modules") &&
+        !line.includes("Error:"));
+    if (!relevantLine)
+        return null;
+    // Regex otimizado para capturar arquivo, linha e coluna
+    const match = relevantLine.match(/\((.*?):(\d+):(\d+)\)/);
+    if (!match)
+        return null;
+    const [, file, line, column] = match;
+    return { file, line, column, snippet: "" };
+}
+/**
+ * Lê snippet de código de forma otimizada com cache
+ */
+async function getCodeSnippet(filePath, lineNumber) {
+    try {
+        // Normalizar caminho do arquivo
+        const normalizedPath = path.resolve(filePath);
+        // Verificar cache
+        if (fileCache.has(normalizedPath)) {
+            const content = fileCache.get(normalizedPath);
+            const lines = content.split("\n");
+            return lines[lineNumber - 1]?.trim() || "";
+        }
+        // Ler arquivo apenas se for um arquivo .ts/.js do projeto
+        if (!normalizedPath.includes("node_modules") &&
+            (normalizedPath.endsWith(".ts") || normalizedPath.endsWith(".js"))) {
+            const content = await fs.readFile(normalizedPath, "utf-8");
+            // Cache apenas em desenvolvimento
+            if (process.env.NODE_ENV === "development") {
+                fileCache.set(normalizedPath, content);
+            }
+            const lines = content.split("\n");
+            return lines[lineNumber - 1]?.trim() || "";
+        }
+    }
+    catch {
+        // Ignorar erros de leitura
+    }
+    return "";
+}
+/**
+ * Log de erro otimizado
+ */
+function logError(err, route, fileInfo) {
+    const isDev = process.env.NODE_ENV === "development";
+    if (isDev) {
+        logger.group(`✗ Error [${route}]`);
+        logger.error(`${err.name}: ${err.message}`);
+        if (fileInfo) {
+            logger.error(`Location: ${fileInfo}`);
+        }
+        // Stack trace apenas para erros não esperados
+        if (err instanceof TypeError || err instanceof ReferenceError) {
+            logger.raw(err.stack?.split("\n").slice(0, 5).join("\n") || "");
+        }
+    }
+    else {
+        // Log minimalista em produção
+        logger.error(`[${route}] ${err.name}: ${err.message}`);
+        // Log detalhado apenas para erros críticos
+        if (err instanceof SyntaxError || err.message?.includes("Unexpected")) {
+            logger.raw(err.stack?.split("\n")[0] || "");
+        }
+    }
+}
+/**
+ * Handler de erros otimizado para Fastay
+ */
+export function errorHandler(err, req, res, next) {
+    // Se headers já foram enviados, delegar para próximo handler
+    if (res.headersSent) {
+        return next(err);
+    }
+    const route = `${req.method} ${req.originalUrl}`;
+    const error = err instanceof Error ? err : new Error(String(err));
+    // Informações adicionais apenas em desenvolvimento
+    let fileInfo = "";
+    if (process.env.NODE_ENV === "development") {
+        const errorInfo = extractErrorInfo(error);
+        if (errorInfo) {
+            fileInfo = `${path.basename(errorInfo.file)}:${errorInfo.line}:${errorInfo.column}`;
+            // Carregar snippet de forma assíncrona
+            getCodeSnippet(errorInfo.file, parseInt(errorInfo.line))
+                .then((snippet) => {
+                if (snippet) {
+                    logger.error(`Code: ${snippet}`);
+                }
+            })
+                .catch(() => { }); // Ignorar erros de leitura
+        }
+    }
+    // Log otimizado
+    logError(error, route, fileInfo);
+    // Determinar status code
+    let statusCode = 500;
+    let errorMessage = "Internal Server Error";
+    if (error instanceof SyntaxError || error.message?.includes("Unexpected")) {
+        statusCode = 400;
+        errorMessage = "Invalid Request";
+    }
+    else if (error.name === "ValidationError") {
+        statusCode = 422;
+        errorMessage = "Validation Failed";
+    }
+    // Resposta otimizada
+    const isDev = process.env.NODE_ENV === "development";
+    res.status(statusCode);
+    // JSON response otimizado
+    const response = {
+        error: errorMessage,
+        status: statusCode,
+        path: req.originalUrl,
+    };
+    // Detalhes apenas em desenvolvimento
+    if (isDev) {
+        response.message = error.message;
+        if (error.stack && statusCode === 500) {
+            response.stack = error.stack.split("\n").slice(0, 3);
+        }
+        if (fileInfo) {
+            response.location = fileInfo;
+        }
+    }
+    // Cabeçalhos de segurança
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("X-Error-Type", error.name);
+    // Cache-control para respostas de erro
+    res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
+    return res.json(response);
+}
+/**
+ * Factory para criar error handlers customizados
+ */
+export function createErrorHandler(options) {
+    const opts = {
+        logDetails: process.env.NODE_ENV === "development",
+        includeStack: process.env.NODE_ENV === "development",
+        customMessages: {},
+        ...options,
+    };
+    return (err, req, res, next) => {
+        if (res.headersSent)
+            return next(err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        const route = `${req.method} ${req.originalUrl}`;
+        // Log customizado
+        if (opts.logDetails) {
+            logger.error(`[${route}] ${error.name}: ${error.message}`);
+        }
+        // Status code customizado
+        let statusCode = 500;
+        if (error.name in opts.customMessages) {
+            statusCode = 400;
+        }
+        // Response
+        res.status(statusCode).json({
+            error: opts.customMessages[error.name] || "Internal Server Error",
+            ...(opts.includeStack && {
+                details: error.message,
+                ...(statusCode === 500 && { stack: error.stack?.split("\n")[0] }),
+            }),
+        });
+    };
+}

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AA6CA,eAAO,MAAM,MAAM;gBACL,MAAM;gBAEN,MAAM;iBACL,MAAM;mBAEJ,MAAM;gBAET,MAAM;kBAEL,MAAM;iBAIN,MAAM;aAOV,MAAM;;mBAQA,MAAM;CAGtB,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,MAAM;gBACL,MAAM;gBAEN,MAAM;iBACL,MAAM;mBAEJ,MAAM;gBAET,MAAM;kBAEL,MAAM;iBAIN,MAAM;aAOV,MAAM;;mBAQA,MAAM;CAGtB,CAAC"}

package/dist/logger.js

@@ -1,24 +1,21 @@
-import pino from 'pino';
-import pretty from 'pino-pretty';
-// stream configurado para remover INFO:, timestamps e etc
+import pino from "pino";
+import pretty from "pino-pretty";
 const stream = pretty({
     colorize: true,
-    ignore: 'pid,hostname,time,level',
+    ignore: "pid,hostname,time,level",
     levelFirst: false,
-    // Remove "INFO: " antes da msg
-    messageKey: 'msg',
-    // Maneira correta TS-safe
+    // Remove "INFO: "
+    messageKey: "msg",
     messageFormat: (log, messageKey) => {
         const msg = log[messageKey];
-        return typeof msg === 'string' ? msg : String(msg);
+        return typeof msg === "string" ? msg : String(msg);
     },
 });
 const base = pino({
-    level: 'info',
+    level: "info",
     timestamp: false, // remove [HH:mm:ss]
     base: undefined, // remove pid, hostname
 }, stream);
-// helpers para cores ANSI
 const colors = {
     white: (s) => `\x1b[37m${s}\x1b[0m`,
     green: (s) => `\x1b[32m${s}\x1b[0m`,
@@ -26,26 +23,25 @@ const colors = {
     cyan: (s) => `\x1b[36m${s}\x1b[0m`,
     gray: (s) => `\x1b[90m${s}\x1b[0m`,
 };
-// emojis Fastay
 const ICONS = {
-    info: '○',
-    success: '✓',
-    error: '✗',
-    gear: '⚙️',
+    info: "○",
+    success: "✓",
+    error: "✗",
+    gear: "⚙️",
 };
 export const logger = {
     info: (msg) => base.info(` ${colors.white(ICONS.info)} ${colors.white(msg)}`),
-    warn: (msg) => base.info(` ${colors.red('⚠')} ${colors.white(msg)}`),
+    warn: (msg) => base.info(` ${colors.red("⚠")} ${colors.white(msg)}`),
     error: (msg) => base.info(` ${colors.red(ICONS.error)} ${colors.white(msg)}`),
     success: (msg) => base.info(` ${colors.green(ICONS.success)} ${colors.white(msg)}`),
     gear: (msg) => base.info(` ${ICONS.gear}  ${colors.white(msg)}`),
     space(lines = 1) {
         for (let i = 0; i < lines; i++)
-            base.info(' ');
+            base.info(" ");
     },
     group(title) {
         this.space();
-        base.info('');
+        base.info("");
         base.info(colors.cyan(title));
         // this.space();
     },

package/dist/middleware.d.ts

@@ -1,4 +1,5 @@
-import { Application, Request, Response, NextFunction } from 'express';
+import { Application, Response, NextFunction } from 'express';
+import { Request } from './types/request.js';
 type MiddlewareFn = (req: Request, res: Response, next: NextFunction) => any;
 /**
  * Defines a map of routes and the middleware functions that Fastay

package/dist/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAOvE,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,KAAK,GAAG,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,IAE1D,KAAK,WAAW,UASzB;AAED,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,WAAW,iBA2B3D"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAM9D,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,KAAK,GAAG,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,IAE1D,KAAK,WAAW,UASzB;AAED,wBAAsB,qBAAqB,CAAC,GAAG,EAAE,WAAW,iBA2B3D"}

package/dist/router.d.ts

@@ -1,14 +1,8 @@
 import { Application } from 'express';
-/**
- * Converte caminho do arquivo em rota Express (somente arquivos route.ts)
- */
+/** Path → route with cache */
 export declare function filePathToRoute(apiDir: string, filePath: string, baseRoute: string): string | null;
-/**
- * Retorna todos arquivos .ts/.js recursivamente
- */
+/** Walk recursion limit */
 export declare function collectFiles(dir: string): string[];
-/**
- * Carrega todas as rotas do diretório apiDir
- */
+/** Optimized route loader with parallel import */
 export declare function loadApiRoutes(app: Application, baseRoute: string, apiDirectory: string): Promise<number>;
 //# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAmC,MAAM,SAAS,CAAC;AAGvE;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,iBAYlB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CASlD;AA8HD;;GAEG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,mBA+ErB"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAA2C,MAAM,SAAS,CAAC;AAgD/E,8BAA8B;AAC9B,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CA+Bf;AAED,2BAA2B;AAC3B,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CA2BlD;AA+FD,kDAAkD;AAClD,wBAAsB,aAAa,CACjC,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CA4EjB"}

package/dist/router.js

@@ -1,197 +1,211 @@
 import fs from 'fs';
 import path from 'node:path';
-import mime from 'mime-types'; // npm i mime-types
+import mime from 'mime-types';
 import { pathToFileURL } from 'url';
+import { Router } from 'express';
 import { logger } from './logger.js';
-/**
- * Converte caminho do arquivo em rota Express (somente arquivos route.ts)
- */
+// Optimized cache with WeakMap for garbage collection
+const mimeCache = new Map();
+const routeCache = new Map();
+const moduleCache = new Map();
+// Predefined HTTP methods as an array for compatibility
+const HTTP_METHODS = [
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'OPTIONS',
+    'HEAD',
+];
+/** Path → route with cache */
 export function filePathToRoute(apiDir, filePath, baseRoute) {
+    // Creates a unique key for the route cache.
+    const key = `${apiDir}:${filePath}`;
+    // Check if the route is already in the cache routeCache.
+    if (routeCache.has(key)) {
+        return routeCache.get(key);
+    }
+    // the relative path of the file in relation to the API folder
     const rel = path.relative(apiDir, filePath);
+    // Divide the relative path into parts.
     const parts = rel.split(path.sep);
+    // The `parts` array moves and returns the last element of the `parts` array, which is the filename.
     const filename = parts.pop();
-    if (filename !== 'route.ts' && filename !== 'route.js')
+    //Check if the file exists.
+    if (!filename || !(filename === 'route.ts' || filename === 'route.js')) {
+        routeCache.set(key, null);
         return null;
-    const segments = parts
-        .map(s => (s.startsWith('[') && s.endsWith(']') ? `:${s.slice(1, -1)}` : s))
-        .filter(Boolean);
-    return `${baseRoute}/${segments.join('/')}`.replace(/\/+/g, '/');
+    }
+    // Converts dynamic folders into Express route parameters.
+    const segments = parts.map((s) => s.startsWith('[') && s.endsWith(']') ? `:${s.slice(1, -1)}` : s);
+    const route = `${baseRoute}/${segments.join('/')}`.replace(/\/+/g, '/');
+    routeCache.set(key, route);
+    return route;
 }
-/**
- * Retorna todos arquivos .ts/.js recursivamente
- */
+/** Walk recursion limit */
 export function collectFiles(dir) {
-    let out = [];
-    const items = fs.readdirSync(dir, { withFileTypes: true });
-    for (const it of items) {
-        const full = path.join(dir, it.name);
-        if (it.isDirectory())
-            out = out.concat(collectFiles(full));
-        else if (/\.(ts|js|mts|mjs)$/.test(it.name))
-            out.push(full);
+    const result = [];
+    const stack = [dir];
+    const maxDepth = 20;
+    while (stack.length > 0 && stack.length < maxDepth) {
+        const current = stack.pop();
+        try {
+            const items = fs.readdirSync(current, { withFileTypes: true });
+            for (let i = items.length - 1; i >= 0; i--) {
+                const it = items[i];
+                const full = path.join(current, it.name);
+                if (it.isDirectory()) {
+                    stack.push(full);
+                }
+                else if (/\.(ts|js|mts|mjs)$/.test(it.name)) {
+                    result.push(full);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`Cannot read directory: ${current}`);
+        }
     }
-    return out;
+    return result;
+}
+/** Cache mime */
+function getMime(filePath) {
+    const cached = mimeCache.get(filePath);
+    if (cached)
+        return cached;
+    const type = mime.lookup(filePath) || 'application/octet-stream';
+    mimeCache.set(filePath, type);
+    return type;
 }
-/**
- * Wrapper para suportar return JSON/string/number e capturar erros runtime
- */
-function wrapHandler(fn, routePath, filePath) {
-    return async (req, res, next) => {
+/** Highly optimized handler with fewer branches. */
+function wrapHandler(fn) {
+    return async (request, res, next) => {
         try {
-            const result = fn.length >= 2 ? await fn(req, res) : await fn(req);
-            if (res.headersSent)
+            const result = await (fn.length >= 2 ? fn(request, res) : fn(request));
+            // If response has already been sent, exit
+            if (res.headersSent || result === undefined)
                 return;
-            if (result === undefined)
-                return;
-            // Suporte a status e cookies customizado
-            // if (
-            //   typeof result === 'object' &&
-            //   'status' in result &&
-            //   'body' in result &&
-            //   typeof result.status === 'number'
-            // ) {
-            //   return res.status(result.status).json(result.body);
-            // }
-            if (typeof result === 'object' && result !== null) {
-                const typedResult = result;
-                // redirect
-                if (typedResult.redirect) {
-                    return res.redirect(typedResult.status ?? 302, typedResult.redirect);
-                }
-                //headers
-                if (typedResult.headers) {
-                    for (const [h, v] of Object.entries(typedResult.headers)) {
-                        res.setHeader(h, v);
+            //Optimized processing by type
+            switch (typeof result) {
+                case 'string':
+                case 'number':
+                case 'boolean':
+                    return res.send(String(result));
+                case 'object':
+                    if (result === null)
+                        return res.send('null');
+                    const response = result;
+                    // Headers first
+                    if (response.headers) {
+                        for (const [k, v] of Object.entries(response.headers)) {
+                            res.setHeader(k, v);
+                        }
                     }
-                }
-                //file
-                if (typedResult.file) {
-                    const { path, filename, options } = typedResult.file;
-                    if (filename) {
-                        return res.download(path, filename, options);
+                    // Cookies
+                    if (response.cookies) {
+                        for (const [name, cookie] of Object.entries(response.cookies)) {
+                            res.cookie(name, cookie.value, cookie.options || {});
+                        }
                     }
-                    return res.download(path, options);
-                }
-                // stream
-                if (typedResult.stream) {
-                    if (typedResult.headers) {
-                        for (const [h, v] of Object.entries(typedResult.headers))
-                            res.setHeader(h, v);
+                    // Redirections e files
+                    if (response.redirect) {
+                        return res.redirect(response.status ?? 302, response.redirect);
                     }
-                    return typedResult.stream.pipe(res);
-                }
-                // raw
-                if (typedResult.raw) {
-                    if (typedResult.headers) {
-                        for (const [h, v] of Object.entries(typedResult.headers))
-                            res.setHeader(h, v);
+                    if (response.file) {
+                        return response.file.filename
+                            ? res.download(response.file.path, response.file.filename, response.file.options)
+                            : res.download(response.file.path, response.file.options);
                     }
-                    return res.status(typedResult.status ?? 200).send(typedResult.raw);
-                }
-                if (typedResult.cookies) {
-                    for (const [name, data] of Object.entries(typedResult.cookies)) {
-                        res.cookie(name, data.value, data.options || {});
+                    if (response.stream) {
+                        return response.stream.pipe(res);
                     }
-                }
-                if (typedResult.static) {
-                    const filePath = typedResult.static.path;
-                    let contentType = typedResult.static.contentType;
-                    if (!contentType) {
-                        contentType = mime.lookup(filePath) || 'application/octet-stream';
+                    if (response.raw) {
+                        return res.status(response.status ?? 200).send(response.raw);
                     }
-                    res.setHeader('Content-Type', contentType);
-                    return res.sendFile(path.resolve(filePath), (err) => {
-                        if (err) {
-                            console.error(err);
-                            res.status(500).send('Internal Server Error');
-                        }
-                    });
-                }
-                const statusCode = typeof result.status === 'number' ? result.status : 200;
-                const body = result.body ?? result; // se não existir body, retorna o objeto inteiro
-                return res.status(statusCode).json(body);
+                    if (response.static) {
+                        const type = response.static.contentType || getMime(response.static.path);
+                        res.setHeader('Content-Type', type);
+                        return res.sendFile(path.resolve(response.static.path));
+                    }
+                    // JSON response default
+                    return res
+                        .status(response.status ?? 200)
+                        .json(response.body ?? result);
+                default:
+                    return res.json(result);
             }
-            // Suporte a retorno simples
-            if (typeof result === 'string')
-                return res.send(result);
-            if (typeof result === 'number')
-                return res.send(String(result));
-            return res.json(result);
         }
         catch (err) {
-            const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
-            logger.error(`${err.name}: ${err.message}`);
+            const error = err;
+            logger.error(`Handler Error [${request.method} ${request.path}]: ${error.message}`);
             next(err);
         }
     };
 }
-/**
- * Carrega todas as rotas do diretório apiDir
- */
+/** Optimized route loader with parallel import */
 export async function loadApiRoutes(app, baseRoute, apiDirectory) {
     const isDev = process.env.NODE_ENV !== 'production';
     const apiDir = path.join(process.cwd(), isDev ? apiDirectory : 'dist/api');
-    if (!fs.existsSync(apiDir))
+    if (!fs.existsSync(apiDir)) {
+        logger.warn(`API directory not found: ${apiDir}`);
         return 0;
+    }
     const files = collectFiles(apiDir);
-    let cont = 0;
-    logger.group('Routes Loaded');
-    for (const file of files) {
-        const route = filePathToRoute(apiDir, file, baseRoute);
-        if (!route)
-            continue;
+    let count = 0;
+    logger.group('Loading Routes');
+    // Optimized parallel loading
+    const modulePromises = files.map(async (file) => {
         try {
-            const fileUrl = pathToFileURL(file).href;
-            const mod = await import(fileUrl);
-            const httpMethods = [
-                'GET',
-                'POST',
-                'PUT',
-                'DELETE',
-                'PATCH',
-                'OPTIONS',
-                'HEAD'
-            ];
-            for (const m of httpMethods) {
-                if (typeof mod[m] === 'function') {
-                    app[m.toLowerCase()](route, wrapHandler(mod[m], route, file));
-                    cont++;
-                    logger.success(`Route: [${m}] ${route}`);
-                }
+            // Module cache in production
+            if (process.env.NODE_ENV === 'production' && moduleCache.has(file)) {
+                return { file, module: moduleCache.get(file) };
             }
-            if (mod.default && typeof mod.default === 'function') {
-                app.get(route, wrapHandler(mod.default, route, file));
-                cont++;
-                logger.success(`Route: [GET] ${route}`);
+            const module = await import(pathToFileURL(file).href);
+            if (process.env.NODE_ENV === 'production') {
+                moduleCache.set(file, module);
             }
+            return { file, module };
         }
-        catch (err) {
-            const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
-            // logger.error(
-            //   `✗ Boot Error importing ${file}\n` +
-            //     `  Message: ${err.message || 'Unknown error'}\n` +
-            //     `  Stack: ${stack}`
-            // );
-            let fileInfo = '';
-            if (err.stack) {
-                const stackLine = err.stack.split('\n')[1]; // pega primeira linha depois do erro
-                const match = stackLine.match(/\((.*):(\d+):(\d+)\)/);
-                if (match) {
-                    const [_, file, line, col] = match;
-                    fileInfo = `${file}:${line}:${col}`;
-                    // Tenta mostrar o trecho da linha que deu erro
-                    if (fs.existsSync(file)) {
-                        const codeLines = fs.readFileSync(file, 'utf-8').split('\n');
-                        const codeSnippet = codeLines[parseInt(line) - 1].trim();
-                        fileInfo += ` → ${codeSnippet}`;
-                    }
+        catch (error) {
+            logger.error(`Failed to load ${file}: ${error.message}`);
+            return { file, module: null, error };
+        }
+    });
+    const modules = await Promise.all(modulePromises);
+    // Router per file
+    for (const { file, module } of modules) {
+        if (!module || module.error)
+            continue;
+        const route = filePathToRoute(apiDir, file, baseRoute);
+        if (!route)
+            continue;
+        const routeRouter = Router({ mergeParams: true });
+        let hasRoutes = false;
+        // Register HTTP methods
+        for (const method of HTTP_METHODS) {
+            const handler = module[method];
+            if (typeof handler === 'function') {
+                // Using type assertion is safe.
+                const routerMethod = method.toLowerCase();
+                if (typeof routeRouter[routerMethod] === 'function') {
+                    routeRouter[routerMethod]('/', wrapHandler(handler));
+                    logger.success(`[${method}] ${route}`);
+                    hasRoutes = true;
+                    count++;
                 }
             }
-            // logger.group(`✗ Boot Error importing ${file}`);
-            logger.error(`${err.name}: ${err.message}`);
-            if (fileInfo)
-                logger.error(`Location: ${fileInfo}`);
+        }
+        // Default export
+        if (typeof module.default === 'function') {
+            routeRouter.get('/', wrapHandler(module.default));
+            logger.success(`[GET] ${route}`);
+            hasRoutes = true;
+            count++;
+        }
+        if (hasRoutes) {
+            app.use(route, routeRouter);
         }
     }
-    return cont;
+    return count;
 }