vector-framework 0.8.1 → 0.9.0

package/src/cli/index.ts

@@ -1,34 +1,35 @@
 #!/usr/bin/env bun
 
-import { join } from 'node:path';
-import { parseArgs } from 'node:util';
-import vector from '../core/vector';
+import { watch } from "node:fs";
+import { parseArgs } from "node:util";
+import { getVectorInstance } from "../core/vector";
+import { ConfigLoader } from "../core/config-loader";
 
 const { values, positionals } = parseArgs({
   args: Bun.argv.slice(2),
   options: {
     port: {
-      type: 'string',
-      short: 'p',
-      default: '3000',
+      type: "string",
+      short: "p",
+      default: "3000",
     },
     host: {
-      type: 'string',
-      short: 'h',
-      default: 'localhost',
+      type: "string",
+      short: "h",
+      default: "localhost",
     },
     routes: {
-      type: 'string',
-      short: 'r',
-      default: './routes',
+      type: "string",
+      short: "r",
+      default: "./routes",
     },
     watch: {
-      type: 'boolean',
-      short: 'w',
+      type: "boolean",
+      short: "w",
       default: true,
     },
     cors: {
-      type: 'boolean',
+      type: "boolean",
       default: true,
     },
   },
@@ -36,69 +37,153 @@ const { values, positionals } = parseArgs({
   allowPositionals: true,
 });
 
-const command = positionals[0] || 'dev';
+const command = positionals[0] || "dev";
 
 async function runDev() {
-  const isDev = command === 'dev';
-  console.log(`\n→ Starting Vector ${isDev ? 'development' : 'production'} server\n`);
-
-  const config = {
-    port: Number.parseInt(values.port as string),
-    hostname: values.host as string,
-    routesDir: values.routes as string,
-    development: isDev,
-    autoDiscover: true,
-    cors: values.cors
-      ? {
-          origin: '*',
+  const isDev = command === "dev";
+  console.log(
+    `\n→ Starting Vector ${isDev ? "development" : "production"} server\n`
+  );
+
+  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();
+
+      // 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',
+          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) {
-        Object.assign(config, userConfig.default);
+      // 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}`);
+      const gray = "\x1b[90m";
+      const reset = "\x1b[0m";
+      const cyan = "\x1b[36m";
+      const green = "\x1b[32m";
+
+      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) {
-      console.log(`  ${gray}Watching${reset}   Enabled`);
+      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.includes("node_modules") &&
+            !filename.includes(".git")
+          ) {
+            // 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);
+    console.error("[ERROR] Failed to start server:", error);
     process.exit(1);
   }
 }
 
 async function runBuild() {
-  console.log('\n→ Building Vector application\n');
+  console.log("\n→ Building Vector application\n");
 
   try {
-    const { RouteScanner } = await import('../dev/route-scanner');
-    const { RouteGenerator } = await import('../dev/route-generator');
+    const { RouteScanner } = await import("../dev/route-scanner");
+    const { RouteGenerator } = await import("../dev/route-generator");
 
     const scanner = new RouteScanner(values.routes as string);
     const generator = new RouteGenerator();
@@ -109,31 +194,31 @@ async function runBuild() {
     console.log(`  Generated ${routes.length} routes`);
 
     const buildProcess = Bun.spawn([
-      'bun',
-      'build',
-      'src/index.ts',
-      '--outdir',
-      'dist',
-      '--minify',
+      "bun",
+      "build",
+      "src/index.ts",
+      "--outdir",
+      "dist",
+      "--minify",
     ]);
     await buildProcess.exited;
 
-    console.log('\n  ✓ Build complete\n');
+    console.log("\n  ✓ Build complete\n");
   } catch (error) {
-    console.error('[ERROR] Build failed:', error);
+    console.error("[ERROR] Build failed:", error);
     process.exit(1);
   }
 }
 
 switch (command) {
-  case 'dev':
+  case "dev":
     await runDev();
     break;
-  case 'build':
+  case "build":
     await runBuild();
     break;
-  case 'start':
-    process.env.NODE_ENV = 'production';
+  case "start":
+    process.env.NODE_ENV = "production";
     await runDev();
     break;
   default:

package/src/core/config-loader.ts

@@ -0,0 +1,193 @@
+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;
+
+  constructor(configPath = 'vector.config.ts') {
+    this.configPath = resolve(process.cwd(), configPath);
+  }
+
+  async load(): Promise<VectorConfig<TTypes>> {
+    try {
+      // Try to load user config
+      const userConfigPath = toFileUrl(this.configPath);
+      const userConfig = await import(userConfigPath);
+      this.config = userConfig.default || userConfig;
+    } catch (error) {
+      // No config file, use defaults
+      console.log('No vector.config.ts found, using defaults');
+      this.config = {};
+    }
+
+    // Convert new config schema to legacy VectorConfig format
+    return await this.buildLegacyConfig();
+  }
+
+  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

@@ -140,7 +140,8 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
       request = vectorRequest;
       try {
-        if (!options.expose) {
+        // Default expose to true if not specified
+        if (options.expose === false) {
           return APIError.forbidden('Forbidden');
         }
 
@@ -255,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);
     }
@@ -105,12 +98,6 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     this.server = new VectorServer<TTypes>(this.router, this.config);
     const bunServer = await this.server.start();
 
-    if (this.config.development && this.routeScanner) {
-      this.routeScanner.enableWatch(async () => {
-        await this.discoverRoutes();
-      });
-    }
-
     return bunServer;
   }
 
@@ -135,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') {
@@ -163,7 +152,7 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
         console.log(`✅ Loaded ${routes.length} routes from ${routesDir}`);
       }
     } catch (error) {
-      if ((error as any).code !== 'ENOENT') {
+      if ((error as any).code !== 'ENOENT' && (error as any).code !== 'ENOTDIR') {
         console.error('Failed to discover routes:', error);
       }
     }
@@ -191,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]}`);
@@ -204,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 {
@@ -221,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;