vector-framework 0.9.8 → 1.0.0

package/src/cli/index.ts

@@ -49,9 +49,6 @@ const command = positionals[0] || "dev";
 
 async function runDev() {
   const isDev = command === "dev";
-  console.log(
-    `\n→ Starting Vector ${isDev ? "development" : "production"} server\n`
-  );
 
   let server: any = null;
   let vector: any = null;
@@ -66,83 +63,62 @@ async function runDev() {
 
     // Create the actual server start promise
     const serverStartPromise = (async (): Promise<{ server: any; vector: any; config: any }> => {
-      try {
-        // 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
-        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 = config.development ?? isDev;
-        config.autoDiscover = true; // Always auto-discover routes
-
-        // 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",
-            maxAge: 86400,
-          };
-        }
+      // Load configuration using ConfigLoader
+      const configLoader = new ConfigLoader(values.config as string | undefined);
+      const config = await configLoader.load();
+
+      // Merge CLI options with loaded config
+      // Only use CLI values if config doesn't have them
+      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 = config.development ?? isDev;
+      config.autoDiscover = true; // Always auto-discover routes
+
+      // Apply CLI CORS option if not explicitly set in config
+      // Only apply default CORS if config.cors is undefined (not set)
+      if (config.cors === undefined && values.cors) {
+        config.cors = {
+          origin: "*",
+          credentials: true,
+          allowHeaders: "Content-Type, Authorization",
+          allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+          exposeHeaders: "Authorization",
+          maxAge: 86400,
+        };
+      }
 
-        // Get Vector instance and configure handlers
-        vector = getVectorInstance();
+      // 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);
-        }
-
-        // Load and set cache handler if configured
-        const cacheHandler = await configLoader.loadCacheHandler();
-        if (cacheHandler) {
-          vector.setCacheHandler(cacheHandler);
-        }
+      // Load and set auth handler if configured
+      const authHandler = await configLoader.loadAuthHandler();
+      if (authHandler) {
+        vector.setProtectedHandler(authHandler);
+      }
 
-        // Start the server
-        server = await vector.startServer(config);
+      // Load and set cache handler if configured
+      const cacheHandler = await configLoader.loadCacheHandler();
+      if (cacheHandler) {
+        vector.setCacheHandler(cacheHandler);
+      }
 
-        // Verify the server is actually running
-        if (!server || !server.port) {
-          throw new Error("Server started but is not responding correctly");
-        }
+      // Start the server
+      server = await vector.startServer(config);
 
-        const gray = "\x1b[90m";
-        const reset = "\x1b[0m";
-        const cyan = "\x1b[36m";
-        const green = "\x1b[32m";
-
-        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`
-        );
-
-        return { server, vector, config };
-      } catch (error) {
-        throw error;
+      // Verify the server is actually running
+      if (!server || !server.port) {
+        throw new Error("Server started but is not responding correctly");
       }
+
+      const cyan = "\x1b[36m";
+      const reset = "\x1b[0m";
+
+      console.log(
+        `\nListening on ${cyan}http://${config.hostname}:${config.port}${reset}\n`
+      );
+
+      return { server, vector, config };
     })();
 
     // Race between server startup and timeout
@@ -206,9 +182,13 @@ async function runDev() {
               await new Promise((resolve) => setTimeout(resolve, 100));
 
               // Clear module cache to ensure fresh imports
-              for (const key in require.cache) {
-                if (!key.includes("node_modules")) {
-                  delete require.cache[key];
+              // 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];
+                  }
                 }
               }
 
@@ -221,84 +201,93 @@ async function runDev() {
                 console.error("\n[Reload Error]", error.message || error);
                 // Don't exit the process on reload failures, just continue watching
               } finally {
-                // Reset flag after a delay
-                setTimeout(() => {
-                  isReloading = false;
-                }, 2000); // 2 second cooldown
+                // Reset flag immediately after reload completes
+                // The lastReloadTime check provides additional protection
+                isReloading = false;
               }
             }, 500); // Increased debounce to 500ms
           }
         });
-      } catch (err) {
-        console.warn("  ⚠️  File watching not available");
+      } catch {
+        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`);
-
-    // 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");
 
+    // 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
+    // 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",
+        "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(
+      const result = spawnSync(
         "bun",
-        ["build", "src/index.ts", "--outdir", "dist", "--minify"],
+        [
+          "build",
+          "src/cli/index.ts",
+          "--target",
+          "bun",
+          "--outfile",
+          "dist/server.js",
+          "--minify",
+        ],
         {
           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);
   }
 }

package/src/core/config-loader.ts

@@ -30,27 +30,21 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
     // 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) {
+      } catch (error: any) {
+        const red = "\x1b[31m";
+        const reset = "\x1b[0m";
         console.error(
-          `  ✗ Failed to load config from ${this.configPath}:`,
-          error
+          `${red}Error loading config: ${error.message || error}${reset}`
         );
-        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 = {};
     }
 

package/src/core/server.ts

@@ -87,8 +87,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) {

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/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

@@ -85,6 +85,7 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   before?: BeforeMiddlewareHandler<TTypes>[];
   finally?: AfterMiddlewareHandler<TTypes>[];
   routesDir?: string;
+  routeExcludePatterns?: string[];
   autoDiscover?: boolean;
   idleTimeout?: number;
 }
@@ -97,6 +98,7 @@ export interface VectorConfigSchema<TTypes extends VectorTypes = DefaultVectorTy
   reusePort?: boolean;
   development?: boolean;
   routesDir?: string;
+  routeExcludePatterns?: string[];
   idleTimeout?: number;
 
   // Middleware functions