vector-framework 0.9.9 → 1.1.1

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 });
         },
       });
 
@@ -87,8 +101,7 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
         throw new Error(`Failed to start server on ${hostname}:${port} - server object is invalid`);
       }
 
-      // Server logs are handled by CLI, keep this minimal
-      console.log(`→ Vector server running at http://${hostname}:${port}`);
+      // Server logs are handled by CLI
 
       return this.server;
     } catch (error: any) {
@@ -112,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');
     }
   }
 
@@ -125,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 () => {