vector-framework 0.8.2 → 0.9.1

package/src/cli/index.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env bun
 
 import { watch } from "node:fs";
-import { join } from "node:path";
 import { parseArgs } from "node:util";
-import vector from "../core/vector";
+import { getVectorInstance } from "../core/vector";
+import { ConfigLoader } from "../core/config-loader";
 
 const { values, positionals } = parseArgs({
   args: Bun.argv.slice(2),
@@ -45,92 +45,135 @@ async function runDev() {
     `\n→ Starting Vector ${isDev ? "development" : "production"} server\n`
   );
 
-  const config: any = {
-    port: Number.parseInt(values.port as string),
-    hostname: values.host as string,
-    routesDir: values.routes as string,
-    development: isDev,
-    autoDiscover: true,
-    cors: values.cors
-      ? {
+  let server: any = null;
+  let vector: any = null;
+
+  async function startServer() {
+    try {
+      // Load configuration using ConfigLoader
+      const configLoader = new ConfigLoader();
+      const config = await configLoader.load();
+      const configSource = configLoader.getConfigSource();
+
+      // Merge CLI options with loaded config
+      config.port = config.port || Number.parseInt(values.port as string);
+      config.hostname = config.hostname || (values.host as string);
+      config.routesDir = config.routesDir || (values.routes as string);
+      config.development = isDev;
+      config.autoDiscover = true;
+
+      // Apply CLI CORS option if not set in config
+      if (!config.cors && values.cors) {
+        config.cors = {
           origin: "*",
           credentials: true,
           allowHeaders: "Content-Type, Authorization",
           allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
           exposeHeaders: "Authorization",
           maxAge: 86400,
-        }
-      : undefined,
-  };
+        };
+      }
 
-  try {
-    const userConfigPath = join(process.cwd(), "vector.config.ts");
-    try {
-      const userConfig = await import(userConfigPath);
-      if (userConfig.default) {
-        // Properly merge config, preserving middleware arrays
-        const {
-          before,
-          finally: finallyMiddleware,
-          ...otherConfig
-        } = userConfig.default;
-
-        // Merge non-middleware config
-        Object.assign(config, otherConfig);
-
-        // Handle middleware arrays properly - these need to be set after Object.assign
-        // to avoid being overwritten
-        if (before) {
-          config.before = before;
-        }
-        if (finallyMiddleware) {
-          config.finally = finallyMiddleware;
-        }
+      // Get Vector instance and configure handlers
+      vector = getVectorInstance();
+
+      // Load and set auth handler if configured
+      const authHandler = await configLoader.loadAuthHandler();
+      if (authHandler) {
+        vector.setProtectedHandler(authHandler);
       }
-    } catch {
-      // No user config file, use defaults
-    }
 
-    await vector.serve(config);
+      // Load and set cache handler if configured
+      const cacheHandler = await configLoader.loadCacheHandler();
+      if (cacheHandler) {
+        vector.setCacheHandler(cacheHandler);
+      }
 
-    const gray = "\x1b[90m";
-    const reset = "\x1b[0m";
-    const cyan = "\x1b[36m";
-    const green = "\x1b[32m";
+      // Start the server
+      server = await vector.startServer(config);
 
-    console.log(`  ${gray}Routes${reset}     ${config.routesDir}`);
-    if (isDev && values.watch) {
-      console.log(`  ${gray}Watching${reset}   All project files`);
+      const gray = "\x1b[90m";
+      const reset = "\x1b[0m";
+      const cyan = "\x1b[36m";
+      const green = "\x1b[32m";
 
+      console.log(`  ${gray}Config${reset}     ${configSource === 'user' ? 'User config loaded' : 'Using defaults'}`);
+      console.log(`  ${gray}Routes${reset}     ${config.routesDir}`);
+      if (isDev && values.watch) {
+        console.log(`  ${gray}Watching${reset}   All project files`);
+      }
+      console.log(
+        `  ${gray}CORS${reset}       ${values.cors ? "Enabled" : "Disabled"}`
+      );
+      console.log(
+        `  ${gray}Mode${reset}       ${isDev ? "Development" : "Production"}\n`
+      );
+      console.log(
+        `  ${green}Ready${reset} → ${cyan}http://${config.hostname}:${config.port}${reset}\n`
+      );
+
+      return { server, vector, config };
+    } catch (error) {
+      console.error("[ERROR] Failed to start server:", error);
+      throw error;
+    }
+  }
+
+  try {
+    // Start the server initially
+    const result = await startServer();
+    server = result.server;
+
+    // Setup file watching for hot reload
+    if (isDev && values.watch) {
       try {
+        let reloadTimeout: any = null;
+
         // Watch entire project directory for changes
         watch(process.cwd(), { recursive: true }, async (_, filename) => {
           if (
             filename &&
             (filename.endsWith(".ts") ||
               filename.endsWith(".js") ||
-              filename.endsWith(".json"))
+              filename.endsWith(".json")) &&
+            !filename.includes("node_modules") &&
+            !filename.includes(".git")
           ) {
-            console.log(`\n  🔄 File changed: ${filename}`);
-            console.log("  🔄 Restarting server...\n");
-
-            // Exit the current process, which will trigger a restart if using --watch flag
-            process.exit(0);
+            // Debounce reload to avoid multiple restarts
+            if (reloadTimeout) {
+              clearTimeout(reloadTimeout);
+            }
+
+            reloadTimeout = setTimeout(async () => {
+              console.log(`\n  🔄 File changed: ${filename}`);
+              console.log("  🔄 Reloading server...\n");
+
+              // Stop the current server
+              if (vector) {
+                vector.stop();
+              }
+
+              // Clear module cache to ensure fresh imports
+              for (const key in require.cache) {
+                if (!key.includes("node_modules")) {
+                  delete require.cache[key];
+                }
+              }
+
+              // Restart the server
+              try {
+                const result = await startServer();
+                server = result.server;
+              } catch (error) {
+                console.error("  ❌ Failed to reload server:", error);
+              }
+            }, 100); // 100ms debounce
           }
         });
       } catch (err) {
         console.warn("  ⚠️  File watching not available");
       }
     }
-    console.log(
-      `  ${gray}CORS${reset}       ${values.cors ? "Enabled" : "Disabled"}`
-    );
-    console.log(
-      `  ${gray}Mode${reset}       ${isDev ? "Development" : "Production"}\n`
-    );
-    console.log(
-      `  ${green}Ready${reset} → ${cyan}http://${config.hostname}:${config.port}${reset}\n`
-    );
   } catch (error) {
     console.error("[ERROR] Failed to start server:", error);
     process.exit(1);

package/src/core/config-loader.ts

@@ -0,0 +1,213 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { toFileUrl } from '../utils/path';
+import type {
+  AfterMiddlewareHandler,
+  BeforeMiddlewareHandler,
+  CacheHandler,
+  CorsOptions,
+  DefaultVectorTypes,
+  ProtectedHandler,
+  VectorConfig,
+  VectorConfigSchema,
+  VectorTypes,
+} from '../types';
+
+export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
+  private configPath: string;
+  private config: VectorConfigSchema<TTypes> | null = null;
+  private configSource: 'user' | 'default' = 'default';
+
+  constructor(configPath = 'vector.config.ts') {
+    // Always resolve from the current working directory (user's project)
+    this.configPath = resolve(process.cwd(), configPath);
+  }
+
+  async load(): Promise<VectorConfig<TTypes>> {
+    // Check if config file exists before attempting to load
+    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');
+      } catch (error) {
+        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');
+      this.config = {};
+    }
+
+    // Convert new config schema to legacy VectorConfig format
+    return await this.buildLegacyConfig();
+  }
+  
+  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;
+    }
+
+    // Routes configuration
+    if (this.config?.routes) {
+      config.routesDir = this.config.routes.dir || './routes';
+      config.autoDiscover = this.config.routes.autoDiscover !== false;
+    } else {
+      config.routesDir = './routes';
+      config.autoDiscover = true;
+    }
+
+    // CORS configuration
+    if (this.config?.cors) {
+      if (typeof this.config.cors === 'boolean') {
+        config.cors = this.config.cors
+          ? {
+              origin: '*',
+              credentials: true,
+              allowHeaders: 'Content-Type, Authorization',
+              allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+              exposeHeaders: 'Authorization',
+              maxAge: 86400,
+            }
+          : undefined;
+      } else {
+        config.cors = this.config.cors as CorsOptions;
+      }
+    }
+
+    // Load middleware - support both direct functions and file paths
+    if (this.config?.before) {
+      // Direct functions provided
+      console.log('Using direct before middleware functions:', this.config.before.length);
+      config.before = this.config.before;
+    } else if (this.config?.middleware?.before) {
+      // File paths provided (legacy)
+      console.log('Loading before middleware from file paths:', this.config.middleware.before);
+      config.before = await this.loadMiddleware<BeforeMiddlewareHandler<TTypes>>(
+        this.config.middleware.before
+      );
+      console.log('Loaded before middleware:', config.before?.length);
+    }
+
+    if (this.config?.after) {
+      // Direct functions provided
+      console.log('Using direct after middleware functions:', this.config.after.length);
+      config.finally = this.config.after;
+    } else if (this.config?.middleware?.after) {
+      // File paths provided (legacy)
+      console.log('Loading after middleware from file paths:', this.config.middleware.after);
+      config.finally = await this.loadMiddleware<AfterMiddlewareHandler<TTypes>>(
+        this.config.middleware.after
+      );
+      console.log('Loaded after middleware:', config.finally?.length);
+    }
+
+    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) {
+      console.log('Using direct auth handler function');
+      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;
+    }
+  }
+
+  async loadCacheHandler(): Promise<CacheHandler | null> {
+    // Direct function provided
+    if (this.config?.cache) {
+      console.log('Using direct cache handler function');
+      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;
+    }
+  }
+
+  getConfig(): VectorConfigSchema<TTypes> | null {
+    return this.config;
+  }
+}

package/src/core/router.ts

@@ -256,4 +256,8 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
     return APIError.notFound('Route not found');
   }
+
+  clearRoutes(): void {
+    this.routes = [];
+  }
 }

package/src/core/vector.ts

@@ -5,9 +5,8 @@ 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 {
-  AfterMiddlewareHandler,
-  BeforeMiddlewareHandler,
   CacheHandler,
   DefaultVectorTypes,
   ProtectedHandler,
@@ -19,6 +18,7 @@ import type {
 import { VectorRouter } from './router';
 import { VectorServer } from './server';
 
+// Internal-only class - not exposed to users
 export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   private static instance: Vector<any>;
   private router: VectorRouter<TTypes>;
@@ -43,6 +43,7 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     );
   }
 
+  // Internal use only - not exposed to users
   static getInstance<T extends VectorTypes = DefaultVectorTypes>(): Vector<T> {
     if (!Vector.instance) {
       Vector.instance = new Vector<T>();
@@ -50,46 +51,38 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     return Vector.instance as Vector<T>;
   }
 
-  set protected(handler: ProtectedHandler<TTypes>) {
+  // Internal method to set protected handler
+  setProtectedHandler(handler: ProtectedHandler<TTypes>) {
     this._protectedHandler = handler;
     this.authManager.setProtectedHandler(handler);
   }
 
-  get protected(): ProtectedHandler<TTypes> | null {
+  getProtectedHandler(): ProtectedHandler<TTypes> | null {
     return this._protectedHandler;
   }
 
-  set cache(handler: CacheHandler) {
+  // Internal method to set cache handler
+  setCacheHandler(handler: CacheHandler) {
     this._cacheHandler = handler;
     this.cacheManager.setCacheHandler(handler);
   }
 
-  get cache(): CacheHandler | null {
+  getCacheHandler(): CacheHandler | null {
     return this._cacheHandler;
   }
 
-  route(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>): RouteEntry {
+  // Internal method to add route
+  addRoute(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>): RouteEntry {
     return this.router.route(options, handler);
   }
 
-  use(...middleware: BeforeMiddlewareHandler<TTypes>[]): this {
-    this.middlewareManager.addBefore(...middleware);
-    return this;
-  }
-
-  before(...middleware: BeforeMiddlewareHandler<TTypes>[]): this {
-    this.middlewareManager.addBefore(...middleware);
-    return this;
-  }
-
-  finally(...middleware: AfterMiddlewareHandler<TTypes>[]): this {
-    this.middlewareManager.addFinally(...middleware);
-    return this;
-  }
-
-  async serve(config?: VectorConfig<TTypes>): Promise<Server> {
+  // Internal method to start server - only called by CLI
+  async startServer(config?: VectorConfig<TTypes>): Promise<Server> {
     this.config = { ...this.config, ...config };
 
+    // Clear previous middleware to avoid accumulation across multiple starts
+    this.middlewareManager.clear();
+
     if (config?.before) {
       this.middlewareManager.addBefore(...config.before);
     }
@@ -129,17 +122,19 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
 
         for (const route of routes) {
           try {
-            // Convert Windows paths to URLs for import
-            const importPath =
-              process.platform === 'win32'
-                ? `file:///${route.path.replace(/\\/g, '/')}`
-                : route.path;
+            const importPath = toFileUrl(route.path);
 
             const module = await import(importPath);
             const exported = route.name === 'default' ? module.default : module[route.name];
 
             if (exported) {
-              if (this.isRouteEntry(exported)) {
+              if (this.isRouteDefinition(exported)) {
+                // Use router.route() to ensure middleware is applied
+                const routeDef = exported as any;
+                this.router.route(routeDef.options, routeDef.handler);
+                this.logRouteLoaded(routeDef.options);
+              } else if (this.isRouteEntry(exported)) {
+                // 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') {
@@ -185,6 +180,10 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     return Array.isArray(value) && value.length >= 3;
   }
 
+  private isRouteDefinition(value: any): boolean {
+    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]}`);
@@ -198,6 +197,9 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
       this.server.stop();
       this.server = null;
     }
+    // Don't reset managers - they should persist for the singleton
+    // Only clear route-specific state if needed
+    this.router.clearRoutes();
   }
 
   getServer(): VectorServer<TTypes> | null {
@@ -215,8 +217,12 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   getAuthManager(): AuthManager<TTypes> {
     return this.authManager;
   }
-}
 
-const vector = Vector.getInstance();
+  // Reset instance for testing purposes only
+  static resetInstance(): void {
+    Vector.instance = null as any;
+  }
+}
 
-export default vector;
+// Export for internal use only
+export const getVectorInstance = Vector.getInstance;

package/src/dev/route-scanner.ts

@@ -1,4 +1,4 @@
-import { promises as fs } from 'node:fs';
+import { existsSync, promises as fs } from 'node:fs';
 import { join, relative, resolve, sep } from 'node:path';
 import type { GeneratedRoute } from '../types';
 
@@ -6,17 +6,29 @@ export class RouteScanner {
   private routesDir: string;
 
   constructor(routesDir = './routes') {
+    // Always resolve from the current working directory (user's project)
     this.routesDir = resolve(process.cwd(), routesDir);
   }
 
   async scan(): Promise<GeneratedRoute[]> {
     const routes: GeneratedRoute[] = [];
 
+    // 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 found: ${this.routesDir}`);
+        console.warn(`  ✗ Routes directory not accessible: ${this.routesDir}`);
         return [];
       }
       throw error;
@@ -64,7 +76,18 @@ export class RouteScanner {
           for (const [name, value] of Object.entries(module)) {
             if (name === 'default') continue;
 
-            if (Array.isArray(value) && value.length >= 4) {
+            // Check for new RouteDefinition format
+            if (value && typeof value === 'object' && 'entry' in value && 'options' in value && 'handler' in value) {
+              const routeDef = value as any;
+              routes.push({
+                name,
+                path: fullPath,
+                method: routeDef.options.method as string,
+                options: routeDef.options,
+              });
+            }
+            // Legacy RouteEntry format support
+            else if (Array.isArray(value) && value.length >= 4) {
               const [method, , , path] = value;
               routes.push({
                 name,