vector-framework 1.0.0 → 1.1.1

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();
   }
 }

package/src/core/server.ts

@@ -1,56 +1,66 @@
-import type { Server } from "bun";
-import { cors } from "itty-router";
-import type {
-  CorsOptions,
-  DefaultVectorTypes,
-  VectorConfig,
-  VectorTypes,
-} from "../types";
-import type { VectorRouter } from "./router";
+import type { Server } from 'bun';
+import { cors } from 'itty-router';
+import type { CorsOptions, DefaultVectorTypes, VectorConfig, VectorTypes } from '../types';
+import type { VectorRouter } from './router';
 
 export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
   private server: Server | null = null;
   private router: VectorRouter<TTypes>;
   private config: VectorConfig<TTypes>;
   private corsHandler: any;
+  private corsHeaders: Record<string, string> | null = null;
 
   constructor(router: VectorRouter<TTypes>, config: VectorConfig<TTypes>) {
     this.router = router;
     this.config = config;
 
     if (config.cors) {
-      const { preflight, corsify } = cors(
-        this.normalizeCorsOptions(config.cors)
-      );
+      const opts = this.normalizeCorsOptions(config.cors);
+      const { preflight, corsify } = cors(opts);
       this.corsHandler = { preflight, corsify };
+
+      // Pre-build static CORS headers when origin is a fixed string.
+      // Avoids cloning the Response on every request via corsify().
+      if (typeof opts.origin === 'string') {
+        this.corsHeaders = {
+          'access-control-allow-origin': opts.origin,
+          'access-control-allow-methods': opts.allowMethods,
+          'access-control-allow-headers': opts.allowHeaders,
+          'access-control-expose-headers': opts.exposeHeaders,
+          'access-control-max-age': String(opts.maxAge),
+        };
+        if (opts.credentials) {
+          this.corsHeaders['access-control-allow-credentials'] = 'true';
+        }
+      }
     }
   }
 
   private normalizeCorsOptions(options: CorsOptions): any {
     return {
-      origin: options.origin || "*",
+      origin: options.origin || '*',
       credentials: options.credentials !== false,
       allowHeaders: Array.isArray(options.allowHeaders)
-        ? options.allowHeaders.join(", ")
-        : options.allowHeaders || "Content-Type, Authorization",
+        ? options.allowHeaders.join(', ')
+        : options.allowHeaders || 'Content-Type, Authorization',
       allowMethods: Array.isArray(options.allowMethods)
-        ? options.allowMethods.join(", ")
-        : options.allowMethods || "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+        ? options.allowMethods.join(', ')
+        : options.allowMethods || 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
       exposeHeaders: Array.isArray(options.exposeHeaders)
-        ? options.exposeHeaders.join(", ")
-        : options.exposeHeaders || "Authorization",
+        ? options.exposeHeaders.join(', ')
+        : options.exposeHeaders || 'Authorization',
       maxAge: options.maxAge || 86400,
     };
   }
 
   async start(): Promise<Server> {
     const port = this.config.port || 3000;
-    const hostname = this.config.hostname || "localhost";
+    const hostname = this.config.hostname || 'localhost';
 
     const fetch = async (request: Request): Promise<Response> => {
       try {
         // Handle CORS preflight
-        if (this.corsHandler && request.method === "OPTIONS") {
+        if (this.corsHandler && request.method === 'OPTIONS') {
           return this.corsHandler.preflight(request);
         }
 
@@ -58,14 +68,18 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
         let response = await this.router.handle(request);
 
         // Apply CORS headers if configured
-        if (this.corsHandler) {
+        if (this.corsHeaders) {
+          for (const [k, v] of Object.entries(this.corsHeaders)) {
+            response.headers.set(k, v);
+          }
+        } else if (this.corsHandler) {
           response = this.corsHandler.corsify(response, request);
         }
 
         return response;
       } catch (error) {
-        console.error("Server error:", error);
-        return new Response("Internal Server Error", { status: 500 });
+        console.error('Server error:', error);
+        return new Response('Internal Server Error', { status: 500 });
       }
     };
 
@@ -77,8 +91,8 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
         fetch,
         idleTimeout: this.config.idleTimeout || 60,
         error: (error) => {
-          console.error("[ERROR] Server error:", error);
-          return new Response("Internal Server Error", { status: 500 });
+          console.error('[ERROR] Server error:', error);
+          return new Response('Internal Server Error', { status: 500 });
         },
       });
 
@@ -111,7 +125,7 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
     if (this.server) {
       this.server.stop();
       this.server = null;
-      console.log("Server stopped");
+      console.log('Server stopped');
     }
   }
 
@@ -124,7 +138,7 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   getHostname(): string {
-    return this.server?.hostname || this.config.hostname || "localhost";
+    return this.server?.hostname || this.config.hostname || 'localhost';
   }
 
   getUrl(): string {

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,10 +72,7 @@ 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);
   }
 
@@ -110,7 +107,7 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   }
 
   private async discoverRoutes() {
-    const routesDir = this.config.routesDir || "./routes";
+    const routesDir = this.config.routesDir || './routes';
     const excludePatterns = this.config.routeExcludePatterns;
 
     // Always create a new RouteScanner with the current config's routesDir
@@ -134,8 +131,7 @@ 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)) {
@@ -147,16 +143,13 @@ 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);
           }
         }
 
@@ -164,24 +157,21 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
         this.router.sortRoutes();
       }
     } 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);
@@ -198,10 +188,10 @@ 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
+      typeof value === 'object' &&
+      'entry' in value &&
+      'options' in value &&
+      'handler' in value
     );
   }
 

package/src/dev/route-scanner.ts

@@ -1,32 +1,31 @@
-import { existsSync, promises as fs } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
-import type { GeneratedRoute } from "../types";
+import { existsSync, promises as fs } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+import type { GeneratedRoute } from '../types';
 
 export class RouteScanner {
   private routesDir: string;
   private excludePatterns: string[];
   private static readonly DEFAULT_EXCLUDE_PATTERNS = [
-    "*.test.ts",
-    "*.test.js",
-    "*.test.tsx",
-    "*.test.jsx",
-    "*.spec.ts",
-    "*.spec.js",
-    "*.spec.tsx",
-    "*.spec.jsx",
-    "*.tests.ts",
-    "*.tests.js",
-    "**/__tests__/**",
-    "*.interface.ts",
-    "*.type.ts",
-    "*.d.ts",
+    '*.test.ts',
+    '*.test.js',
+    '*.test.tsx',
+    '*.test.jsx',
+    '*.spec.ts',
+    '*.spec.js',
+    '*.spec.tsx',
+    '*.spec.jsx',
+    '*.tests.ts',
+    '*.tests.js',
+    '**/__tests__/**',
+    '*.interface.ts',
+    '*.type.ts',
+    '*.d.ts',
   ];
 
-  constructor(routesDir = "./routes", excludePatterns?: string[]) {
+  constructor(routesDir = './routes', excludePatterns?: string[]) {
     // Always resolve from the current working directory (user's project)
     this.routesDir = resolve(process.cwd(), routesDir);
-    this.excludePatterns =
-      excludePatterns || RouteScanner.DEFAULT_EXCLUDE_PATTERNS;
+    this.excludePatterns = excludePatterns || RouteScanner.DEFAULT_EXCLUDE_PATTERNS;
   }
 
   async scan(): Promise<GeneratedRoute[]> {
@@ -40,7 +39,7 @@ export class RouteScanner {
     try {
       await this.scanDirectory(this.routesDir, routes);
     } catch (error) {
-      if ((error as any).code === "ENOENT") {
+      if ((error as any).code === 'ENOENT') {
         console.warn(`  ✗ Routes directory not accessible: ${this.routesDir}`);
         return [];
       }
@@ -56,15 +55,16 @@ export class RouteScanner {
     for (const pattern of this.excludePatterns) {
       // Convert glob pattern to regex
       const regexPattern = pattern
-        .replace(/\./g, "\\.") // Escape dots
-        .replace(/\*/g, "[^/]*") // * matches anything except /
-        .replace(/\*\*/g, ".*") // ** matches anything including /
-        .replace(/\?/g, "."); // ? matches single character
+        .replace(/\./g, '\\.') // Escape dots
+        .replace(/\*\*/g, '__GLOBSTAR__') // protect ** before * replacement
+        .replace(/\*/g, '[^/]*') // * matches anything except /
+        .replace(/__GLOBSTAR__/g, '.*') // ** matches anything including /
+        .replace(/\?/g, '.'); // ? matches single character
 
       const regex = new RegExp(`^${regexPattern}$`);
 
       // Check both the full relative path and just the filename
-      const filename = relativePath.split(sep).pop() || "";
+      const filename = relativePath.split(sep).pop() || '';
       if (regex.test(relativePath) || regex.test(filename)) {
         return true;
       }
@@ -73,11 +73,7 @@ export class RouteScanner {
     return false;
   }
 
-  private async scanDirectory(
-    dir: string,
-    routes: GeneratedRoute[],
-    basePath = ""
-  ): Promise<void> {
+  private async scanDirectory(dir: string, routes: GeneratedRoute[], basePath = ''): Promise<void> {
     const entries = await fs.readdir(dir);
 
     for (const entry of entries) {
@@ -87,32 +83,30 @@ export class RouteScanner {
       if (stats.isDirectory()) {
         const newBasePath = basePath ? `${basePath}/${entry}` : entry;
         await this.scanDirectory(fullPath, routes, newBasePath);
-      } else if (entry.endsWith(".ts") || entry.endsWith(".js")) {
+      } else if (entry.endsWith('.ts') || entry.endsWith('.js')) {
         // Skip excluded files (test files, etc.)
         if (this.isExcluded(fullPath)) {
           continue;
         }
         const routePath = relative(this.routesDir, fullPath)
-          .replace(/\.(ts|js)$/, "")
+          .replace(/\.(ts|js)$/, '')
           .split(sep)
-          .join("/");
+          .join('/');
 
         try {
           // Convert Windows paths to URLs for import
           const importPath =
-            process.platform === "win32"
-              ? `file:///${fullPath.replace(/\\/g, "/")}`
-              : fullPath;
+            process.platform === 'win32' ? `file:///${fullPath.replace(/\\/g, '/')}` : fullPath;
 
           const module = await import(importPath);
 
-          if (module.default && typeof module.default === "function") {
+          if (module.default && typeof module.default === 'function') {
             routes.push({
-              name: "default",
+              name: 'default',
               path: fullPath,
-              method: "GET",
+              method: 'GET',
               options: {
-                method: "GET",
+                method: 'GET',
                 path: `/${routePath}`,
                 expose: true,
               },
@@ -120,15 +114,15 @@ export class RouteScanner {
           }
 
           for (const [name, value] of Object.entries(module)) {
-            if (name === "default") continue;
+            if (name === 'default') continue;
 
             // Check for new RouteDefinition format
             if (
               value &&
-              typeof value === "object" &&
-              "entry" in value &&
-              "options" in value &&
-              "handler" in value
+              typeof value === 'object' &&
+              'entry' in value &&
+              'options' in value &&
+              'handler' in value
             ) {
               const routeDef = value as any;
               routes.push({
@@ -161,7 +155,7 @@ export class RouteScanner {
   }
 
   enableWatch(callback: () => void) {
-    if (typeof Bun !== "undefined" && Bun.env.NODE_ENV === "development") {
+    if (typeof Bun !== 'undefined' && Bun.env.NODE_ENV === 'development') {
       console.log(`Watching for route changes in ${this.routesDir}`);
 
       setInterval(async () => {