vector-framework 0.9.4 → 0.9.5

package/src/core/config-loader.ts

@@ -1,9 +1,7 @@
-import { existsSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { toFileUrl } from '../utils/path';
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { toFileUrl } from "../utils/path";
 import type {
-  AfterMiddlewareHandler,
-  BeforeMiddlewareHandler,
   CacheHandler,
   CorsOptions,
   DefaultVectorTypes,
@@ -11,14 +9,14 @@ import type {
   VectorConfig,
   VectorConfigSchema,
   VectorTypes,
-} from '../types';
+} from "../types";
 
 export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
   private configPath: string;
   private config: VectorConfigSchema<TTypes> | null = null;
-  private configSource: 'user' | 'default' = 'default';
+  private configSource: "user" | "default" = "default";
 
-  constructor(configPath = 'vector.config.ts') {
+  constructor(configPath = "vector.config.ts") {
     // Always resolve from the current working directory (user's project)
     this.configPath = resolve(process.cwd(), configPath);
   }
@@ -28,69 +26,62 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
     if (existsSync(this.configPath)) {
       try {
         console.log(`→ Loading config from: ${this.configPath}`);
-        
+
         // Use explicit file:// URL to ensure correct resolution
         const userConfigPath = toFileUrl(this.configPath);
         const userConfig = await import(userConfigPath);
         this.config = userConfig.default || userConfig;
-        this.configSource = 'user';
-        
-        console.log('  ✓ User config loaded successfully');
+        this.configSource = "user";
+
+        console.log("  ✓ User config loaded successfully");
       } catch (error) {
-        console.error(`  ✗ Failed to load config from ${this.configPath}:`, error);
-        console.log('  → Using default configuration');
+        console.error(
+          `  ✗ Failed to load config from ${this.configPath}:`,
+          error
+        );
+        console.log("  → Using default configuration");
         this.config = {};
       }
     } else {
       // Config file doesn't exist, use defaults
       console.log(`  → No config file found at: ${this.configPath}`);
-      console.log('  → Using default configuration');
+      console.log("  → Using default configuration");
       this.config = {};
     }
 
     // Convert new config schema to legacy VectorConfig format
     return await this.buildLegacyConfig();
   }
-  
-  getConfigSource(): 'user' | 'default' {
+
+  getConfigSource(): "user" | "default" {
     return this.configSource;
   }
 
   private async buildLegacyConfig(): Promise<VectorConfig<TTypes>> {
     const config: VectorConfig<TTypes> = {};
 
-    // Server configuration
-    if (this.config?.server) {
-      config.port = this.config.server.port;
-      config.hostname = this.config.server.hostname;
-      config.reusePort = this.config.server.reusePort;
-      config.development = this.config.server.development;
+    // Direct mapping - schemas are now the same (flat)
+    if (this.config) {
+      config.port = this.config.port;
+      config.hostname = this.config.hostname;
+      config.reusePort = this.config.reusePort;
+      config.development = this.config.development;
+      config.routesDir = this.config.routesDir || "./routes";
     }
 
-    // Routes configuration - support both new and legacy formats
-    if (this.config?.routes) {
-      // New format: { routes: { dir: string } }
-      config.routesDir = this.config.routes.dir || './routes';
-      config.autoDiscover = this.config.routes.autoDiscover !== false;
-    } else if ((this.config as any)?.routesDir) {
-      // Legacy format: { routesDir: string }
-      config.routesDir = (this.config as any).routesDir;
-      config.autoDiscover = (this.config as any).autoDiscover !== false;
-    } else {
-      config.routesDir = './routes';
-      config.autoDiscover = true;
-    }
+    // Always auto-discover routes
+    config.autoDiscover = true;
 
     // CORS configuration
     if (this.config?.cors) {
-      if (typeof this.config.cors === 'boolean') {
+      if (typeof this.config.cors === "boolean") {
         config.cors = this.config.cors
           ? {
-              origin: '*',
+              origin: "*",
               credentials: true,
-              allowHeaders: 'Content-Type, Authorization',
-              allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
-              exposeHeaders: 'Authorization',
+              allowHeaders: "Content-Type, Authorization",
+              allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+              exposeHeaders: "Authorization",
               maxAge: 86400,
             }
           : undefined;
@@ -99,112 +90,27 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
       }
     }
 
-    // Load middleware - support both direct functions and file paths
+    // Middleware mapping (VectorConfig uses 'finally' instead of 'after')
     if (this.config?.before) {
-      // Direct functions provided
       config.before = this.config.before;
-    } else if (this.config?.middleware?.before) {
-      // File paths provided (legacy)
-      config.before = await this.loadMiddleware<BeforeMiddlewareHandler<TTypes>>(
-        this.config.middleware.before
-      );
     }
 
     if (this.config?.after) {
-      // Direct functions provided
       config.finally = this.config.after;
-    } else if (this.config?.middleware?.after) {
-      // File paths provided (legacy)
-      config.finally = await this.loadMiddleware<AfterMiddlewareHandler<TTypes>>(
-        this.config.middleware.after
-      );
     }
 
     return config;
   }
 
-  private async loadMiddleware<T>(paths: string[]): Promise<T[]> {
-    const middleware: T[] = [];
-
-    for (const path of paths) {
-      try {
-        const modulePath = resolve(process.cwd(), path);
-        const importPath = toFileUrl(modulePath);
-        const module = await import(importPath);
-        const handler = module.default || module;
-
-        if (typeof handler === 'function') {
-          middleware.push(handler as T);
-        } else {
-          console.warn(`Middleware at ${path} does not export a function`);
-        }
-      } catch (error) {
-        console.error(`Failed to load middleware from ${path}:`, error);
-      }
-    }
-
-    return middleware;
-  }
-
   async loadAuthHandler(): Promise<ProtectedHandler<TTypes> | null> {
-    // Direct function provided
-    if (this.config?.auth) {
-      return this.config.auth;
-    }
-
-    // File path provided (legacy)
-    if (!this.config?.handlers?.auth) {
-      return null;
-    }
-
-    try {
-      const modulePath = resolve(process.cwd(), this.config.handlers.auth);
-      const importPath = toFileUrl(modulePath);
-      const module = await import(importPath);
-      const handler = module.default || module;
-
-      if (typeof handler === 'function') {
-        return handler as ProtectedHandler<TTypes>;
-      } else {
-        console.warn(`Auth handler at ${this.config.handlers.auth} does not export a function`);
-        return null;
-      }
-    } catch (error) {
-      console.error(`Failed to load auth handler from ${this.config.handlers.auth}:`, error);
-      return null;
-    }
+    return this.config?.auth || null;
   }
 
   async loadCacheHandler(): Promise<CacheHandler | null> {
-    // Direct function provided
-    if (this.config?.cache) {
-      return this.config.cache;
-    }
-
-    // File path provided (legacy)
-    if (!this.config?.handlers?.cache) {
-      return null;
-    }
-
-    try {
-      const modulePath = resolve(process.cwd(), this.config.handlers.cache);
-      const importPath = toFileUrl(modulePath);
-      const module = await import(importPath);
-      const handler = module.default || module;
-
-      if (typeof handler === 'function') {
-        return handler as CacheHandler;
-      } else {
-        console.warn(`Cache handler at ${this.config.handlers.cache} does not export a function`);
-        return null;
-      }
-    } catch (error) {
-      console.error(`Failed to load cache handler from ${this.config.handlers.cache}:`, error);
-      return null;
-    }
+    return this.config?.cache || null;
   }
 
   getConfig(): VectorConfigSchema<TTypes> | null {
     return this.config;
   }
-}
+}

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

@@ -85,39 +85,20 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   autoDiscover?: boolean;
 }
 
-// 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[];
-  };
+  port?: number;
+  hostname?: string;
+  reusePort?: boolean;
+  development?: boolean;
+  routesDir?: string;
   
-  // Direct middleware functions (preferred approach)
+  // 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;