vector-framework 0.9.9 → 1.1.1

package/src/cli/index.ts

@@ -1,57 +1,53 @@
 #!/usr/bin/env bun
 
-import { watch } from "node:fs";
-import { parseArgs } from "node:util";
-import { getVectorInstance } from "../core/vector";
-import { ConfigLoader } from "../core/config-loader";
+import { watch } from 'node:fs';
+import { parseArgs } from 'node:util';
+import { getVectorInstance } from '../core/vector';
+import { ConfigLoader } from '../core/config-loader';
 
 // Compatibility layer for both Node and Bun
-const args =
-  typeof Bun !== "undefined" ? Bun.argv.slice(2) : process.argv.slice(2);
+const args = typeof Bun !== 'undefined' ? Bun.argv.slice(2) : process.argv.slice(2);
 
 const { values, positionals } = parseArgs({
   args,
   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,
     },
     config: {
-      type: "string",
-      short: "c",
+      type: 'string',
+      short: 'c',
     },
   },
   strict: true,
   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 isDev = command === 'dev';
 
   let server: any = null;
   let vector: any = null;
@@ -60,7 +56,7 @@ async function runDev() {
     // Create a timeout promise that rejects after 10 seconds
     const timeoutPromise = new Promise<never>((_, reject) => {
       setTimeout(() => {
-        reject(new Error("Server startup timed out (10s)"));
+        reject(new Error('Server startup timed out (10s)'));
       }, 10000);
     });
 
@@ -69,7 +65,6 @@ async function runDev() {
       // Load configuration using ConfigLoader
       const configLoader = new ConfigLoader(values.config as string | undefined);
       const config = await configLoader.load();
-      const configSource = configLoader.getConfigSource();
 
       // Merge CLI options with loaded config
       // Only use CLI values if config doesn't have them
@@ -83,11 +78,11 @@ async function runDev() {
       // Only apply default CORS if config.cors is undefined (not set)
       if (config.cors === undefined && values.cors) {
         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,
         };
       }
@@ -112,32 +107,13 @@ async function runDev() {
 
       // Verify the server is actually running
       if (!server || !server.port) {
-        throw new Error("Server started but is not responding correctly");
+        throw new Error('Server started but is not responding correctly');
       }
 
-      const gray = "\x1b[90m";
-      const reset = "\x1b[0m";
-      const cyan = "\x1b[36m";
-      const green = "\x1b[32m";
+      const cyan = '\x1b[36m';
+      const reset = '\x1b[0m';
 
-      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}       ${config.cors ? "Enabled" : "Disabled"}`
-      );
-      console.log(
-        `  ${gray}Mode${reset}       ${config.development ? "Development" : "Production"}\n`
-      );
-      console.log(
-        `  ${green}Ready${reset} → ${cyan}http://${config.hostname}:${config.port}${reset}\n`
-      );
+      console.log(`\nListening on ${cyan}http://${config.hostname}:${config.port}${reset}\n`);
 
       return { server, vector, config };
     })();
@@ -165,17 +141,16 @@ async function runDev() {
           const now = Date.now();
           if (isReloading || now - lastReloadTime < 1000) return;
 
+          const segments = filename ? filename.split(/[/\\]/) : [];
+          const excluded = segments.some((s) =>
+            ['node_modules', '.git', '.vector', 'dist'].includes(s)
+          );
           if (
             filename &&
-            (filename.endsWith(".ts") ||
-              filename.endsWith(".js") ||
-              filename.endsWith(".json")) &&
-            !filename.includes("node_modules") &&
-            !filename.includes(".git") &&
-            !filename.includes(".vector") && // Ignore generated files
-            !filename.includes("dist") && // Ignore dist folder
-            !filename.includes("bun.lockb") && // Ignore lock files
-            !filename.endsWith(".generated.ts") // Ignore generated files
+            (filename.endsWith('.ts') || filename.endsWith('.js') || filename.endsWith('.json')) &&
+            !excluded &&
+            !filename.includes('bun.lockb') && // Ignore lock files
+            !filename.endsWith('.generated.ts') // Ignore generated files
           ) {
             // Track changed files
             changedFiles.add(filename);
@@ -202,24 +177,13 @@ async function runDev() {
               // Small delay to ensure file system operations complete
               await new Promise((resolve) => setTimeout(resolve, 100));
 
-              // Clear module cache to ensure fresh imports
-              // Note: Bun uses ESM and doesn't have require.cache
-              // The Loader API will handle module reloading automatically
-              if (typeof require !== 'undefined' && require.cache) {
-                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;
                 vector = result.vector;
               } catch (error: any) {
-                console.error("\n[Reload Error]", error.message || error);
+                console.error('\n[Reload Error]', error.message || error);
                 // Don't exit the process on reload failures, just continue watching
               } finally {
                 // Reset flag immediately after reload completes
@@ -230,88 +194,90 @@ async function runDev() {
           }
         });
       } catch {
-        console.warn("  ⚠️  File watching not available");
+        const yellow = '\x1b[33m';
+        const reset = '\x1b[0m';
+        console.warn(`${yellow}Warning: File watching not available${reset}`);
       }
     }
   } catch (error: any) {
-    const red = "\x1b[31m";
-    const reset = "\x1b[0m";
-
-    console.error(`\n${red}[ERROR] Failed to start server${reset}\n`);
+    const red = '\x1b[31m';
+    const reset = '\x1b[0m';
 
-    // Always show the error message and stack trace
-    if (error.message) {
-      console.error(`Message: ${error.message}`);
-    }
+    console.error(`\n${red}Error: ${error.message || error}${reset}\n`);
 
-    if (error.stack) {
-      console.error(`\nStack trace:`);
+    if (error.stack && process.env.NODE_ENV === 'development') {
       console.error(error.stack);
-    } else if (!error.message) {
-      // If no message or stack, show the raw error
-      console.error(`Raw error:`, error);
     }
 
-    // Ensure we exit with error code
     process.exit(1);
   }
 }
 
 async function runBuild() {
-  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');
 
+    // Step 1: Scan and generate routes
     const scanner = new RouteScanner(values.routes as string);
     const generator = new RouteGenerator();
 
     const routes = await scanner.scan();
     await generator.generate(routes);
 
-    console.log(`  Generated ${routes.length} routes`);
-
-    // Use spawn based on runtime
-    if (typeof Bun !== "undefined") {
+    // Step 2: Build the application with Bun
+    if (typeof Bun !== 'undefined') {
+      // Build the CLI as an executable
       const buildProcess = Bun.spawn([
-        "bun",
-        "build",
-        "src/index.ts",
-        "--outdir",
-        "dist",
-        "--minify",
+        'bun',
+        'build',
+        'src/cli/index.ts',
+        '--target',
+        'bun',
+        '--outfile',
+        'dist/server.js',
+        '--minify',
       ]);
-      await buildProcess.exited;
+
+      const exitCode = await buildProcess.exited;
+      if (exitCode !== 0) {
+        throw new Error(`Build failed with exit code ${exitCode}`);
+      }
     } else {
       // For Node.js, use child_process
-      const { spawnSync } = await import("child_process");
-      spawnSync(
-        "bun",
-        ["build", "src/index.ts", "--outdir", "dist", "--minify"],
+      const { spawnSync } = await import('child_process');
+      const result = spawnSync(
+        'bun',
+        ['build', 'src/cli/index.ts', '--target', 'bun', '--outfile', 'dist/server.js', '--minify'],
         {
-          stdio: "inherit",
+          stdio: 'inherit',
           shell: true,
         }
       );
+
+      if (result.status !== 0) {
+        throw new Error(`Build failed with exit code ${result.status}`);
+      }
     }
 
-    console.log("\n  ✓ Build complete\n");
-  } catch (error) {
-    console.error("[ERROR] Build failed:", error);
+    console.log('\nBuild complete: dist/server.js\n');
+  } catch (error: any) {
+    const red = '\x1b[31m';
+    const reset = '\x1b[0m';
+    console.error(`\n${red}Error: ${error.message || error}${reset}\n`);
     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

@@ -1,6 +1,6 @@
-import { existsSync } from "node:fs";
-import { resolve, isAbsolute } from "node:path";
-import { toFileUrl } from "../utils/path";
+import { existsSync } from 'node:fs';
+import { resolve, isAbsolute } from 'node:path';
+import { toFileUrl } from '../utils/path';
 import type {
   CacheHandler,
   CorsOptions,
@@ -9,48 +9,40 @@ 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?: string) {
     // Use provided config path or default to vector.config.ts
-    const path = configPath || "vector.config.ts";
+    const path = configPath || 'vector.config.ts';
 
     // Handle absolute vs relative paths
-    this.configPath = isAbsolute(path)
-      ? path
-      : resolve(process.cwd(), path);
+    this.configPath = isAbsolute(path) ? path : resolve(process.cwd(), path);
   }
 
   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) {
+        this.configSource = 'user';
+      } catch (error: any) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[Vector] Failed to load config from ${this.configPath}: ${msg}`);
         console.error(
-          `  ✗ Failed to load config from ${this.configPath}:`,
-          error
+          '[Vector] Server is using default configuration. Fix your config file and restart.'
         );
-        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 = {};
     }
 
@@ -58,7 +50,7 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
     return await this.buildLegacyConfig();
   }
 
-  getConfigSource(): "user" | "default" {
+  getConfigSource(): 'user' | 'default' {
     return this.configSource;
   }
 
@@ -71,7 +63,7 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
       config.hostname = this.config.hostname;
       config.reusePort = this.config.reusePort;
       config.development = this.config.development;
-      config.routesDir = this.config.routesDir || "./routes";
+      config.routesDir = this.config.routesDir || './routes';
       config.idleTimeout = this.config.idleTimeout;
     }
 
@@ -80,14 +72,14 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
 
     // 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;

package/src/core/router.ts

@@ -1,5 +1,4 @@
 import type { RouteEntry } from 'itty-router';
-import { withCookies } from 'itty-router';
 import type { AuthManager } from '../auth/protected';
 import type { CacheManager } from '../cache/manager';
 import { APIError, createResponse } from '../http';
@@ -11,12 +10,14 @@ import type {
   VectorRequest,
   VectorTypes,
 } from '../types';
+import { buildRouteRegex } from '../utils/path';
 
 export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
   private middlewareManager: MiddlewareManager<TTypes>;
   private authManager: AuthManager<TTypes>;
   private cacheManager: CacheManager<TTypes>;
   private routes: RouteEntry[] = [];
+  private specificityCache: Map<string, number> = new Map();
 
   constructor(
     middlewareManager: MiddlewareManager<TTypes>,
@@ -29,6 +30,9 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   private getRouteSpecificity(path: string): number {
+    const cached = this.specificityCache.get(path);
+    if (cached !== undefined) return cached;
+
     const STATIC_SEGMENT_WEIGHT = 1000;
     const PARAM_SEGMENT_WEIGHT = 10;
     const WILDCARD_WEIGHT = 1;
@@ -53,6 +57,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
       score += EXACT_MATCH_BONUS;
     }
 
+    this.specificityCache.set(path, score);
     return score;
   }
 
@@ -104,14 +109,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   private createRouteRegex(path: string): RegExp {
-    return RegExp(
-      `^${path
-        .replace(/\/+(\/|$)/g, '$1')
-        .replace(/(\/?\.?):(\w+)\+/g, '($1(?<$2>*))')
-        .replace(/(\/?\.?):(\w+)/g, '($1(?<$2>[^$1/]+?))')
-        .replace(/\./g, '\\.')
-        .replace(/(\/?)\*/g, '($1.*)?')}/*$`
-    );
+    return buildRouteRegex(path);
   }
 
   private prepareRequest(
@@ -140,7 +138,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
     // Parse query parameters from URL if not already parsed
     if (!request.query && request.url) {
-      const url = new URL(request.url);
+      const url = (request as any)._parsedUrl ?? new URL(request.url);
       const query: Record<string, string | string[]> = {};
       for (const [key, value] of url.searchParams) {
         if (key in query) {
@@ -156,9 +154,31 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
       request.query = query;
     }
 
-    // Parse cookies if not already parsed
-    if (!request.cookies) {
-      withCookies(request as any);
+    // Lazy cookie parsing — only parse the Cookie header when first accessed
+    if (!Object.getOwnPropertyDescriptor(request, 'cookies')) {
+      Object.defineProperty(request, 'cookies', {
+        get() {
+          const cookieHeader = this.headers.get('cookie') ?? '';
+          const cookies: Record<string, string> = {};
+          if (cookieHeader) {
+            for (const pair of cookieHeader.split(';')) {
+              const idx = pair.indexOf('=');
+              if (idx > 0) {
+                cookies[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+              }
+            }
+          }
+          Object.defineProperty(this, 'cookies', {
+            value: cookies,
+            writable: true,
+            configurable: true,
+            enumerable: true,
+          });
+          return cookies;
+        },
+        configurable: true,
+        enumerable: true,
+      });
     }
   }
 
@@ -169,7 +189,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
       // Prepare the request with common logic
       this.prepareRequest(vectorRequest, {
-        metadata: options.metadata
+        metadata: options.metadata,
       });
 
       request = vectorRequest;
@@ -225,7 +245,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
               _isResponse: true,
               body: await res.text(),
               status: res.status,
-              headers: Object.fromEntries(res.headers.entries())
+              headers: Object.fromEntries(res.headers.entries()),
             };
           }
           return res;
@@ -251,7 +271,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
         if (result && typeof result === 'object' && result._isResponse === true) {
           result = new Response(result.body, {
             status: result.status,
-            headers: result.headers
+            headers: result.headers,
           });
         }
 
@@ -284,12 +304,25 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
     this.sortRoutes(); // Sort routes after adding a new one
   }
 
+  bulkAddRoutes(entries: RouteEntry[]): void {
+    for (const entry of entries) {
+      this.routes.push(entry);
+    }
+    this.sortRoutes(); // Sort once after all routes are added — O(n log n) instead of O(n²)
+  }
+
   getRoutes(): RouteEntry[] {
     return this.routes;
   }
 
   async handle(request: Request): Promise<Response> {
-    const url = new URL(request.url);
+    let url: URL;
+    try {
+      url = new URL(request.url);
+    } catch {
+      return APIError.badRequest('Malformed request URL');
+    }
+    (request as any)._parsedUrl = url;
     const pathname = url.pathname;
 
     for (const [method, regex, handlers, path] of this.routes) {
@@ -301,7 +334,7 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
           // Prepare the request with common logic
           this.prepareRequest(req, {
             params: match.groups || {},
-            route: path || pathname
+            route: path || pathname,
           });
 
           for (const handler of handlers) {
@@ -317,5 +350,6 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
   clearRoutes(): void {
     this.routes = [];
+    this.specificityCache.clear();
   }
 }