bro-framework 2.4.3 → 2.4.5

package/bin/bro.js

@@ -207,7 +207,8 @@ async function bootstrap() {
   }
 
   const localeDir = globalConfig.locale?.directory || path.join(cwd, 'locale');
-  const { app, server, routes: initialRoutes, reload, reloadLocale, io, shutdown } = await createServer(globalConfig, routesDir, db);
+  const tasksDir = path.join(cwd, 'tasks');
+  const { app, server, routes: initialRoutes, reload, reloadLocale, reloadTasks, io, shutdown } = await createServer(globalConfig, routesDir, db);
   const port = globalConfig.port;
   
   let currentRoutes = initialRoutes;
@@ -234,28 +235,35 @@ async function bootstrap() {
       
       printCurrentRoutes(currentRoutes);
 
-      const localeGlob = localeDir.replace(/\\/g, '/') + '/*.{js,mjs,ts}';
-      const watcher = chokidar.watch([routesDir, localeGlob], { ignoreInitial: true });
+      const localeGlob = localeDir.replace(/\\/g, '/') + '/*.{js,mjs,ts,json}';
+      const watcher = chokidar.watch([routesDir, localeGlob, tasksDir], { ignoreInitial: true });
       
       watcher.on('all', async (event, filepath) => {
-        const isJavaScriptFile = filepath.endsWith('.js') || filepath.endsWith('.ts') || filepath.endsWith('.mjs');
-        if (!isJavaScriptFile) return;
+        const isValidFile = filepath.match(/\.(js|ts|mjs|json)$/);
+        if (!isValidFile) return;
         const relLocale = path.relative(path.resolve(localeDir), filepath);
         const isLocaleFile = !relLocale.startsWith('..') && !path.isAbsolute(relLocale);
+        
+        const relTask = path.relative(path.resolve(tasksDir), filepath);
+        const isTaskFile = !relTask.startsWith('..') && !path.isAbsolute(relTask);
 
         try {
           const reloadStartTime = performance.now();
           if (isLocaleFile) {
             await reloadLocale();
+          } else if (isTaskFile) {
+            await reloadTasks();
           } else {
             currentRoutes = await reload();
           }
           const reloadTimeMs = performance.now() - reloadStartTime;
           
-          printHotReload(path.basename(filepath), event, reloadTimeMs, isLocaleFile ? 'Locale' : 'Route');
+          const fileType = isTaskFile ? 'Task' : (isLocaleFile ? 'Locale' : 'Route');
+          printHotReload(path.basename(filepath), event, reloadTimeMs, fileType);
           printCurrentRoutes(currentRoutes);
         } catch (err) {
-          console.error(`\n  ✗ Error hot-reloading ${isLocaleFile ? 'locale' : 'routes'}:`, err);
+          const fileType = isTaskFile ? 'tasks' : (isLocaleFile ? 'locale' : 'routes');
+          console.error(`\n  ✗ Error hot-reloading ${fileType}:`, err);
         }
       });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bro-framework",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "The No-BS Backend Framework for Node.js",
   "repository": {
     "type": "git",

package/src/locale.js

@@ -3,7 +3,7 @@ import path from 'path';
 import { pathToFileURL } from 'url';
 import crypto from 'node:crypto';
 
-const LOCALE_EXTENSIONS = new Set(['.js', '.mjs', '.ts']);
+const LOCALE_EXTENSIONS = new Set(['.js', '.mjs', '.ts', '.json']);
 
 function localeFromFilename(fileName) {
 	return path.basename(fileName, path.extname(fileName));

package/src/next.d.ts

@@ -12,11 +12,15 @@ export interface UploadedFile {
 }
 
 export interface NextBroGlobalConfig<TDb = any> {
-  locale?: any;
+  env?: ZodTypeAny;
+  locales?: Record<string, any>;
+  defaultLocale?: string;
   redisUrl?: string;
+  rateLimit?: { windowMs: number; max: number; };
   auth?: {
     jwtSecret?: string;
     apiKey?: string | string[];
+    expiresIn?: string | number;
   };
   db?: TDb | Promise<TDb> | (() => TDb | Promise<TDb>) | { init: () => TDb | Promise<TDb> };
 }
@@ -44,6 +48,11 @@ export interface NextRouteConfig<TBody = any, TQuery = any, TParams = any, TDb =
   body?: TBody;
   query?: TQuery;
   params?: TParams;
+  cache?: number;
+  rateLimit?: { windowMs: number; max: number; } | false;
+  response?: ZodTypeAny;
+  summary?: string;
+  upload?: any;
   handler: (ctx: NextRouteContext<TBody, TQuery, TParams, TDb>) => Promise<any> | any;
 }
 

package/src/next.js

@@ -3,13 +3,19 @@ import { z } from 'zod';
 import { verifyJwt, signJwt } from './auth.js';
 import { createClient } from 'redis';
 
+export { z };
+
 export function createBro(globalConfig = {}) {
   let isInitialized = false;
   let initPromise = null;
 
   let globalDb = null;
-  let globalRedis = null;
   let globalLocale = null;
+  
+  const globalStore = globalThis;
+  globalStore.__broRedis = globalStore.__broRedis || null;
+  globalStore.__broMemoryCache = globalStore.__broMemoryCache || new Map();
+  globalStore.__broMemoryRateLimit = globalStore.__broMemoryRateLimit || new Map();
 
   async function ensureInitialized() {
     if (isInitialized) return;
@@ -17,17 +23,15 @@ export function createBro(globalConfig = {}) {
 
     initPromise = (async () => {
       try {
-        // Locale Dummy or Real
-        if (globalConfig.locale && typeof globalConfig.locale.resolveLocale === 'function') {
-          globalLocale = globalConfig.locale;
-        } else {
-          globalLocale = {
-            resolveLocale: () => 'en',
-            translate: (locale, key) => key
-          };
+        if (globalConfig.env) {
+          try {
+            globalConfig.env.parse(process.env);
+          } catch (err) {
+            console.error('[bro.js/next] Environment Validation Error:', err);
+            throw err;
+          }
         }
 
-        // DB
         if (typeof globalConfig.db === 'function') {
           globalDb = await globalConfig.db();
         } else if (globalConfig.db && typeof globalConfig.db.init === 'function') {
@@ -37,12 +41,11 @@ export function createBro(globalConfig = {}) {
           if (globalDb instanceof Promise) globalDb = await globalDb;
         }
 
-        // Redis
         if (globalConfig.redisUrl) {
-          globalRedis = createClient({ url: globalConfig.redisUrl });
-          globalRedis.on('error', (err) => console.error('[bro.js/next] Redis Error:', err));
-          if (globalRedis.status === 'wait' || !globalRedis.status) {
-             await globalRedis.connect().catch(err => {
+          globalStore.__broRedis = createClient({ url: globalConfig.redisUrl });
+          globalStore.__broRedis.on('error', (err) => console.error('[bro.js/next] Redis Error:', err));
+          if (!globalStore.__broRedis.isOpen) {
+             await globalStore.__broRedis.connect().catch(err => {
                 if (!err.message.includes('already connecting') && !err.message.includes('already connected')) {
                   throw err;
                 }
@@ -60,6 +63,45 @@ export function createBro(globalConfig = {}) {
     return initPromise;
   }
 
+  const resolveLocale = (headers) => {
+    const acceptLanguage = headers['accept-language'] || '';
+    const preferredLanguages = acceptLanguage
+      .split(',')
+      .map(lang => lang.split(';')[0].trim().toLowerCase())
+      .filter(lang => lang);
+    
+    const configuredLocales = Object.keys(globalConfig.locales || {});
+    
+    for (const lang of preferredLanguages) {
+      if (configuredLocales.includes(lang)) {
+        return lang;
+      }
+      const baseLang = lang.split('-')[0];
+      if (configuredLocales.includes(baseLang)) {
+        return baseLang;
+      }
+    }
+    
+    return globalConfig.defaultLocale || 'en';
+  };
+
+  const translate = (locale, key, values = {}) => {
+    let messages = globalConfig.locales?.[locale] || globalConfig.locales?.[globalConfig.defaultLocale || 'en'];
+    if (!messages) return key;
+
+    // Handle Webpack / ES module JSON interop where the object is under .default
+    if (messages.default && typeof messages.default === 'object') {
+      messages = messages.default;
+    }
+
+    const message = key.split('.').reduce((acc, part) => acc && acc[part], messages);
+    if (!message || typeof message !== 'string') return key;
+
+    return message.replace(/\{(\w+)\}/g, (_, name) => {
+      return values[name] !== undefined ? String(values[name]) : `{${name}}`;
+    });
+  };
+
   const errorHelper = (status, message) => {
     const err = new Error(message);
     err.status = status;
@@ -71,54 +113,11 @@ export function createBro(globalConfig = {}) {
       try {
         await ensureInitialized();
 
-        const rawParams = context?.params ? await context.params : {};
-        
-        const url = new URL(req.url);
-        const rawQuery = Object.fromEntries(url.searchParams.entries());
-        
-        let rawBody = {};
-        const parsedFiles = {};
-        let totalFiles = 0;
-        
-        if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
-          const contentType = req.headers.get('content-type') || '';
-          
-          if (contentType.includes('multipart/form-data')) {
-             try {
-                const formData = await req.formData();
-                for (const [key, value] of formData.entries()) {
-                   if (value instanceof File || value instanceof Blob) {
-                      if (!parsedFiles[key]) parsedFiles[key] = [];
-                      parsedFiles[key].push(value);
-                      totalFiles++;
-                   } else {
-                      rawBody[key] = value;
-                   }
-                }
-             } catch (err) {}
-          } else {
-            try {
-              rawBody = await req.json();
-            } catch (err) {}
-          }
-        }
-
-        let body, params, query;
-        try {
-          if (config.body) body = await config.body.parseAsync(rawBody);
-          if (config.params) params = await config.params.parseAsync(rawParams);
-          if (config.query) query = await config.query.parseAsync(rawQuery);
-        } catch (err) {
-          if (err instanceof z.ZodError) {
-            return NextResponse.json(
-              { error: 'Validation Error', issues: err.issues },
-              { status: 400 }
-            );
-          }
-          throw err;
-        }
+        const resolvedLocale = resolveLocale(Object.fromEntries(req.headers.entries()));
 
+        // Auth extraction early for Identity caching
         let user = null;
+        let apiKeyUsed = null;
         if (config.auth) {
           if (config.auth === 'api-key') {
             const apiKey = req.headers.get('x-api-key') || req.headers.get('authorization')?.replace('Bearer ', '');
@@ -133,6 +132,7 @@ export function createBro(globalConfig = {}) {
             if (!isValid) {
               return NextResponse.json({ error: 'Unauthorized', details: 'Missing or invalid API key' }, { status: 401 });
             }
+            apiKeyUsed = apiKey;
           } else {
             const authHeader = req.headers.get('authorization');
             if (!authHeader || !authHeader.startsWith('Bearer ')) {
@@ -161,8 +161,113 @@ export function createBro(globalConfig = {}) {
           }
         }
 
-        const resolvedLocale = globalLocale.resolveLocale({ headers: Object.fromEntries(req.headers.entries()) });
+        // Rate Limiting
+        const activeRateLimit = config.rateLimit === false ? null : (config.rateLimit || globalConfig.rateLimit);
+        if (activeRateLimit) {
+          const ip = req.headers.get('x-forwarded-for') || 'ip';
+          const urlObj = new URL(req.url);
+          const rlKey = `rate-limit:${urlObj.pathname}:${ip}`;
+          
+          if (globalStore.__broRedis) {
+            const currentCount = await globalStore.__broRedis.incr(rlKey);
+            if (currentCount === 1) {
+              await globalStore.__broRedis.expire(rlKey, Math.ceil(activeRateLimit.windowMs / 1000));
+            }
+            if (currentCount > activeRateLimit.max) {
+              return NextResponse.json({ error: 'Too Many Requests' }, { status: 429 });
+            }
+          } else {
+            const now = Date.now();
+            let record = globalStore.__broMemoryRateLimit.get(rlKey);
+            
+            if (!record || now > record.expires) {
+              record = { count: 0, expires: now + activeRateLimit.windowMs };
+            }
+            
+            record.count++;
+            globalStore.__broMemoryRateLimit.set(rlKey, record);
+            
+            if (record.count > activeRateLimit.max) {
+              return NextResponse.json({ error: 'Too Many Requests' }, { status: 429 });
+            }
+          }
+        }
+
+        // Caching
+        let cacheKey = null;
+        if (config.cache && req.method === 'GET') {
+          const urlObj = new URL(req.url);
+          const identity = user ? (user.id || user.role || 'user') : (apiKeyUsed || 'anon');
+          cacheKey = `cache:${urlObj.pathname}${urlObj.search}:${resolvedLocale}:${identity}`;
+          
+          if (globalStore.__broRedis) {
+            const cachedData = await globalStore.__broRedis.get(cacheKey);
+            if (cachedData) {
+              return NextResponse.json(JSON.parse(cachedData), { status: 200 });
+            }
+          } else {
+            const cached = globalStore.__broMemoryCache.get(cacheKey);
+            if (cached) {
+              if (Date.now() < cached.expires) {
+                return NextResponse.json(cached.data, { status: 200 });
+              } else {
+                globalStore.__broMemoryCache.delete(cacheKey);
+              }
+            }
+          }
+        }
+
+        const rawParams = context?.params ? await context.params : {};
+        const url = new URL(req.url);
+        const rawQuery = Object.fromEntries(url.searchParams.entries());
         
+        let rawBody = {};
+        const parsedFiles = {};
+        let totalFiles = 0;
+        
+        if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
+          const contentType = req.headers.get('content-type') || '';
+          
+          if (contentType.includes('multipart/form-data')) {
+             try {
+                const formData = await req.formData();
+                for (const [key, value] of formData.entries()) {
+                   if (value instanceof File || value instanceof Blob) {
+                      if (!parsedFiles[key]) parsedFiles[key] = [];
+                      parsedFiles[key].push(value);
+                      totalFiles++;
+                   } else {
+                      rawBody[key] = value;
+                   }
+                }
+             } catch (err) {}
+          } else {
+            try {
+              rawBody = await req.json();
+            } catch (err) {}
+          }
+        }
+
+        let body, params, query;
+        try {
+          if (config.body) body = await config.body.parseAsync(rawBody);
+        } catch (err) {
+          if (err instanceof z.ZodError) return NextResponse.json({ error: 'Invalid Request Body', details: err.issues }, { status: 400 });
+          throw err;
+        }
+        try {
+          if (config.params) params = await config.params.parseAsync(rawParams);
+        } catch (err) {
+          if (err instanceof z.ZodError) return NextResponse.json({ error: 'Invalid URL Parameters', details: err.issues }, { status: 400 });
+          throw err;
+        }
+        try {
+          if (config.query) query = await config.query.parseAsync(rawQuery);
+        } catch (err) {
+          if (err instanceof z.ZodError) return NextResponse.json({ error: 'Invalid Query Parameters', details: err.issues }, { status: 400 });
+          throw err;
+        }
+
         let ctxFile = undefined;
         let ctxFiles = undefined;
         if (totalFiles === 1) {
@@ -177,7 +282,7 @@ export function createBro(globalConfig = {}) {
           req,
           env: process.env,
           db: globalDb,
-          redis: globalRedis,
+          redis: globalStore.__broRedis,
           io: { emit: () => console.warn('[bro.js/next] WebSockets require standard bro.js server.') },
           body,
           params,
@@ -185,13 +290,24 @@ export function createBro(globalConfig = {}) {
           file: ctxFile,
           files: ctxFiles,
           locale: resolvedLocale,
-          t: (key, values) => globalLocale.translate(resolvedLocale, key, values),
+          t: (key, values) => translate(resolvedLocale, key, values),
           user,
-          jwt: { sign: (payload, opts) => signJwt(payload, globalConfig?.auth?.jwtSecret || process.env.JWT_SECRET, opts) },
+          jwt: { 
+             sign: (payload, opts) => signJwt(payload, globalConfig?.auth?.jwtSecret || process.env.JWT_SECRET, Object.assign({ expiresIn: globalConfig?.auth?.expiresIn || '1d' }, opts || {})) 
+          },
           error: errorHelper
         };
 
         const result = await config.handler(ctx);
+
+        if (cacheKey) {
+           if (globalStore.__broRedis) {
+             await globalStore.__broRedis.set(cacheKey, JSON.stringify(result), { EX: config.cache });
+           } else {
+             globalStore.__broMemoryCache.set(cacheKey, { data: result, expires: Date.now() + (config.cache * 1000) });
+           }
+        }
+
         return NextResponse.json(result, { status: 200 });
 
       } catch (error) {

package/src/router.js

@@ -157,7 +157,6 @@ export async function loadRoutes(app, routesDir, createHandler, openApiSpec) {
         }
       }
       
-      // Auto-inject security definition if auth is true
       if (config.auth === 'api-key') {
         operation.security = [{ apiKeyAuth: [] }];
       } else if (config.auth) {

package/src/server.js

@@ -407,7 +407,12 @@ export async function createServer(globalConfig, routesDir, db) {
 
   const initialRoutes = await reload();
 
-  const taskManager = await scanTasks({ db, io });
+  let taskManager = await scanTasks({ db, io });
+
+  const reloadTasks = async () => {
+    if (taskManager) taskManager.stopAll();
+    taskManager = await scanTasks({ db, io });
+  };
 
   let isShuttingDown = false;
   const shutdown = async () => {
@@ -434,5 +439,5 @@ export async function createServer(globalConfig, routesDir, db) {
     });
   };
 
-  return { app, server, routes: initialRoutes, reload, reloadLocale, io, shutdown };
+  return { app, server, routes: initialRoutes, reload, reloadLocale, reloadTasks, io, shutdown };
 }