vector-framework 0.9.5 → 0.9.7

package/src/cli/index.ts

@@ -36,6 +36,10 @@ const { values, positionals } = parseArgs({
       type: "boolean",
       default: true,
     },
+    config: {
+      type: "string",
+      short: "c",
+    },
   },
   strict: true,
   allowPositionals: true,
@@ -52,80 +56,97 @@ async function runDev() {
   let server: any = null;
   let vector: any = null;
 
-  async function startServer() {
-    try {
-      // Load configuration using ConfigLoader
-      const configLoader = new ConfigLoader();
-      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,
-        };
-      }
+  async function startServer(): Promise<{ server: any; vector: any; config: any }> {
+    // Create a timeout promise that rejects after 10 seconds
+    const timeoutPromise = new Promise<never>((_, reject) => {
+      setTimeout(() => {
+        reject(new Error("Server startup timed out (10s)"));
+      }, 10000);
+    });
 
-      // Get Vector instance and configure handlers
-      vector = getVectorInstance();
+    // 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 and set auth handler if configured
-      const authHandler = await configLoader.loadAuthHandler();
-      if (authHandler) {
-        vector.setProtectedHandler(authHandler);
-      }
+        // Get Vector instance and configure handlers
+        vector = getVectorInstance();
 
-      // 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);
+        }
+
+        // Load and set cache handler if configured
+        const cacheHandler = await configLoader.loadCacheHandler();
+        if (cacheHandler) {
+          vector.setCacheHandler(cacheHandler);
+        }
 
-      // Start the server
-      server = await vector.startServer(config);
+        // Start the server
+        server = await vector.startServer(config);
 
-      const gray = "\x1b[90m";
-      const reset = "\x1b[0m";
-      const cyan = "\x1b[36m";
-      const green = "\x1b[32m";
+        // Verify the server is actually running
+        if (!server || !server.port) {
+          throw new Error("Server started but is not responding correctly");
+        }
 
-      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`);
+        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;
       }
-      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) {
-      console.error("[ERROR] Failed to start server:", error);
-      throw error;
-    }
+    // Race between server startup and timeout
+    return await Promise.race([serverStartPromise, timeoutPromise]);
   }
 
   try {
@@ -196,8 +217,9 @@ async function runDev() {
                 const result = await startServer();
                 server = result.server;
                 vector = result.vector;
-              } catch (error) {
-                console.error("  ❌ Failed to reload server:", error);
+              } catch (error: any) {
+                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(() => {
@@ -211,8 +233,26 @@ async function runDev() {
         console.warn("  ⚠️  File watching not available");
       }
     }
-  } catch (error) {
-    console.error("[ERROR] Failed to start server:", error);
+  } 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}`);
+    }
+
+    if (error.stack) {
+      console.error(`\nStack trace:`);
+      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);
   }
 }
@@ -289,6 +329,7 @@ Options:
   -h, --host <host>      Hostname to bind to (default: localhost)
   -r, --routes <dir>     Routes directory (default: ./routes)
   -w, --watch            Watch for file changes (default: true)
+  -c, --config <path>    Path to config file (default: vector.config.ts)
   --cors                 Enable CORS (default: true)
 `);
     process.exit(1);

package/src/core/config-loader.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, isAbsolute } from "node:path";
 import { toFileUrl } from "../utils/path";
 import type {
   CacheHandler,
@@ -16,9 +16,14 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
   private config: VectorConfigSchema<TTypes> | null = null;
   private configSource: "user" | "default" = "default";
 
-  constructor(configPath = "vector.config.ts") {
-    // Always resolve from the current working directory (user's project)
-    this.configPath = resolve(process.cwd(), configPath);
+  constructor(configPath?: string) {
+    // Use provided config path or default to vector.config.ts
+    const path = configPath || "vector.config.ts";
+
+    // Handle absolute vs relative paths
+    this.configPath = isAbsolute(path)
+      ? path
+      : resolve(process.cwd(), path);
   }
 
   async load(): Promise<VectorConfig<TTypes>> {
@@ -67,6 +72,7 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
       config.reusePort = this.config.reusePort;
       config.development = this.config.development;
       config.routesDir = this.config.routesDir || "./routes";
+      config.idleTimeout = this.config.idleTimeout;
     }
 
     // Always auto-discover routes

package/src/core/server.ts

@@ -1,7 +1,12 @@
-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;
@@ -14,36 +19,38 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
     this.config = config;
 
     if (config.cors) {
-      const { preflight, corsify } = cors(this.normalizeCorsOptions(config.cors));
+      const { preflight, corsify } = cors(
+        this.normalizeCorsOptions(config.cors)
+      );
       this.corsHandler = { preflight, corsify };
     }
   }
 
   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);
         }
 
@@ -57,33 +64,55 @@ export class VectorServer<TTypes extends VectorTypes = DefaultVectorTypes> {
 
         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 });
       }
     };
 
-    this.server = Bun.serve({
-      port,
-      hostname,
-      reusePort: this.config.reusePort !== false,
-      fetch,
-      error: (error) => {
-        console.error('[ERROR] Server error:', error);
-        return new Response('Internal Server Error', { status: 500 });
-      },
-    });
+    try {
+      this.server = Bun.serve({
+        port,
+        hostname,
+        reusePort: this.config.reusePort !== false,
+        fetch,
+        idleTimeout: this.config.idleTimeout || 60,
+        error: (error) => {
+          console.error("[ERROR] Server error:", error);
+          return new Response("Internal Server Error", { status: 500 });
+        },
+      });
+
+      // Validate that the server actually started
+      if (!this.server || !this.server.port) {
+        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, keep this minimal
+      console.log(`→ Vector server running at http://${hostname}:${port}`);
+
+      return this.server;
+    } catch (error: any) {
+      // Enhance error message with context for common issues
+      if (error.code === 'EADDRINUSE' || error.message?.includes('address already in use')) {
+        error.message = `Port ${port} is already in use`;
+        error.port = port;
+      } else if (error.code === 'EACCES' || error.message?.includes('permission denied')) {
+        error.message = `Permission denied to bind to port ${port}`;
+        error.port = port;
+      } else if (error.message?.includes('EADDRNOTAVAIL')) {
+        error.message = `Cannot bind to hostname ${hostname}`;
+        error.hostname = hostname;
+      }
 
-    return this.server;
+      throw error;
+    }
   }
 
   stop() {
     if (this.server) {
       this.server.stop();
       this.server = null;
-      console.log('Server stopped');
+      console.log("Server stopped");
     }
   }
 
@@ -96,7 +125,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/types/index.ts

@@ -83,6 +83,7 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   finally?: AfterMiddlewareHandler<TTypes>[];
   routesDir?: string;
   autoDiscover?: boolean;
+  idleTimeout?: number;
 }
 
 // New config-driven schema - flat structure
@@ -93,18 +94,19 @@ export interface VectorConfigSchema<TTypes extends VectorTypes = DefaultVectorTy
   reusePort?: boolean;
   development?: boolean;
   routesDir?: string;
-  
+  idleTimeout?: number;
+
   // Middleware functions
   before?: BeforeMiddlewareHandler<TTypes>[];
   after?: AfterMiddlewareHandler<TTypes>[];
-  
+
   // Handler functions
   auth?: ProtectedHandler<TTypes>;
   cache?: CacheHandler;
-  
+
   // CORS configuration
   cors?: CorsOptions | boolean;
-  
+
   // Custom types for TypeScript
   types?: VectorTypes;
 }