@syntay/fastay 0.1.0

package/src/router.ts

@@ -0,0 +1,175 @@
+import fs from 'fs';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import { Application, Request, Response, NextFunction } from 'express';
+import { logger } from './logger.js';
+
+/**
+ * Converte caminho do arquivo em rota Express (somente arquivos route.ts)
+ */
+export function filePathToRoute(
+  apiDir: string,
+  filePath: string,
+  baseRoute: string
+) {
+  const rel = path.relative(apiDir, filePath);
+  const parts = rel.split(path.sep);
+  const filename = parts.pop()!;
+  if (filename !== 'route.ts' && filename !== 'route.js') return null;
+
+  const segments = parts
+    .map((s) =>
+      s.startsWith('[') && s.endsWith(']') ? `:${s.slice(1, -1)}` : s
+    )
+    .filter(Boolean);
+
+  return `${baseRoute}/${segments.join('/')}`.replace(/\/+/g, '/');
+}
+
+/**
+ * Retorna todos arquivos .ts/.js recursivamente
+ */
+export function collectFiles(dir: string): string[] {
+  let out: string[] = [];
+  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);
+  }
+  return out;
+}
+
+/**
+ * Wrapper para suportar return JSON/string/number e capturar erros runtime
+ */
+function wrapHandler(fn: Function, routePath: string, filePath: string) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const result = fn.length >= 2 ? await fn(req, res) : await fn(req);
+      if (res.headersSent) return;
+      if (result === undefined) return;
+      if (typeof result === 'string') return res.send(result);
+      if (typeof result === 'number') return res.send(String(result));
+      return res.json(result);
+    } catch (err: any) {
+      const stack = err?.stack?.split('\n').slice(0, 3).join('\n') || '';
+      // logger.error(
+      //   `✗ Runtime Error in route [${req.method} ${routePath}]\n` +
+      //     `  File: ${filePath}\n` +
+      //     `  ${err.name}: ${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}`;
+          }
+        }
+      }
+
+      // logger.group(`✗ Runtime Error in route  [${req.method} ${routePath}]`);
+      logger.error(`${err.name}: ${err.message}`);
+      if (fileInfo) logger.error(`Location: ${fileInfo}`);
+
+      next(err);
+    }
+  };
+}
+
+/**
+ * Carrega todas as rotas do diretório apiDir
+ */
+export async function loadApiRoutes(
+  app: Application,
+  baseRoute: string,
+  apiDirectory: string
+) {
+  const isDev = process.env.NODE_ENV !== 'production';
+
+  const apiDir = path.join(process.cwd(), isDev ? apiDirectory : 'dist/api');
+
+  if (!fs.existsSync(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;
+
+    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 as any)[m.toLowerCase()](
+            route,
+            wrapHandler(mod[m], route, file)
+          );
+          cont++;
+          logger.success(`Route: [${m}] ${route}`);
+        }
+      }
+
+      if (mod.default && typeof mod.default === 'function') {
+        app.get(route, wrapHandler(mod.default, route, file));
+        cont++;
+        logger.success(`Route: [GET] ${route}`);
+      }
+    } catch (err: any) {
+      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}`;
+          }
+        }
+      }
+
+      // logger.group(`✗ Boot Error importing ${file}`);
+      logger.error(`${err.name}: ${err.message}`);
+      if (fileInfo) logger.error(`Location: ${fileInfo}`);
+    }
+  }
+
+  return cont;
+}

package/src/types/index.ts

@@ -0,0 +1,13 @@
+import {
+  Request as ExpressRequest,
+  Response as ExpressResponse,
+  NextFunction,
+} from 'express';
+
+/**
+ * Request e Response do Express
+ * Podem ser usados nos handlers do usuário
+ */
+export type Request = ExpressRequest;
+export type Response = ExpressResponse;
+export type Next = NextFunction;

package/src/utils/wrapMiddleware.ts

@@ -0,0 +1,95 @@
+import { Request, Response, NextFunction } from 'express';
+import { logger } from '../logger.js';
+
+export type MiddlewareFn = (
+  req: Request,
+  res: Response,
+  next: NextFunction
+) => any;
+
+const color = {
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  gray: (s: string) => `\x1b[90m${s}\x1b[0m`,
+  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
+  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  white: (s: string) => `\x1b[37m${s}\x1b[0m`,
+};
+
+/**
+ * Formata uma função para exibição bonitinha
+ */
+function formatFunction(fn: Function): string {
+  let code = fn.toString();
+
+  // deixa com quebras de linha
+  code = code.replace(/;/g, ';\n');
+
+  // tenta dar indentação
+  code = code
+    .replace(/{/g, '{\n  ')
+    .replace(/}/g, '\n}')
+    .replace(/\n\s*\n/g, '\n');
+
+  return code.trim();
+}
+
+/**
+ * Verifica se next() ou return existem
+ */
+function validateMiddlewareCode(mw: MiddlewareFn) {
+  const raw = mw.toString();
+  const name = mw.name || 'anonymous';
+
+  const cleaned = raw
+    .replace(/\/\/.*$/gm, '')
+    .replace(/\/\*[\s\S]*?\*\//gm, '');
+
+  const hasNext = /next\s*\(/.test(cleaned);
+  const hasReturn = /\breturn\b/.test(cleaned);
+
+  if (!hasNext && !hasReturn) {
+    const prettyCode = formatFunction(mw);
+
+    const message = [
+      `${color.red('⨯ Fastay Middleware Error')}`,
+      ``,
+      `The middleware ${color.yellow(
+        `"${name}"`
+      )} does not call next() or return any value.`,
+      `This will halt the middleware chain and block the request pipeline.`,
+      ``,
+      `▌ Middleware Source`,
+      color.gray(prettyCode),
+      ``,
+      `${color.cyan('▌ How to fix')}`,
+      `Ensure your middleware ends with either:`,
+      `  • ${color.green('next()')}`,
+      `  • ${color.green('return ...')}`,
+      ``,
+      `Fastay cannot continue until this middleware is fixed.`,
+    ].join('\n');
+
+    const err = new Error(message);
+    err.name = 'FastayMiddlewareError';
+    throw err;
+  }
+}
+
+/**
+ * Wrapper final
+ */
+export function wrapMiddleware(mw: MiddlewareFn): MiddlewareFn {
+  const name = mw.name || 'anonymous';
+  validateMiddlewareCode(mw);
+
+  // retorna middleware "puro"
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      await mw(req, res, next);
+    } catch (err) {
+      logger.error(`[${name}] middleware error: ${err}`);
+      next(err);
+    }
+  };
+}

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "declaration": true,
+    "sourceMap": false,
+    "rootDir": "src",
+    "module": "ES2022",
+    "target": "ES2020"
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}