vector-framework 0.8.2 → 0.9.0

package/src/core/config-loader.ts

@@ -0,0 +1,193 @@
+import { resolve } from 'node:path';
+import { toFileUrl } from '../utils/path';
+import type {
+  AfterMiddlewareHandler,
+  BeforeMiddlewareHandler,
+  CacheHandler,
+  CorsOptions,
+  DefaultVectorTypes,
+  ProtectedHandler,
+  VectorConfig,
+  VectorConfigSchema,
+  VectorTypes,
+} from '../types';
+
+export class ConfigLoader<TTypes extends VectorTypes = DefaultVectorTypes> {
+  private configPath: string;
+  private config: VectorConfigSchema<TTypes> | null = null;
+
+  constructor(configPath = 'vector.config.ts') {
+    this.configPath = resolve(process.cwd(), configPath);
+  }
+
+  async load(): Promise<VectorConfig<TTypes>> {
+    try {
+      // Try to load user config
+      const userConfigPath = toFileUrl(this.configPath);
+      const userConfig = await import(userConfigPath);
+      this.config = userConfig.default || userConfig;
+    } catch (error) {
+      // No config file, use defaults
+      console.log('No vector.config.ts found, using defaults');
+      this.config = {};
+    }
+
+    // Convert new config schema to legacy VectorConfig format
+    return await this.buildLegacyConfig();
+  }
+
+  private async buildLegacyConfig(): Promise<VectorConfig<TTypes>> {
+    const config: VectorConfig<TTypes> = {};
+
+    // Server configuration
+    if (this.config?.server) {
+      config.port = this.config.server.port;
+      config.hostname = this.config.server.hostname;
+      config.reusePort = this.config.server.reusePort;
+      config.development = this.config.server.development;
+    }
+
+    // Routes configuration
+    if (this.config?.routes) {
+      config.routesDir = this.config.routes.dir || './routes';
+      config.autoDiscover = this.config.routes.autoDiscover !== false;
+    } else {
+      config.routesDir = './routes';
+      config.autoDiscover = true;
+    }
+
+    // CORS configuration
+    if (this.config?.cors) {
+      if (typeof this.config.cors === 'boolean') {
+        config.cors = this.config.cors
+          ? {
+              origin: '*',
+              credentials: true,
+              allowHeaders: 'Content-Type, Authorization',
+              allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+              exposeHeaders: 'Authorization',
+              maxAge: 86400,
+            }
+          : undefined;
+      } else {
+        config.cors = this.config.cors as CorsOptions;
+      }
+    }
+
+    // Load middleware - support both direct functions and file paths
+    if (this.config?.before) {
+      // Direct functions provided
+      console.log('Using direct before middleware functions:', this.config.before.length);
+      config.before = this.config.before;
+    } else if (this.config?.middleware?.before) {
+      // File paths provided (legacy)
+      console.log('Loading before middleware from file paths:', this.config.middleware.before);
+      config.before = await this.loadMiddleware<BeforeMiddlewareHandler<TTypes>>(
+        this.config.middleware.before
+      );
+      console.log('Loaded before middleware:', config.before?.length);
+    }
+
+    if (this.config?.after) {
+      // Direct functions provided
+      console.log('Using direct after middleware functions:', this.config.after.length);
+      config.finally = this.config.after;
+    } else if (this.config?.middleware?.after) {
+      // File paths provided (legacy)
+      console.log('Loading after middleware from file paths:', this.config.middleware.after);
+      config.finally = await this.loadMiddleware<AfterMiddlewareHandler<TTypes>>(
+        this.config.middleware.after
+      );
+      console.log('Loaded after middleware:', config.finally?.length);
+    }
+
+    return config;
+  }
+
+  private async loadMiddleware<T>(paths: string[]): Promise<T[]> {
+    const middleware: T[] = [];
+
+    for (const path of paths) {
+      try {
+        const modulePath = resolve(process.cwd(), path);
+        const importPath = toFileUrl(modulePath);
+        const module = await import(importPath);
+        const handler = module.default || module;
+
+        if (typeof handler === 'function') {
+          middleware.push(handler as T);
+        } else {
+          console.warn(`Middleware at ${path} does not export a function`);
+        }
+      } catch (error) {
+        console.error(`Failed to load middleware from ${path}:`, error);
+      }
+    }
+
+    return middleware;
+  }
+
+  async loadAuthHandler(): Promise<ProtectedHandler<TTypes> | null> {
+    // Direct function provided
+    if (this.config?.auth) {
+      console.log('Using direct auth handler function');
+      return this.config.auth;
+    }
+
+    // File path provided (legacy)
+    if (!this.config?.handlers?.auth) {
+      return null;
+    }
+
+    try {
+      const modulePath = resolve(process.cwd(), this.config.handlers.auth);
+      const importPath = toFileUrl(modulePath);
+      const module = await import(importPath);
+      const handler = module.default || module;
+
+      if (typeof handler === 'function') {
+        return handler as ProtectedHandler<TTypes>;
+      } else {
+        console.warn(`Auth handler at ${this.config.handlers.auth} does not export a function`);
+        return null;
+      }
+    } catch (error) {
+      console.error(`Failed to load auth handler from ${this.config.handlers.auth}:`, error);
+      return null;
+    }
+  }
+
+  async loadCacheHandler(): Promise<CacheHandler | null> {
+    // Direct function provided
+    if (this.config?.cache) {
+      console.log('Using direct cache handler function');
+      return this.config.cache;
+    }
+
+    // File path provided (legacy)
+    if (!this.config?.handlers?.cache) {
+      return null;
+    }
+
+    try {
+      const modulePath = resolve(process.cwd(), this.config.handlers.cache);
+      const importPath = toFileUrl(modulePath);
+      const module = await import(importPath);
+      const handler = module.default || module;
+
+      if (typeof handler === 'function') {
+        return handler as CacheHandler;
+      } else {
+        console.warn(`Cache handler at ${this.config.handlers.cache} does not export a function`);
+        return null;
+      }
+    } catch (error) {
+      console.error(`Failed to load cache handler from ${this.config.handlers.cache}:`, error);
+      return null;
+    }
+  }
+
+  getConfig(): VectorConfigSchema<TTypes> | null {
+    return this.config;
+  }
+}

package/src/core/router.ts

@@ -256,4 +256,8 @@ export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
 
     return APIError.notFound('Route not found');
   }
+
+  clearRoutes(): void {
+    this.routes = [];
+  }
 }

package/src/core/vector.ts

@@ -5,9 +5,8 @@ import { CacheManager } from '../cache/manager';
 import { RouteGenerator } from '../dev/route-generator';
 import { RouteScanner } from '../dev/route-scanner';
 import { MiddlewareManager } from '../middleware/manager';
+import { toFileUrl } from '../utils/path';
 import type {
-  AfterMiddlewareHandler,
-  BeforeMiddlewareHandler,
   CacheHandler,
   DefaultVectorTypes,
   ProtectedHandler,
@@ -19,6 +18,7 @@ import type {
 import { VectorRouter } from './router';
 import { VectorServer } from './server';
 
+// Internal-only class - not exposed to users
 export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   private static instance: Vector<any>;
   private router: VectorRouter<TTypes>;
@@ -43,6 +43,7 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     );
   }
 
+  // Internal use only - not exposed to users
   static getInstance<T extends VectorTypes = DefaultVectorTypes>(): Vector<T> {
     if (!Vector.instance) {
       Vector.instance = new Vector<T>();
@@ -50,46 +51,38 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     return Vector.instance as Vector<T>;
   }
 
-  set protected(handler: ProtectedHandler<TTypes>) {
+  // Internal method to set protected handler
+  setProtectedHandler(handler: ProtectedHandler<TTypes>) {
     this._protectedHandler = handler;
     this.authManager.setProtectedHandler(handler);
   }
 
-  get protected(): ProtectedHandler<TTypes> | null {
+  getProtectedHandler(): ProtectedHandler<TTypes> | null {
     return this._protectedHandler;
   }
 
-  set cache(handler: CacheHandler) {
+  // Internal method to set cache handler
+  setCacheHandler(handler: CacheHandler) {
     this._cacheHandler = handler;
     this.cacheManager.setCacheHandler(handler);
   }
 
-  get cache(): CacheHandler | null {
+  getCacheHandler(): CacheHandler | null {
     return this._cacheHandler;
   }
 
-  route(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>): RouteEntry {
+  // Internal method to add route
+  addRoute(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>): RouteEntry {
     return this.router.route(options, handler);
   }
 
-  use(...middleware: BeforeMiddlewareHandler<TTypes>[]): this {
-    this.middlewareManager.addBefore(...middleware);
-    return this;
-  }
-
-  before(...middleware: BeforeMiddlewareHandler<TTypes>[]): this {
-    this.middlewareManager.addBefore(...middleware);
-    return this;
-  }
-
-  finally(...middleware: AfterMiddlewareHandler<TTypes>[]): this {
-    this.middlewareManager.addFinally(...middleware);
-    return this;
-  }
-
-  async serve(config?: VectorConfig<TTypes>): Promise<Server> {
+  // Internal method to start server - only called by CLI
+  async startServer(config?: VectorConfig<TTypes>): Promise<Server> {
     this.config = { ...this.config, ...config };
 
+    // Clear previous middleware to avoid accumulation across multiple starts
+    this.middlewareManager.clear();
+
     if (config?.before) {
       this.middlewareManager.addBefore(...config.before);
     }
@@ -129,17 +122,19 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
 
         for (const route of routes) {
           try {
-            // Convert Windows paths to URLs for import
-            const importPath =
-              process.platform === 'win32'
-                ? `file:///${route.path.replace(/\\/g, '/')}`
-                : route.path;
+            const importPath = toFileUrl(route.path);
 
             const module = await import(importPath);
             const exported = route.name === 'default' ? module.default : module[route.name];
 
             if (exported) {
-              if (this.isRouteEntry(exported)) {
+              if (this.isRouteDefinition(exported)) {
+                // Use router.route() to ensure middleware is applied
+                const routeDef = exported as any;
+                this.router.route(routeDef.options, routeDef.handler);
+                this.logRouteLoaded(routeDef.options);
+              } else if (this.isRouteEntry(exported)) {
+                // Legacy support for direct RouteEntry (won't have middleware)
                 this.router.addRoute(exported as RouteEntry);
                 this.logRouteLoaded(exported as RouteEntry);
               } else if (typeof exported === 'function') {
@@ -185,6 +180,10 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
     return Array.isArray(value) && value.length >= 3;
   }
 
+  private isRouteDefinition(value: any): boolean {
+    return value && typeof value === 'object' && 'entry' in value && 'options' in value && 'handler' in value;
+  }
+
   private logRouteLoaded(route: RouteEntry | RouteOptions): void {
     if (Array.isArray(route)) {
       console.log(`  ✓ Loaded route: ${route[0]} ${route[3] || route[1]}`);
@@ -198,6 +197,9 @@ 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();
   }
 
   getServer(): VectorServer<TTypes> | null {
@@ -215,8 +217,12 @@ export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
   getAuthManager(): AuthManager<TTypes> {
     return this.authManager;
   }
-}
 
-const vector = Vector.getInstance();
+  // Reset instance for testing purposes only
+  static resetInstance(): void {
+    Vector.instance = null as any;
+  }
+}
 
-export default vector;
+// Export for internal use only
+export const getVectorInstance = Vector.getInstance;

package/src/dev/route-scanner.ts

@@ -64,7 +64,18 @@ export class RouteScanner {
           for (const [name, value] of Object.entries(module)) {
             if (name === 'default') continue;
 
-            if (Array.isArray(value) && value.length >= 4) {
+            // Check for new RouteDefinition format
+            if (value && typeof value === 'object' && 'entry' in value && 'options' in value && 'handler' in value) {
+              const routeDef = value as any;
+              routes.push({
+                name,
+                path: fullPath,
+                method: routeDef.options.method as string,
+                options: routeDef.options,
+              });
+            }
+            // Legacy RouteEntry format support
+            else if (Array.isArray(value) && value.length >= 4) {
               const [method, , , path] = value;
               routes.push({
                 name,

package/src/http.ts

@@ -33,13 +33,19 @@ interface ExtendedApiOptions extends ApiOptions {
   path: string;
 }
 
+export interface RouteDefinition<TTypes extends VectorTypes = DefaultVectorTypes> {
+  entry: RouteEntry;
+  options: ExtendedApiOptions;
+  handler: (req: VectorRequest<TTypes>) => Promise<unknown>;
+}
+
 export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
   options: ExtendedApiOptions,
   fn: (req: VectorRequest<TTypes>) => Promise<unknown>
-): RouteEntry {
+): RouteDefinition<TTypes> {
   const handler = api(options, fn);
 
-  return [
+  const entry: RouteEntry = [
     options.method.toUpperCase(),
     RegExp(
       `^${
@@ -54,6 +60,12 @@ export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
     [handler],
     options.path,
   ];
+
+  return {
+    entry,
+    options,
+    handler: fn
+  };
 }
 
 function stringifyData(data: unknown): string {
@@ -251,9 +263,11 @@ export const protectedRoute = async <
   responseContentType?: string
 ) => {
   // Get the Vector instance to access the protected handler
-  const vector = (await import("./core/vector")).default;
+  const { getVectorInstance } = await import("./core/vector");
+  const vector = getVectorInstance();
 
-  if (!vector.protected) {
+  const protectedHandler = vector.getProtectedHandler();
+  if (!protectedHandler) {
     throw APIError.unauthorized(
       "Authentication not configured",
       responseContentType
@@ -261,7 +275,7 @@ export const protectedRoute = async <
   }
 
   try {
-    const authUser = await vector.protected(request as any);
+    const authUser = await protectedHandler(request as any);
     request.authUser = authUser as GetAuthType<TTypes>;
   } catch (error) {
     throw APIError.unauthorized(
@@ -292,6 +306,8 @@ export function api<TTypes extends VectorTypes = DefaultVectorTypes>(
     responseContentType = CONTENT_TYPES.JSON,
   } = options;
 
+  // For backward compatibility with direct route usage (not auto-discovered)
+  // This wrapper is only used when routes are NOT auto-discovered
   return async (request: IRequest) => {
     if (!expose) {
       return APIError.forbidden("Forbidden");

package/src/index.ts

@@ -1,19 +1,14 @@
-import { Vector } from './core/vector';
-import { route } from './http';
-import type { DefaultVectorTypes, VectorTypes } from './types';
+// Public exports for route definitions only
+import { route } from "./http";
 
-export { route, Vector };
-export { AuthManager } from './auth/protected';
-export { CacheManager } from './cache/manager';
-export { APIError, createResponse } from './http';
-export { MiddlewareManager } from './middleware/manager';
-export * from './types';
+// Export route function for defining routes
+export { route };
 
-// Create a typed Vector instance with custom types
-export function createVector<TTypes extends VectorTypes = DefaultVectorTypes>(): Vector<TTypes> {
-  return Vector.getInstance<TTypes>();
-}
+// Export utilities for route handlers
+export { APIError, createResponse } from "./http";
 
-// Default vector instance with default AuthUser type
-const vector = Vector.getInstance();
-export default vector;
+// Export types for TypeScript users
+export * from "./types";
+
+// Note: Vector framework is now config-driven and runs via CLI
+// Usage: Create vector.config.ts and run 'vector dev' or 'vector start'

package/src/middleware/manager.ts

@@ -4,9 +4,11 @@ import type {
   DefaultVectorTypes,
   VectorRequest,
   VectorTypes,
-} from '../types';
+} from "../types";
 
-export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes> {
+export class MiddlewareManager<
+  TTypes extends VectorTypes = DefaultVectorTypes
+> {
   private beforeHandlers: BeforeMiddlewareHandler<TTypes>[] = [];
   private finallyHandlers: AfterMiddlewareHandler<TTypes>[] = [];
 
@@ -18,7 +20,9 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
     this.finallyHandlers.push(...handlers);
   }
 
-  async executeBefore(request: VectorRequest<TTypes>): Promise<VectorRequest<TTypes> | Response> {
+  async executeBefore(
+    request: VectorRequest<TTypes>
+  ): Promise<VectorRequest<TTypes> | Response> {
     let currentRequest = request;
 
     for (const handler of this.beforeHandlers) {
@@ -34,7 +38,10 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
     return currentRequest;
   }
 
-  async executeFinally(response: Response, request: VectorRequest<TTypes>): Promise<Response> {
+  async executeFinally(
+    response: Response,
+    request: VectorRequest<TTypes>
+  ): Promise<Response> {
     let currentResponse = response;
 
     for (const handler of this.finallyHandlers) {
@@ -50,4 +57,9 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
     manager.finallyHandlers = [...this.finallyHandlers];
     return manager;
   }
+
+  clear(): void {
+    this.beforeHandlers = [];
+    this.finallyHandlers = [];
+  }
 }

package/src/types/index.ts

@@ -72,6 +72,7 @@ export interface RouteOptions<TTypes extends VectorTypes = DefaultVectorTypes> {
   metadata?: GetMetadataType<TTypes>;
 }
 
+// Legacy config interface - will be deprecated
 export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   port?: number;
   hostname?: string;
@@ -84,6 +85,49 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   autoDiscover?: boolean;
 }
 
+// New config-driven schema
+export interface VectorConfigSchema<TTypes extends VectorTypes = DefaultVectorTypes> {
+  // Server configuration
+  server?: {
+    port?: number;
+    hostname?: string;
+    reusePort?: boolean;
+    development?: boolean;
+  };
+  
+  // Routes configuration
+  routes?: {
+    dir?: string;
+    autoDiscover?: boolean;
+  };
+  
+  // Middleware configuration - supports both file paths and direct functions
+  middleware?: {
+    before?: string[];
+    after?: string[];
+  };
+  
+  // Direct middleware functions (preferred approach)
+  before?: BeforeMiddlewareHandler<TTypes>[];
+  after?: AfterMiddlewareHandler<TTypes>[];
+  
+  // Handler configuration - supports both file paths and direct functions
+  handlers?: {
+    auth?: string;
+    cache?: string;
+  };
+  
+  // Direct handler functions (preferred approach)
+  auth?: ProtectedHandler<TTypes>;
+  cache?: CacheHandler;
+  
+  // CORS configuration
+  cors?: CorsOptions | boolean;
+  
+  // Custom types for TypeScript
+  types?: VectorTypes;
+}
+
 export interface CorsOptions {
   origin?: string | string[] | ((origin: string) => boolean);
   credentials?: boolean;

package/src/utils/path.ts

@@ -0,0 +1,9 @@
+export function toFileUrl(path: string): string {
+  return process.platform === 'win32'
+    ? `file:///${path.replace(/\\/g, '/')}`
+    : path;
+}
+
+export function normalizePath(path: string): string {
+  return path.replace(/\\/g, '/').replace(/\/+/g, '/');
+}