vector-framework 0.9.4 → 0.9.6

package/src/core/vector.ts

@@ -1,11 +1,11 @@
-import type { Server } from 'bun';
-import type { RouteEntry } from 'itty-router';
-import { AuthManager } from '../auth/protected';
-import { CacheManager } from '../cache/manager';
-import { RouteGenerator } from '../dev/route-generator';
-import { RouteScanner } from '../dev/route-scanner';
-import { MiddlewareManager } from '../middleware/manager';
-import { toFileUrl } from '../utils/path';
+import type { Server } from "bun";
+import type { RouteEntry } from "itty-router";
+import { AuthManager } from "../auth/protected";
+import { CacheManager } from "../cache/manager";
+import { RouteGenerator } from "../dev/route-generator";
+import { RouteScanner } from "../dev/route-scanner";
+import { MiddlewareManager } from "../middleware/manager";
+import { toFileUrl } from "../utils/path";
 import type {
   CacheHandler,
   DefaultVectorTypes,
@@ -14,9 +14,9 @@ import type {
   RouteOptions,
   VectorConfig,
   VectorTypes,
-} from '../types';
-import { VectorRouter } from './router';
-import { VectorServer } from './server';
+} from "../types";
+import { VectorRouter } from "./router";
+import { VectorServer } from "./server";
 
 // Internal-only class - not exposed to users
 export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
@@ -72,7 +72,10 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   // Internal method to add route
-  addRoute(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>): RouteEntry {
+  addRoute(
+    options: RouteOptions<TTypes>,
+    handler: RouteHandler<TTypes>
+  ): RouteEntry {
     return this.router.route(options, handler);
   }
 
@@ -102,7 +105,7 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   private async discoverRoutes() {
-    const routesDir = this.config.routesDir || './routes';
+    const routesDir = this.config.routesDir || "./routes";
 
     // Always create a new RouteScanner with the current config's routesDir
     // to ensure we're using the correct path from the user's config
@@ -125,7 +128,8 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
             const importPath = toFileUrl(route.path);
 
             const module = await import(importPath);
-            const exported = route.name === 'default' ? module.default : module[route.name];
+            const exported =
+              route.name === "default" ? module.default : module[route.name];
 
             if (exported) {
               if (this.isRouteDefinition(exported)) {
@@ -137,36 +141,41 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
                 // Legacy support for direct RouteEntry (won't have middleware)
                 this.router.addRoute(exported as RouteEntry);
                 this.logRouteLoaded(exported as RouteEntry);
-              } else if (typeof exported === 'function') {
+              } else if (typeof exported === "function") {
                 this.router.route(route.options as any, exported);
                 this.logRouteLoaded(route.options);
               }
             }
           } catch (error) {
-            console.error(`Failed to load route ${route.name} from ${route.path}:`, error);
+            console.error(
+              `Failed to load route ${route.name} from ${route.path}:`,
+              error
+            );
           }
         }
 
         // Ensure routes are properly sorted after loading all
         this.router.sortRoutes();
-        console.log(`✅ Loaded ${routes.length} routes from ${routesDir}`);
       }
     } catch (error) {
-      if ((error as any).code !== 'ENOENT' && (error as any).code !== 'ENOTDIR') {
-        console.error('Failed to discover routes:', error);
+      if (
+        (error as any).code !== "ENOENT" &&
+        (error as any).code !== "ENOTDIR"
+      ) {
+        console.error("Failed to discover routes:", error);
       }
     }
   }
 
   async loadRoute(routeModule: any) {
-    if (typeof routeModule === 'function') {
+    if (typeof routeModule === "function") {
       const routeEntry = routeModule();
       if (Array.isArray(routeEntry)) {
         this.router.addRoute(routeEntry as RouteEntry);
       }
-    } else if (routeModule && typeof routeModule === 'object') {
+    } else if (routeModule && typeof routeModule === "object") {
       for (const [, value] of Object.entries(routeModule)) {
-        if (typeof value === 'function') {
+        if (typeof value === "function") {
           const routeEntry = (value as any)();
           if (Array.isArray(routeEntry)) {
             this.router.addRoute(routeEntry as RouteEntry);
@@ -181,15 +190,17 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   private isRouteDefinition(value: any): boolean {
-    return value && typeof value === 'object' && 'entry' in value && 'options' in value && 'handler' in value;
+    return (
+      value &&
+      typeof value === "object" &&
+      "entry" in value &&
+      "options" in value &&
+      "handler" in value
+    );
   }
 
-  private logRouteLoaded(route: RouteEntry | RouteOptions): void {
-    if (Array.isArray(route)) {
-      console.log(`  ✓ Loaded route: ${route[0]} ${route[3] || route[1]}`);
-    } else {
-      console.log(`  ✓ Loaded route: ${route.method} ${route.path}`);
-    }
+  private logRouteLoaded(_: RouteEntry | RouteOptions): void {
+    // Silent - no logging
   }
 
   stop(): void {

package/src/dev/route-generator.ts

@@ -65,7 +65,6 @@ export default routes;
 `;
 
     await fs.writeFile(this.outputPath, content, 'utf-8');
-    console.log(`Generated routes file: ${this.outputPath}`);
   }
 
   async generateDynamic(routes: GeneratedRoute[]): Promise<string> {

package/src/dev/route-scanner.ts

@@ -15,17 +15,11 @@ export class RouteScanner {
 
     // Check if routes directory exists before attempting to scan
     if (!existsSync(this.routesDir)) {
-      console.log(`  → Routes directory not found: ${this.routesDir}`);
-      console.log('  → No routes will be auto-discovered');
       return [];
     }
 
     try {
-      console.log(`  → Scanning routes from: ${this.routesDir}`);
       await this.scanDirectory(this.routesDir, routes);
-      if (routes.length > 0) {
-        console.log(`  ✓ Found ${routes.length} route${routes.length === 1 ? '' : 's'}`);
-      }
     } catch (error) {
       if ((error as any).code === 'ENOENT') {
         console.warn(`  ✗ Routes directory not accessible: ${this.routesDir}`);

package/src/types/index.ts

@@ -83,47 +83,30 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   finally?: AfterMiddlewareHandler<TTypes>[];
   routesDir?: string;
   autoDiscover?: boolean;
+  idleTimeout?: number;
 }
 
-// New config-driven schema
+// New config-driven schema - flat structure
 export interface VectorConfigSchema<TTypes extends VectorTypes = DefaultVectorTypes> {
   // Server configuration
-  server?: {
-    port?: number;
-    hostname?: string;
-    reusePort?: boolean;
-    development?: boolean;
-  };
-  
-  // Routes configuration
-  routes?: {
-    dir?: string;
-    autoDiscover?: boolean;
-  };
-  
-  // Middleware configuration - supports both file paths and direct functions
-  middleware?: {
-    before?: string[];
-    after?: string[];
-  };
-  
-  // Direct middleware functions (preferred approach)
+  port?: number;
+  hostname?: string;
+  reusePort?: boolean;
+  development?: boolean;
+  routesDir?: string;
+  idleTimeout?: number;
+
+  // Middleware functions
   before?: BeforeMiddlewareHandler<TTypes>[];
   after?: AfterMiddlewareHandler<TTypes>[];
-  
-  // Handler configuration - supports both file paths and direct functions
-  handlers?: {
-    auth?: string;
-    cache?: string;
-  };
-  
-  // Direct handler functions (preferred approach)
+
+  // Handler functions
   auth?: ProtectedHandler<TTypes>;
   cache?: CacheHandler;
-  
+
   // CORS configuration
   cors?: CorsOptions | boolean;
-  
+
   // Custom types for TypeScript
   types?: VectorTypes;
 }