vector-framework 0.9.7 → 0.9.9

package/src/core/router.ts

@@ -1,4 +1,5 @@
 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';
@@ -113,30 +114,63 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
     );
   }
 
-  private wrapHandler(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>) {
-    return async (request: any) => {
-      // Ensure request has required properties
-      const vectorRequest = request as VectorRequest<TTypes>;
+  private prepareRequest(
+    request: VectorRequest<TTypes>,
+    options?: {
+      params?: Record<string, string>;
+      route?: string;
+      metadata?: any;
+    }
+  ): void {
+    // Initialize context if not present
+    if (!request.context) {
+      request.context = {} as any;
+    }
 
-      // Initialize context if not present
-      if (!vectorRequest.context) {
-        vectorRequest.context = {} as any;
-      }
+    // Set params and route if provided
+    if (options?.params !== undefined) {
+      request.params = options.params;
+    }
+    if (options?.route !== undefined) {
+      request.route = options.route;
+    }
+    if (options?.metadata !== undefined) {
+      request.metadata = options.metadata;
+    }
 
-      // Parse query parameters from URL (handles duplicate params as arrays)
-      if (!vectorRequest.query && vectorRequest.url) {
-        const url = new URL(vectorRequest.url);
-        const query: Record<string, string | string[]> = {};
-        for (let [k, v] of url.searchParams) {
-          query[k] = query[k] ? ([] as string[]).concat(query[k], v) : v;
+    // Parse query parameters from URL if not already parsed
+    if (!request.query && request.url) {
+      const url = new URL(request.url);
+      const query: Record<string, string | string[]> = {};
+      for (const [key, value] of url.searchParams) {
+        if (key in query) {
+          if (Array.isArray(query[key])) {
+            (query[key] as string[]).push(value);
+          } else {
+            query[key] = [query[key] as string, value];
+          }
+        } else {
+          query[key] = value;
         }
-        vectorRequest.query = query;
       }
+      request.query = query;
+    }
 
-      // Add metadata to request if provided
-      if (options.metadata) {
-        vectorRequest.metadata = options.metadata;
-      }
+    // Parse cookies if not already parsed
+    if (!request.cookies) {
+      withCookies(request as any);
+    }
+  }
+
+  private wrapHandler(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>) {
+    return async (request: any) => {
+      // Ensure request has required properties
+      const vectorRequest = request as VectorRequest<TTypes>;
+
+      // Prepare the request with common logic
+      this.prepareRequest(vectorRequest, {
+        metadata: options.metadata
+      });
 
       request = vectorRequest;
       try {
@@ -182,22 +216,45 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
         let result;
         const cacheOptions = options.cache;
 
+        // Create cache factory that handles Response objects
+        const cacheFactory = async () => {
+          const res = await handler(request);
+          // If Response, extract data for caching
+          if (res instanceof Response) {
+            return {
+              _isResponse: true,
+              body: await res.text(),
+              status: res.status,
+              headers: Object.fromEntries(res.headers.entries())
+            };
+          }
+          return res;
+        };
+
         if (cacheOptions && typeof cacheOptions === 'number' && cacheOptions > 0) {
           const cacheKey = this.cacheManager.generateKey(request as any, {
             authUser: request.authUser,
           });
-          result = await this.cacheManager.get(cacheKey, () => handler(request), cacheOptions);
+          result = await this.cacheManager.get(cacheKey, cacheFactory, cacheOptions);
         } else if (cacheOptions && typeof cacheOptions === 'object' && cacheOptions.ttl) {
           const cacheKey =
             cacheOptions.key ||
             this.cacheManager.generateKey(request as any, {
               authUser: request.authUser,
             });
-          result = await this.cacheManager.get(cacheKey, () => handler(request), cacheOptions.ttl);
+          result = await this.cacheManager.get(cacheKey, cacheFactory, cacheOptions.ttl);
         } else {
           result = await handler(request);
         }
 
+        // Reconstruct Response if it was cached
+        if (result && typeof result === 'object' && result._isResponse === true) {
+          result = new Response(result.body, {
+            status: result.status,
+            headers: result.headers
+          });
+        }
+
         let response: Response;
         if (options.rawResponse || result instanceof Response) {
           response = result instanceof Response ? result : new Response(result);
@@ -235,16 +292,17 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
     const url = new URL(request.url);
     const pathname = url.pathname;
 
-    for (const [method, regex, handlers] of this.routes) {
+    for (const [method, regex, handlers, path] of this.routes) {
       if (request.method === 'OPTIONS' || request.method === method) {
         const match = pathname.match(regex);
         if (match) {
           const req = request as any as VectorRequest<TTypes>;
-          // Initialize context for new request
-          if (!req.context) {
-            req.context = {} as any;
-          }
-          req.params = match.groups || {};
+
+          // Prepare the request with common logic
+          this.prepareRequest(req, {
+            params: match.groups || {},
+            route: path || pathname
+          });
 
           for (const handler of handlers) {
             const response = await handler(req as any);

package/src/core/vector.ts

@@ -86,6 +86,11 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     // Clear previous middleware to avoid accumulation across multiple starts
     this.middlewareManager.clear();
 
+    // Only clear routes if we're doing auto-discovery
+    if (this.config.autoDiscover !== false) {
+      this.router.clearRoutes();
+    }
+
     if (config?.before) {
       this.middlewareManager.addBefore(...config.before);
     }
@@ -106,10 +111,11 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
 
   private async discoverRoutes() {
     const routesDir = this.config.routesDir || "./routes";
+    const excludePatterns = this.config.routeExcludePatterns;
 
     // Always create a new RouteScanner with the current config's routesDir
     // to ensure we're using the correct path from the user's config
-    this.routeScanner = new RouteScanner(routesDir);
+    this.routeScanner = new RouteScanner(routesDir, excludePatterns);
 
     if (!this.routeGenerator) {
       this.routeGenerator = new RouteGenerator();
@@ -208,9 +214,8 @@ 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();
+    // Don't reset managers or routes - they persist for the singleton
+    // Routes will be cleared on next startServer() call
   }
 
   getServer(): VectorServer<TTypes> | null {

package/src/dev/route-scanner.ts

@@ -1,13 +1,32 @@
-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;
-
-  constructor(routesDir = './routes') {
+  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",
+  ];
+
+  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;
   }
 
   async scan(): Promise<GeneratedRoute[]> {
@@ -21,7 +40,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 [];
       }
@@ -31,7 +50,34 @@ export class RouteScanner {
     return routes;
   }
 
-  private async scanDirectory(dir: string, routes: GeneratedRoute[], basePath = ''): Promise<void> {
+  private isExcluded(filePath: string): boolean {
+    const relativePath = relative(this.routesDir, filePath);
+
+    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
+
+      const regex = new RegExp(`^${regexPattern}$`);
+
+      // Check both the full relative path and just the filename
+      const filename = relativePath.split(sep).pop() || "";
+      if (regex.test(relativePath) || regex.test(filename)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  private async scanDirectory(
+    dir: string,
+    routes: GeneratedRoute[],
+    basePath = ""
+  ): Promise<void> {
     const entries = await fs.readdir(dir);
 
     for (const entry of entries) {
@@ -41,26 +87,32 @@ 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,
               },
@@ -68,10 +120,16 @@ 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) {
+            if (
+              value &&
+              typeof value === "object" &&
+              "entry" in value &&
+              "options" in value &&
+              "handler" in value
+            ) {
               const routeDef = value as any;
               routes.push({
                 name,
@@ -103,7 +161,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 () => {

package/src/http.ts

@@ -1,17 +1,13 @@
-import {
-  cors,
-  type IRequest,
-  type RouteEntry,
-  withContent,
-  withCookies,
-} from "itty-router";
+import { cors, type IRequest, type RouteEntry, withContent } from "itty-router";
 import { CONTENT_TYPES, HTTP_STATUS } from "./constants";
 import type {
+  CacheOptions,
   DefaultVectorTypes,
   GetAuthType,
   VectorRequest,
   VectorTypes,
 } from "./types";
+import { getVectorInstance } from "./core/vector";
 
 export interface ProtectedRequest<
   TTypes extends VectorTypes = DefaultVectorTypes
@@ -33,7 +29,9 @@ interface ExtendedApiOptions extends ApiOptions {
   path: string;
 }
 
-export interface RouteDefinition<TTypes extends VectorTypes = DefaultVectorTypes> {
+export interface RouteDefinition<
+  TTypes extends VectorTypes = DefaultVectorTypes
+> {
   entry: RouteEntry;
   options: ExtendedApiOptions;
   handler: (req: VectorRequest<TTypes>) => Promise<unknown>;
@@ -64,7 +62,7 @@ export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
   return {
     entry,
     options,
-    handler: fn
+    handler: fn,
   };
 }
 
@@ -263,7 +261,6 @@ export const protectedRoute = async <
   responseContentType?: string
 ) => {
   // Get the Vector instance to access the protected handler
-  const { getVectorInstance } = await import("./core/vector");
   const vector = getVectorInstance();
 
   const protectedHandler = vector.getProtectedHandler();
@@ -290,7 +287,7 @@ export interface ApiOptions {
   expose?: boolean;
   rawRequest?: boolean;
   rawResponse?: boolean;
-  cache?: number | null;
+  cache?: CacheOptions | number | null;
   responseContentType?: string;
 }
 
@@ -325,8 +322,6 @@ export function api<TTypes extends VectorTypes = DefaultVectorTypes>(
         await withContent(request);
       }
 
-      withCookies(request);
-
       // Cache handling is now done in the router
       const result = await fn(request as any as VectorRequest<TTypes>);
 

package/src/middleware/manager.ts

@@ -45,7 +45,13 @@ export class MiddlewareManager<
     let currentResponse = response;
 
     for (const handler of this.finallyHandlers) {
-      currentResponse = await handler(currentResponse, request);
+      try {
+        currentResponse = await handler(currentResponse, request);
+      } catch (error) {
+        // Log but don't throw - we don't want to break the response chain
+        console.error('After middleware error:', error);
+        // Continue with the current response
+      }
     }
 
     return currentResponse;

package/src/types/index.ts

@@ -51,6 +51,9 @@ export interface VectorRequest<TTypes extends VectorTypes = DefaultVectorTypes>
   metadata?: GetMetadataType<TTypes>;
   content?: any;
   params?: Record<string, string>;
+  query: { [key: string]: string | string[] | undefined };
+  headers: Headers;
+  cookies?: Record<string, string>;
   startTime?: number;
   [key: string]: any;
 }
@@ -82,6 +85,7 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   before?: BeforeMiddlewareHandler<TTypes>[];
   finally?: AfterMiddlewareHandler<TTypes>[];
   routesDir?: string;
+  routeExcludePatterns?: string[];
   autoDiscover?: boolean;
   idleTimeout?: number;
 }
@@ -94,6 +98,7 @@ export interface VectorConfigSchema<TTypes extends VectorTypes = DefaultVectorTy
   reusePort?: boolean;
   development?: boolean;
   routesDir?: string;
+  routeExcludePatterns?: string[];
   idleTimeout?: number;
 
   // Middleware functions