vector-framework 1.0.0 → 1.2.0

package/src/cli/index.ts

@@ -1,54 +1,57 @@
 #!/usr/bin/env bun
 
-import { watch } from "node:fs";
-import { parseArgs } from "node:util";
-import { getVectorInstance } from "../core/vector";
-import { ConfigLoader } from "../core/config-loader";
+import { watch } from 'node:fs';
+import { parseArgs } from 'node:util';
+import { getVectorInstance } from '../core/vector';
+import { ConfigLoader } from '../core/config-loader';
+import { resolveHost, resolvePort, resolveRoutesDir } from './option-resolution';
 
 // Compatibility layer for both Node and Bun
-const args =
-  typeof Bun !== "undefined" ? Bun.argv.slice(2) : process.argv.slice(2);
+const args = typeof Bun !== 'undefined' ? Bun.argv.slice(2) : process.argv.slice(2);
 
 const { values, positionals } = parseArgs({
   args,
   options: {
     port: {
-      type: "string",
-      short: "p",
-      default: "3000",
+      type: 'string',
+      short: 'p',
+      default: '3000',
     },
     host: {
-      type: "string",
-      short: "h",
-      default: "localhost",
+      type: 'string',
+      short: 'h',
+      default: 'localhost',
     },
     routes: {
-      type: "string",
-      short: "r",
-      default: "./routes",
+      type: 'string',
+      short: 'r',
+      default: './routes',
     },
     watch: {
-      type: "boolean",
-      short: "w",
+      type: 'boolean',
+      short: 'w',
       default: true,
     },
     cors: {
-      type: "boolean",
+      type: 'boolean',
       default: true,
     },
     config: {
-      type: "string",
-      short: "c",
+      type: 'string',
+      short: 'c',
     },
   },
   strict: true,
   allowPositionals: true,
 });
 
-const command = positionals[0] || "dev";
+const command = positionals[0] || 'dev';
+const hasRoutesOption = args.some((arg) => arg === '--routes' || arg === '-r' || arg.startsWith('--routes='));
+const hasHostOption = args.some((arg) => arg === '--host' || arg === '-h' || arg.startsWith('--host='));
+const hasPortOption = args.some((arg) => arg === '--port' || arg === '-p' || arg.startsWith('--port='));
 
 async function runDev() {
-  const isDev = command === "dev";
+  const isDev = command === 'dev';
 
   let server: any = null;
   let vector: any = null;
@@ -57,21 +60,22 @@ async function runDev() {
     // Create a timeout promise that rejects after 10 seconds
     const timeoutPromise = new Promise<never>((_, reject) => {
       setTimeout(() => {
-        reject(new Error("Server startup timed out (10s)"));
+        reject(new Error('Server startup timed out (10s)'));
       }, 10000);
     });
 
     // Create the actual server start promise
     const serverStartPromise = (async (): Promise<{ server: any; vector: any; config: any }> => {
-      // 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);
+      const explicitConfigPath = values.config as string | undefined;
+      const configLoader = new ConfigLoader(explicitConfigPath);
+      const loadedConfig = await configLoader.load();
+      const config = { ...loadedConfig } as Record<string, any>;
+
+      // Merge CLI options with loaded config.
+      // Explicit --port/--host always override config values.
+      config.port = resolvePort(config.port, hasPortOption, values.port as string);
+      config.hostname = resolveHost(config.hostname, hasHostOption, values.host as string);
+      config.routesDir = resolveRoutesDir(config.routesDir, hasRoutesOption, values.routes as string);
       config.development = config.development ?? isDev;
       config.autoDiscover = true; // Always auto-discover routes
 
@@ -79,11 +83,11 @@ async function runDev() {
       // Only apply default CORS if config.cors is undefined (not set)
       if (config.cors === undefined && values.cors) {
         config.cors = {
-          origin: "*",
+          origin: '*',
           credentials: true,
-          allowHeaders: "Content-Type, Authorization",
-          allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-          exposeHeaders: "Authorization",
+          allowHeaders: 'Content-Type, Authorization',
+          allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+          exposeHeaders: 'Authorization',
           maxAge: 86400,
         };
       }
@@ -108,15 +112,13 @@ async function runDev() {
 
       // Verify the server is actually running
       if (!server || !server.port) {
-        throw new Error("Server started but is not responding correctly");
+        throw new Error('Server started but is not responding correctly');
       }
 
-      const cyan = "\x1b[36m";
-      const reset = "\x1b[0m";
+      const cyan = '\x1b[36m';
+      const reset = '\x1b[0m';
 
-      console.log(
-        `\nListening on ${cyan}http://${config.hostname}:${config.port}${reset}\n`
-      );
+      console.log(`\nListening on ${cyan}http://${config.hostname}:${config.port}${reset}\n`);
 
       return { server, vector, config };
     })();
@@ -144,17 +146,14 @@ async function runDev() {
           const now = Date.now();
           if (isReloading || now - lastReloadTime < 1000) return;
 
+          const segments = filename ? filename.split(/[/\\]/) : [];
+          const excluded = segments.some((s) => ['node_modules', '.git', '.vector', 'dist'].includes(s));
           if (
             filename &&
-            (filename.endsWith(".ts") ||
-              filename.endsWith(".js") ||
-              filename.endsWith(".json")) &&
-            !filename.includes("node_modules") &&
-            !filename.includes(".git") &&
-            !filename.includes(".vector") && // Ignore generated files
-            !filename.includes("dist") && // Ignore dist folder
-            !filename.includes("bun.lockb") && // Ignore lock files
-            !filename.endsWith(".generated.ts") // Ignore generated files
+            (filename.endsWith('.ts') || filename.endsWith('.js') || filename.endsWith('.json')) &&
+            !excluded &&
+            !filename.includes('bun.lockb') && // Ignore lock files
+            !filename.endsWith('.generated.ts') // Ignore generated files
           ) {
             // Track changed files
             changedFiles.add(filename);
@@ -181,24 +180,13 @@ async function runDev() {
               // Small delay to ensure file system operations complete
               await new Promise((resolve) => setTimeout(resolve, 100));
 
-              // Clear module cache to ensure fresh imports
-              // 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];
-                  }
-                }
-              }
-
               // Restart the server
               try {
                 const result = await startServer();
                 server = result.server;
                 vector = result.vector;
               } catch (error: any) {
-                console.error("\n[Reload Error]", error.message || error);
+                console.error('\n[Reload Error]', error.message || error);
                 // Don't exit the process on reload failures, just continue watching
               } finally {
                 // Reset flag immediately after reload completes
@@ -209,18 +197,18 @@ async function runDev() {
           }
         });
       } catch {
-        const yellow = "\x1b[33m";
-        const reset = "\x1b[0m";
+        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";
+    const red = '\x1b[31m';
+    const reset = '\x1b[0m';
 
     console.error(`\n${red}Error: ${error.message || error}${reset}\n`);
 
-    if (error.stack && process.env.NODE_ENV === "development") {
+    if (error.stack && process.env.NODE_ENV === 'development') {
       console.error(error.stack);
     }
 
@@ -228,81 +216,15 @@ async function runDev() {
   }
 }
 
-async function runBuild() {
-  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);
-
-    // Step 2: Build the application with Bun
-    if (typeof Bun !== "undefined") {
-      // Build the CLI as an executable
-      const buildProcess = Bun.spawn([
-        "bun",
-        "build",
-        "src/cli/index.ts",
-        "--target",
-        "bun",
-        "--outfile",
-        "dist/server.js",
-        "--minify",
-      ]);
-
-      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");
-      const result = spawnSync(
-        "bun",
-        [
-          "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("\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);
-  }
-}
-
 switch (command) {
-  case "dev":
+  case 'dev':
     await runDev();
     break;
-  case "build":
-    await runBuild();
-    break;
-  case "start":
-    process.env.NODE_ENV = "production";
+  case 'start': {
+    process.env.NODE_ENV = 'production';
     await runDev();
     break;
+  }
   default:
     console.error(`Unknown command: ${command}`);
     console.log(`
@@ -310,15 +232,14 @@ Usage: vector [command] [options]
 
 Commands:
   dev     Start development server (default)
-  build   Build for production
   start   Start production server
 
 Options:
   -p, --port <port>      Port to listen on (default: 3000)
   -h, --host <host>      Hostname to bind to (default: localhost)
-  -r, --routes <dir>     Routes directory (default: ./routes)
+  -r, --routes <dir>     Routes directory (dev/start)
   -w, --watch            Watch for file changes (default: true)
-  -c, --config <path>    Path to config file (default: vector.config.ts)
+  -c, --config <path>    Path to config file (dev/start)
   --cors                 Enable CORS (default: true)
 `);
     process.exit(1);

package/src/cli/option-resolution.ts

@@ -0,0 +1,40 @@
+export function resolveRoutesDir(
+  configRoutesDir: string | null | undefined,
+  hasRoutesOption: boolean,
+  cliRoutes: string
+): string {
+  if (hasRoutesOption) {
+    return cliRoutes;
+  }
+
+  return configRoutesDir ?? cliRoutes;
+}
+
+function parseAndValidatePort(value: unknown): number {
+  const parsed = typeof value === 'number' ? value : Number.parseInt(String(value), 10);
+
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error(`Invalid port value: ${String(value)}`);
+  }
+
+  return parsed;
+}
+
+export function resolvePort(configPort: number | null | undefined, hasPortOption: boolean, cliPort: string): number {
+  if (hasPortOption) {
+    return parseAndValidatePort(cliPort);
+  }
+
+  const resolved = configPort ?? cliPort;
+  return parseAndValidatePort(resolved);
+}
+
+export function resolveHost(configHost: string | null | undefined, hasHostOption: boolean, cliHost: string): string {
+  const resolved = hasHostOption ? cliHost : (configHost ?? cliHost);
+
+  if (typeof resolved !== 'string' || resolved.length === 0) {
+    throw new Error(`Invalid host value: ${String(resolved)}`);
+  }
+
+  return resolved;
+}

package/src/constants/index.ts

@@ -91,3 +91,10 @@ export const HTTP_METHODS = {
   OPTIONS: 'OPTIONS',
   HEAD: 'HEAD',
 } as const;
+
+export const STATIC_RESPONSES: { NOT_FOUND: Response } = {
+  NOT_FOUND: new Response(JSON.stringify({ error: true, message: 'Not Found', statusCode: 404 }), {
+    status: 404,
+    headers: { 'content-type': 'application/json' },
+  }) as Response,
+};

package/src/core/config-loader.ts

@@ -1,6 +1,6 @@
-import { existsSync } from "node:fs";
-import { resolve, isAbsolute } from "node:path";
-import { toFileUrl } from "../utils/path";
+import { existsSync } from 'node:fs';
+import { resolve, isAbsolute } from 'node:path';
+import { toFileUrl } from '../utils/path';
 import type {
   CacheHandler,
   CorsOptions,
@@ -9,21 +9,19 @@ import type {
   VectorConfig,
   VectorConfigSchema,
   VectorTypes,
-} from "../types";
+} from '../types';
 
 export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
   private configPath: string;
   private config: VectorConfigSchema<TTypes> | null = null;
-  private configSource: "user" | "default" = "default";
+  private configSource: 'user' | 'default' = 'default';
 
   constructor(configPath?: string) {
     // Use provided config path or default to vector.config.ts
-    const path = configPath || "vector.config.ts";
+    const path = configPath || 'vector.config.ts';
 
     // Handle absolute vs relative paths
-    this.configPath = isAbsolute(path)
-      ? path
-      : resolve(process.cwd(), path);
+    this.configPath = isAbsolute(path) ? path : resolve(process.cwd(), path);
   }
 
   async load(): Promise<VectorConfig<TTypes>> {
@@ -34,13 +32,11 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
         const userConfigPath = toFileUrl(this.configPath);
         const userConfig = await import(userConfigPath);
         this.config = userConfig.default || userConfig;
-        this.configSource = "user";
+        this.configSource = 'user';
       } catch (error: any) {
-        const red = "\x1b[31m";
-        const reset = "\x1b[0m";
-        console.error(
-          `${red}Error loading config: ${error.message || error}${reset}`
-        );
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[Vector] Failed to load config from ${this.configPath}: ${msg}`);
+        console.error('[Vector] Server is using default configuration. Fix your config file and restart.');
         this.config = {};
       }
     } else {
@@ -52,7 +48,7 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
     return await this.buildLegacyConfig();
   }
 
-  getConfigSource(): "user" | "default" {
+  getConfigSource(): 'user' | 'default' {
     return this.configSource;
   }
 
@@ -65,8 +61,10 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
       config.hostname = this.config.hostname;
       config.reusePort = this.config.reusePort;
       config.development = this.config.development;
-      config.routesDir = this.config.routesDir || "./routes";
+      config.routesDir = this.config.routesDir || './routes';
       config.idleTimeout = this.config.idleTimeout;
+      config.defaults = this.config.defaults;
+      config.openapi = this.config.openapi;
     }
 
     // Always auto-discover routes
@@ -74,14 +72,14 @@ export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
 
     // CORS configuration
     if (this.config?.cors) {
-      if (typeof this.config.cors === "boolean") {
+      if (typeof this.config.cors === 'boolean') {
         config.cors = this.config.cors
           ? {
-              origin: "*",
+              origin: '*',
               credentials: true,
-              allowHeaders: "Content-Type, Authorization",
-              allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-              exposeHeaders: "Authorization",
+              allowHeaders: 'Content-Type, Authorization',
+              allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+              exposeHeaders: 'Authorization',
               maxAge: 86400,
             }
           : undefined;