vector-framework 0.8.1 → 0.8.2

package/src/cli/index.ts

@@ -1,34 +1,35 @@
 #!/usr/bin/env bun
 
-import { join } from 'node:path';
-import { parseArgs } from 'node:util';
-import vector from '../core/vector';
+import { watch } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import vector from "../core/vector";
 
 const { values, positionals } = parseArgs({
   args: Bun.argv.slice(2),
   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,
     },
   },
@@ -36,13 +37,15 @@ const { values, positionals } = parseArgs({
   allowPositionals: true,
 });
 
-const command = positionals[0] || 'dev';
+const command = positionals[0] || "dev";
 
 async function runDev() {
-  const isDev = command === 'dev';
-  console.log(`\n→ Starting Vector ${isDev ? 'development' : 'production'} server\n`);
+  const isDev = command === "dev";
+  console.log(
+    `\n→ Starting Vector ${isDev ? "development" : "production"} server\n`
+  );
 
-  const config = {
+  const config: any = {
     port: Number.parseInt(values.port as string),
     hostname: values.host as string,
     routesDir: values.routes as string,
@@ -50,22 +53,39 @@ async function runDev() {
     autoDiscover: true,
     cors: values.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,
   };
 
   try {
-    const userConfigPath = join(process.cwd(), 'vector.config.ts');
+    const userConfigPath = join(process.cwd(), "vector.config.ts");
     try {
       const userConfig = await import(userConfigPath);
       if (userConfig.default) {
-        Object.assign(config, userConfig.default);
+        // Properly merge config, preserving middleware arrays
+        const {
+          before,
+          finally: finallyMiddleware,
+          ...otherConfig
+        } = userConfig.default;
+
+        // Merge non-middleware config
+        Object.assign(config, otherConfig);
+
+        // Handle middleware arrays properly - these need to be set after Object.assign
+        // to avoid being overwritten
+        if (before) {
+          config.before = before;
+        }
+        if (finallyMiddleware) {
+          config.finally = finallyMiddleware;
+        }
       }
     } catch {
       // No user config file, use defaults
@@ -73,32 +93,56 @@ async function runDev() {
 
     await vector.serve(config);
 
-    const gray = '\x1b[90m';
-    const reset = '\x1b[0m';
-    const cyan = '\x1b[36m';
-    const green = '\x1b[32m';
+    const gray = "\x1b[90m";
+    const reset = "\x1b[0m";
+    const cyan = "\x1b[36m";
+    const green = "\x1b[32m";
 
     console.log(`  ${gray}Routes${reset}     ${config.routesDir}`);
     if (isDev && values.watch) {
-      console.log(`  ${gray}Watching${reset}   Enabled`);
+      console.log(`  ${gray}Watching${reset}   All project files`);
+
+      try {
+        // Watch entire project directory for changes
+        watch(process.cwd(), { recursive: true }, async (_, filename) => {
+          if (
+            filename &&
+            (filename.endsWith(".ts") ||
+              filename.endsWith(".js") ||
+              filename.endsWith(".json"))
+          ) {
+            console.log(`\n  🔄 File changed: ${filename}`);
+            console.log("  🔄 Restarting server...\n");
+
+            // Exit the current process, which will trigger a restart if using --watch flag
+            process.exit(0);
+          }
+        });
+      } catch (err) {
+        console.warn("  ⚠️  File watching not available");
+      }
     }
-    console.log(`  ${gray}CORS${reset}       ${values.cors ? 'Enabled' : 'Disabled'}`);
-    console.log(`  ${gray}Mode${reset}       ${isDev ? 'Development' : 'Production'}\n`);
+    console.log(
+      `  ${gray}CORS${reset}       ${values.cors ? "Enabled" : "Disabled"}`
+    );
+    console.log(
+      `  ${gray}Mode${reset}       ${isDev ? "Development" : "Production"}\n`
+    );
     console.log(
       `  ${green}Ready${reset} → ${cyan}http://${config.hostname}:${config.port}${reset}\n`
     );
   } catch (error) {
-    console.error('[ERROR] Failed to start server:', error);
+    console.error("[ERROR] Failed to start server:", error);
     process.exit(1);
   }
 }
 
 async function runBuild() {
-  console.log('\n→ Building Vector application\n');
+  console.log("\n→ Building Vector application\n");
 
   try {
-    const { RouteScanner } = await import('../dev/route-scanner');
-    const { RouteGenerator } = await import('../dev/route-generator');
+    const { RouteScanner } = await import("../dev/route-scanner");
+    const { RouteGenerator } = await import("../dev/route-generator");
 
     const scanner = new RouteScanner(values.routes as string);
     const generator = new RouteGenerator();
@@ -109,31 +153,31 @@ async function runBuild() {
     console.log(`  Generated ${routes.length} routes`);
 
     const buildProcess = Bun.spawn([
-      'bun',
-      'build',
-      'src/index.ts',
-      '--outdir',
-      'dist',
-      '--minify',
+      "bun",
+      "build",
+      "src/index.ts",
+      "--outdir",
+      "dist",
+      "--minify",
     ]);
     await buildProcess.exited;
 
-    console.log('\n  ✓ Build complete\n');
+    console.log("\n  ✓ Build complete\n");
   } catch (error) {
-    console.error('[ERROR] Build failed:', error);
+    console.error("[ERROR] Build failed:", error);
     process.exit(1);
   }
 }
 
 switch (command) {
-  case 'dev':
+  case "dev":
     await runDev();
     break;
-  case 'build':
+  case "build":
     await runBuild();
     break;
-  case 'start':
-    process.env.NODE_ENV = 'production';
+  case "start":
+    process.env.NODE_ENV = "production";
     await runDev();
     break;
   default:

package/src/core/router.ts

@@ -140,7 +140,8 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
       request = vectorRequest;
       try {
-        if (!options.expose) {
+        // Default expose to true if not specified
+        if (options.expose === false) {
           return APIError.forbidden('Forbidden');
         }
 

package/src/core/vector.ts

@@ -105,12 +105,6 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     this.server = new VectorServer<TTypes>(this.router, this.config);
     const bunServer = await this.server.start();
 
-    if (this.config.development && this.routeScanner) {
-      this.routeScanner.enableWatch(async () => {
-        await this.discoverRoutes();
-      });
-    }
-
     return bunServer;
   }
 
@@ -163,7 +157,7 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
         console.log(`✅ Loaded ${routes.length} routes from ${routesDir}`);
       }
     } catch (error) {
-      if ((error as any).code !== 'ENOENT') {
+      if ((error as any).code !== 'ENOENT' && (error as any).code !== 'ENOTDIR') {
         console.error('Failed to discover routes:', error);
       }
     }

package/src/dev/route-generator.ts

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from 'node:fs/promises';
+import { promises as fs } from 'node:fs';
 import { dirname, relative } from 'node:path';
 import type { GeneratedRoute } from '../types';
 
@@ -11,7 +11,7 @@ export class RouteGenerator {
 
   async generate(routes: GeneratedRoute[]): Promise<void> {
     const outputDir = dirname(this.outputPath);
-    await mkdir(outputDir, { recursive: true });
+    await fs.mkdir(outputDir, { recursive: true });
 
     const imports: string[] = [];
     const groupedByFile = new Map<string, GeneratedRoute[]>();
@@ -64,7 +64,7 @@ ${routeEntries.join('\n')}
 export default routes;
 `;
 
-    await writeFile(this.outputPath, content, 'utf-8');
+    await fs.writeFile(this.outputPath, content, 'utf-8');
     console.log(`Generated routes file: ${this.outputPath}`);
   }
 

package/src/dev/route-scanner.ts

@@ -1,4 +1,4 @@
-import { readdir, stat } from 'node:fs/promises';
+import { promises as fs } from 'node:fs';
 import { join, relative, resolve, sep } from 'node:path';
 import type { GeneratedRoute } from '../types';
 
@@ -26,11 +26,11 @@ export class RouteScanner {
   }
 
   private async scanDirectory(dir: string, routes: GeneratedRoute[], basePath = ''): Promise<void> {
-    const entries = await readdir(dir);
+    const entries = await fs.readdir(dir);
 
     for (const entry of entries) {
       const fullPath = join(dir, entry);
-      const stats = await stat(fullPath);
+      const stats = await fs.stat(fullPath);
 
       if (stats.isDirectory()) {
         const newBasePath = basePath ? `${basePath}/${entry}` : entry;

package/src/types/index.ts

@@ -64,7 +64,7 @@ export interface RouteOptions<TTypes extends VectorTypes = DefaultVectorTypes> {
   method: string;
   path: string;
   auth?: boolean;
-  expose?: boolean;
+  expose?: boolean; // defaults to true
   cache?: CacheOptions | number;
   rawRequest?: boolean;
   rawResponse?: boolean;