bro-framework 3.0.0 → 3.0.1

package/bin/bro.js

@@ -32,7 +32,7 @@ async function bootstrap() {
     }
   }
 
-  const routesDir = globalConfig.routesDir || path.resolve(process.cwd(), 'api');
+  const routesDir = globalConfig.routesDir || path.resolve(process.cwd(), 'routes');
   const localeDir = globalConfig.locale?.directory || path.resolve(process.cwd(), 'locale');
   const tasksDir = globalConfig.tasksDir || path.resolve(process.cwd(), 'tasks');
   const port = globalConfig.server?.port || process.env.PORT || 3000;
@@ -138,15 +138,92 @@ async function bootstrap() {
   const configPath = path.resolve(process.cwd(), 'bro.config.js');
   const envPath = path.resolve(process.cwd(), '.env.example');
   if (!fs.existsSync(configPath)) {
-    fs.writeFileSync(configPath, `export default {
-  server: { port: 3000, cors: false },
-  auth: { jwtSecret: process.env.JWT_SECRET }
-};
+    fs.writeFileSync(configPath, `import { defineConfig } from 'bro-framework';
+
+export default defineConfig({
+  // Server Settings
+  server: {
+    port: 5000,
+    cors: process.env.NODE_ENV === 'production' ? ['https://yourdomain.com'] : true, // Set to true to allow all, or pass a CORS options object
+    helmet: true // Enable security headers
+  },
+
+  // Authentication Settings
+  auth: {
+    jwtSecret: process.env.JWT_SECRET || 'dev_secret_please_change', // Must be at least 32 characters in production
+    expiresIn: '7d',
+    //apiKey: process.env.API_KEY || ['dev_key_1', 'dev_key_2'] // Supports array for zero-downtime rotation
+  },
+
+  // Trust reverse proxy IP headers (Nginx/Cloudflare)
+  trustProxy: true,
+
+  // Observability & Telemetry
+  observability: {
+    // Output structured JSON logs with request IDs and execution timing (ideal for CloudWatch/Datadog)
+    // Options: 'json' | 'pretty' (default: 'pretty' in dev, 'json' in production)
+    logging: 'json',
+
+    // Enable OpenTelemetry W3C trace propagation and HTTP span generation
+    openTelemetry: true
+  }
+
+  // Optional file-based API translations
+  // Add locale/en.js, locale/fr.js, etc.
+  locale: {
+    defaultLocale: 'en'
+  },
+  
+  // API Documentation (Scalar UI)
+  docs: process.env.NODE_ENV !== 'production', // Set to false to disable completely, or true to force in prod
+
+  // Rate Limiting
+  rateLimit: {
+    windowMs: 15 * 60 * 1000, // 15 minutes
+    max: 100 // limit each IP to 100 requests per windowMs
+  },
+
+  // Redis Configuration (Auto-scales WebSockets, distributed caches & rate-limiting)
+  redisUrl: process.env.REDIS_URL, // e.g., 'redis://localhost:6379'
+
+  // WebSockets Setup
+  sockets: async (io, db) => {
+    io.on('connection', (socket) => {
+      console.log('Client connected:', socket.id);
+    });
+  },
+
+  // Database Context Injection
+  // This instance will be injected into every route's ctx.db (if defined)
+  db: async () => {
+    // If you use a database, set up your connection here
+    // and return the connection instance or an object of your models.
+    // Could be MongoDB, MySQL, etc. (your choice)
+    // --- MONGOOSE EXAMPLE ---
+    // import mongoose from 'mongoose';
+    
+    // await mongoose.connect(process.env.MONGO_URI || 'mongodb://localhost:27017/bro_database');
+    // console.log("Connected to MongoDB");
+    
+    // You can return mongoose itself, or an object of your models 
+    // to access them instantly in your routes without importing them!
+    // Example: return { User, Post };
+    
+    // return mongoose.connection; 
+    // --------------------------
+    return null;
+  },
+
+  // Graceful Teardown Hook
+  onShutdown: async (db) => {
+    // Close application-owned database resources gracefully here
+  }
+});
 `);
     console.log('[bro.js] Created bro.config.js');
   }
   if (!fs.existsSync(envPath)) {
-    fs.writeFileSync(envPath, 'JWT_SECRET=\n');
+    fs.writeFileSync(envPath, 'JWT_SECRET=your_jwt_secret_here\nNODE_ENV=development\nREDIS_URL=redis://localhost:6379\n');
     console.log('[bro.js] Created .env.example');
   }
 } else if (command === 'doctor') {
@@ -160,7 +237,7 @@ async function bootstrap() {
       if (config.server?.cors === true) console.error('✗ Permissive CORS is enabled (cors: true). Use an array of allowed origins.');
       else console.log('✓ CORS is strict.');
       
-      if (['dev_secret_please_change', 'bro_default_secret_key', 'your_jwt_secret_here'].includes(config.auth?.jwtSecret)) {
+      if (['dev_secret_please_change', 'bro_default_secret_key', 'your_jwt_secret_here', ''].includes(config.auth?.jwtSecret?.trim())) {
         console.error('✗ Hardcoded insecure JWT secret detected.');
       } else {
         console.log('✓ Secrets look ok.');
@@ -168,9 +245,17 @@ async function bootstrap() {
     });
   }
 } else if (command === 'sdk' || command === 'client' || command === 'generate-client') {
-  const sdkOutPath = process.argv[3] || './client.ts';
-  const routesDir = path.resolve(process.cwd(), 'api');
-  generateSDK(routesDir, sdkOutPath).then(() => {
+    const sdkOutPath = process.argv[3] || './client.ts';
+    const configPath = path.resolve(process.cwd(), 'bro.config.js');
+    let globalConfig = {};
+    if (fs.existsSync(configPath)) {
+      try {
+        const configModule = await import(configPath);
+        globalConfig = configModule.default || configModule;
+      } catch (e) {}
+    }
+    const routesDir = globalConfig.routesDir || path.resolve(process.cwd(), 'routes');
+    generateSDK(routesDir, sdkOutPath).then(() => {
     console.log(`\x1b[32m✓ SDK successfully generated at ${sdkOutPath}\x1b[0m`);
   }).catch(err => {
     console.error('\x1b[31m✗ Failed to generate SDK:\x1b[0m', err);

package/package.json

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

package/src/dashboard.js

@@ -8,7 +8,8 @@ import path from 'path';
  */
 export function startDashboard(globalConfig, routes) {
   const host = '127.0.0.1'; // Strict local binding
-  const port = (globalConfig.port || 5000) + 1;
+  const basePort = globalConfig.server?.port || globalConfig.port || process.env.PORT || 3000;
+  const port = Number(basePort) + 1;
 
   const server = http.createServer((req, res) => {
     // Restrict access to localhost strictly

package/src/engine.js

@@ -92,6 +92,12 @@ export async function executeRequest(routeConfig, requestData, globalConfig, ctx
 
   try {
     const ctx = {
+      req: requestData.originalUrl,
+      method: requestData.method,
+      ip: requestData.ip,
+      headers: requestData.headers,
+      locale: requestData.locale,
+      requestId: reqId,
       ...ctxExtras,
       env: globalConfig.envData || process.env,
       body: requestData.body,

package/src/index.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="node" />
+/// <reference types="node" />
 import { z, ZodTypeAny } from 'zod';
 
 type InferZod<T> = T extends ZodTypeAny ? z.infer<T> : any;
@@ -15,12 +15,12 @@ export interface UploadedFile {
   buffer?: Buffer;
 }
 
-export interface AppContext<Env = any, Db = any, User = any> {
-  env: Env;
-  db: Db;
-  user: User;
-}
-
+export interface AppContext<Env = any, Db = any, User = any> {
+  env: Env;
+  db: Db;
+  user: User;
+}
+
 export interface BroContext<Body = any, Params = any, Query = any, App extends AppContext = AppContext> {
   env?: App['env'];
   jwt?: { sign: (payload: any, options?: any) => string };
@@ -36,10 +36,11 @@ export interface BroContext<Body = any, Params = any, Query = any, App extends A
   t: (key: string, values?: Record<string, unknown>) => string;
   error?: any;
   redis?: any;
+  requestId?: string;
 }
 
 export interface RouteConfig<Body = any, Params = any, Query = any, Response = any, App extends AppContext = AppContext> {
-  auth?: boolean | string[] | 'api-key';
+  auth?: boolean | string[] | 'api-key';
     operationId?: string;
   upload?: boolean | { limits?: any, fields?: { name: string, maxCount?: number }[], single?: string, array?: string, fileFilter?: any, storage?: any };
   body?: Body;
@@ -66,24 +67,40 @@ export function loadLocale(directory: string, options?: { defaultLocale?: string
   translate: (locale: string, key: string, values?: Record<string, unknown>) => string;
 }>;
 
-
-export interface BroPlugin {
-  name: string;
-  version: string;
-  order?: number;
-  onInit?: (globalConfig: BroConfig, app: any) => void | Promise<void>;
-  onContext?: (ctx: BroContext) => any | Promise<any>;
-  onRequest?: (req: any, res: any) => void | Promise<void>;
-  onError?: (err: any, req: any, res: any) => void | Promise<void>;
-  onShutdown?: () => void | Promise<void>;
-}
-export interface BroConfig {
-    validateResponse?: boolean | 'strict' | 'warn';
+
+export interface BroPlugin {
+  name: string;
+  version: string;
+  order?: number;
+  onInit?: (globalConfig: BroConfig, app: any) => void | Promise<void>;
+  onContext?: (ctx: BroContext) => any | Promise<any>;
+  onRequest?: (req: any, res: any) => void | Promise<void>;
+  onError?: (err: any, req: any, res: any) => void | Promise<void>;
+  onShutdown?: () => void | Promise<void>;
+}
+export interface BroConfig {
+  routesDir?: string;
+  tasksDir?: string;
+  logger?: { level?: string; [key: string]: any };
+  plugins?: BroPlugin[];
+  fixtures?: Record<string, any>;
+  stores?: Record<string, any>;
+  health?: boolean | { dbCheck?: (db: any) => Promise<any> };
+  locales?: Record<string, any>;
+  defaultLocale?: string;
+  envData?: any;
+  redis?: any;
+  port?: number;
+  jwtSecret?: string;
+  trustProxy?: boolean;
+  validateResponse?: boolean | 'strict' | 'warn';
   env?: ZodTypeAny;
   server?: {
     port?: number;
     cors?: boolean | object;
     helmet?: boolean | object;
+    timeoutMs?: number;
+    headersTimeoutMs?: number;
   };
   locale?: {
     directory?: string;

package/src/next.d.ts

@@ -12,9 +12,33 @@ export interface UploadedFile {
 }
 
 export interface NextBroGlobalConfig<TEnv = any, TDb = any, TUser = any> {
-  env?: ZodTypeAny;
+  routesDir?: string;
+  tasksDir?: string;
+  logger?: { level?: string; [key: string]: any };
+  plugins?: any[];
+  fixtures?: Record<string, any>;
+  stores?: Record<string, any>;
+  health?: boolean | { dbCheck?: (db: any) => Promise<any> };
   locales?: Record<string, any>;
   defaultLocale?: string;
+  envData?: any;
+  redis?: any;
+  port?: number;
+  jwtSecret?: string;
+  trustProxy?: boolean;
+  validateResponse?: boolean | 'strict' | 'warn';
+  env?: ZodTypeAny;
+  server?: {
+    port?: number;
+    cors?: boolean | object;
+    helmet?: boolean | object;
+    timeoutMs?: number;
+    headersTimeoutMs?: number;
+  };
+  locale?: {
+    directory?: string;
+    defaultLocale?: string;
+  };
   redisUrl?: string;
   rateLimit?: { windowMs: number; max: number; };
   auth?: {
@@ -22,7 +46,18 @@ export interface NextBroGlobalConfig<TEnv = any, TDb = any, TUser = any> {
     apiKey?: string | string[];
     expiresIn?: string | number;
   };
+  docs?: boolean | { auth?: { user: string; pass: string } };
+  upload?: {
+    limits?: {
+      fileSize?: number;
+      files?: number;
+      fields?: number;
+      [key: string]: any;
+    };
+  };
   db?: TDb | Promise<TDb> | (() => TDb | Promise<TDb>) | { init: () => TDb | Promise<TDb> };
+  sockets?: (io: any, db: any) => Promise<void> | void;
+  onShutdown?: (db: any) => Promise<void> | void;
 }
 
 export interface NextRouteContext<TBody = any, TQuery = any, TParams = any, TEnv = any, TDb = any, TUser = any> {
@@ -37,6 +72,11 @@ export interface NextRouteContext<TBody = any, TQuery = any, TParams = any, TEnv
   file?: UploadedFile;
   files?: Record<string, UploadedFile[]>;
   locale: string;
+  method: string;
+  ip: string;
+  headers: Record<string, string>;
+  requestId: string;
+  logger: any;
   t: (key: string, values?: any) => string;
   user?: TUser;
   jwt: { sign: (payload: any, opts?: any) => string };
@@ -52,6 +92,7 @@ export interface NextRouteConfig<TBody = any, TQuery = any, TParams = any, TEnv
   rateLimit?: { windowMs: number; max: number; } | false;
   response?: ZodTypeAny;
   summary?: string;
+  operationId?: string;
   upload?: any;
   handler: (ctx: NextRouteContext<TBody, TQuery, TParams, TEnv, TDb, TUser>) => Promise<any> | any;
 }