vector-framework 0.8.1

package/src/core/router.ts

@@ -0,0 +1,258 @@
+import type { RouteEntry } from 'itty-router';
+import type { AuthManager } from '../auth/protected';
+import type { CacheManager } from '../cache/manager';
+import { APIError, createResponse } from '../http';
+import type { MiddlewareManager } from '../middleware/manager';
+import type {
+  DefaultVectorTypes,
+  RouteHandler,
+  RouteOptions,
+  VectorRequest,
+  VectorTypes,
+} from '../types';
+
+export class VectorRouter<TTypes extends VectorTypes = DefaultVectorTypes> {
+  private middlewareManager: MiddlewareManager<TTypes>;
+  private authManager: AuthManager<TTypes>;
+  private cacheManager: CacheManager<TTypes>;
+  private routes: RouteEntry[] = [];
+
+  constructor(
+    middlewareManager: MiddlewareManager<TTypes>,
+    authManager: AuthManager<TTypes>,
+    cacheManager: CacheManager<TTypes>
+  ) {
+    this.middlewareManager = middlewareManager;
+    this.authManager = authManager;
+    this.cacheManager = cacheManager;
+  }
+
+  private getRouteSpecificity(path: string): number {
+    const STATIC_SEGMENT_WEIGHT = 1000;
+    const PARAM_SEGMENT_WEIGHT = 10;
+    const WILDCARD_WEIGHT = 1;
+    const EXACT_MATCH_BONUS = 10000;
+
+    let score = 0;
+    const segments = path.split('/').filter(Boolean);
+
+    for (const segment of segments) {
+      if (this.isStaticSegment(segment)) {
+        score += STATIC_SEGMENT_WEIGHT;
+      } else if (this.isParamSegment(segment)) {
+        score += PARAM_SEGMENT_WEIGHT;
+      } else if (this.isWildcardSegment(segment)) {
+        score += WILDCARD_WEIGHT;
+      }
+    }
+
+    score += path.length;
+
+    if (this.isExactPath(path)) {
+      score += EXACT_MATCH_BONUS;
+    }
+
+    return score;
+  }
+
+  private isStaticSegment(segment: string): boolean {
+    return !segment.startsWith(':') && !segment.includes('*');
+  }
+
+  private isParamSegment(segment: string): boolean {
+    return segment.startsWith(':');
+  }
+
+  private isWildcardSegment(segment: string): boolean {
+    return segment.includes('*');
+  }
+
+  private isExactPath(path: string): boolean {
+    return !path.includes(':') && !path.includes('*');
+  }
+
+  sortRoutes(): void {
+    this.routes.sort((a, b) => {
+      const pathA = this.extractPath(a);
+      const pathB = this.extractPath(b);
+
+      const scoreA = this.getRouteSpecificity(pathA);
+      const scoreB = this.getRouteSpecificity(pathB);
+
+      return scoreB - scoreA;
+    });
+  }
+
+  private extractPath(route: RouteEntry): string {
+    const PATH_INDEX = 3;
+    return route[PATH_INDEX] || '';
+  }
+
+  route(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>): RouteEntry {
+    const wrappedHandler = this.wrapHandler(options, handler);
+    const routeEntry: RouteEntry = [
+      options.method.toUpperCase(),
+      this.createRouteRegex(options.path),
+      [wrappedHandler],
+      options.path,
+    ];
+
+    this.routes.push(routeEntry);
+    this.sortRoutes(); // Sort routes after adding
+    return routeEntry;
+  }
+
+  private createRouteRegex(path: string): RegExp {
+    return RegExp(
+      `^${path
+        .replace(/\/+(\/|$)/g, '$1')
+        .replace(/(\/?\.?):(\w+)\+/g, '($1(?<$2>*))')
+        .replace(/(\/?\.?):(\w+)/g, '($1(?<$2>[^$1/]+?))')
+        .replace(/\./g, '\\.')
+        .replace(/(\/?)\*/g, '($1.*)?')}/*$`
+    );
+  }
+
+  private wrapHandler(options: RouteOptions<TTypes>, handler: RouteHandler<TTypes>) {
+    return async (request: any) => {
+      // Ensure request has required properties
+      const vectorRequest = request as VectorRequest<TTypes>;
+
+      // Initialize context if not present
+      if (!vectorRequest.context) {
+        vectorRequest.context = {} as any;
+      }
+
+      // Parse query parameters from URL (handles duplicate params as arrays)
+      if (!vectorRequest.query && vectorRequest.url) {
+        const url = new URL(vectorRequest.url);
+        const query: Record<string, string | string[]> = {};
+        for (let [k, v] of url.searchParams) {
+          query[k] = query[k] ? ([] as string[]).concat(query[k], v) : v;
+        }
+        vectorRequest.query = query;
+      }
+
+      // Add metadata to request if provided
+      if (options.metadata) {
+        vectorRequest.metadata = options.metadata;
+      }
+
+      request = vectorRequest;
+      try {
+        if (!options.expose) {
+          return APIError.forbidden('Forbidden');
+        }
+
+        const beforeResult = await this.middlewareManager.executeBefore(request);
+        if (beforeResult instanceof Response) {
+          return beforeResult;
+        }
+        request = beforeResult as any;
+
+        if (options.auth) {
+          try {
+            await this.authManager.authenticate(request);
+          } catch (error) {
+            return APIError.unauthorized(
+              error instanceof Error ? error.message : 'Authentication failed',
+              options.responseContentType
+            );
+          }
+        }
+
+        if (!options.rawRequest && request.method !== 'GET' && request.method !== 'HEAD') {
+          try {
+            const contentType = request.headers.get('content-type');
+            if (contentType?.includes('application/json')) {
+              request.content = await request.json();
+            } else if (contentType?.includes('application/x-www-form-urlencoded')) {
+              request.content = Object.fromEntries(await request.formData());
+            } else if (contentType?.includes('multipart/form-data')) {
+              request.content = await request.formData();
+            } else {
+              request.content = await request.text();
+            }
+          } catch {
+            request.content = null;
+          }
+        }
+
+        let result;
+        const cacheOptions = options.cache;
+
+        if (cacheOptions && typeof cacheOptions === 'number' && cacheOptions > 0) {
+          const cacheKey = this.cacheManager.generateKey(request as any, {
+            authUser: request.authUser,
+          });
+          result = await this.cacheManager.get(cacheKey, () => handler(request), cacheOptions);
+        } else if (cacheOptions && typeof cacheOptions === 'object' && cacheOptions.ttl) {
+          const cacheKey =
+            cacheOptions.key ||
+            this.cacheManager.generateKey(request as any, {
+              authUser: request.authUser,
+            });
+          result = await this.cacheManager.get(cacheKey, () => handler(request), cacheOptions.ttl);
+        } else {
+          result = await handler(request);
+        }
+
+        let response: Response;
+        if (options.rawResponse || result instanceof Response) {
+          response = result instanceof Response ? result : new Response(result);
+        } else {
+          response = createResponse(200, result, options.responseContentType);
+        }
+
+        response = await this.middlewareManager.executeFinally(response, request);
+
+        return response;
+      } catch (error) {
+        if (error instanceof Response) {
+          return error;
+        }
+
+        console.error('Route handler error:', error);
+        return APIError.internalServerError(
+          error instanceof Error ? error.message : String(error),
+          options.responseContentType
+        );
+      }
+    };
+  }
+
+  addRoute(routeEntry: RouteEntry) {
+    this.routes.push(routeEntry);
+    this.sortRoutes(); // Sort routes after adding a new one
+  }
+
+  getRoutes(): RouteEntry[] {
+    return this.routes;
+  }
+
+  async handle(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+
+    for (const [method, regex, handlers] of this.routes) {
+      if (request.method === 'OPTIONS' || request.method === method) {
+        const match = pathname.match(regex);
+        if (match) {
+          const req = request as any as VectorRequest<TTypes>;
+          // Initialize context for new request
+          if (!req.context) {
+            req.context = {} as any;
+          }
+          req.params = match.groups || {};
+
+          for (const handler of handlers) {
+            const response = await handler(req as any);
+            if (response) return response;
+          }
+        }
+      }
+    }
+
+    return APIError.notFound('Route not found');
+  }
+}

package/src/core/server.ts

@@ -0,0 +1,107 @@
+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;
+  private router: VectorRouter<TTypes>;
+  private config: VectorConfig<TTypes>;
+  private corsHandler: any;
+
+  constructor(router: VectorRouter<TTypes>, config: VectorConfig<TTypes>) {
+    this.router = router;
+    this.config = config;
+
+    if (config.cors) {
+      const { preflight, corsify } = cors(this.normalizeCorsOptions(config.cors));
+      this.corsHandler = { preflight, corsify };
+    }
+  }
+
+  private normalizeCorsOptions(options: CorsOptions): any {
+    return {
+      origin: options.origin || '*',
+      credentials: options.credentials !== false,
+      allowHeaders: Array.isArray(options.allowHeaders)
+        ? options.allowHeaders.join(', ')
+        : options.allowHeaders || 'Content-Type, Authorization',
+      allowMethods: Array.isArray(options.allowMethods)
+        ? options.allowMethods.join(', ')
+        : options.allowMethods || 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+      exposeHeaders: Array.isArray(options.exposeHeaders)
+        ? 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 fetch = async (request: Request): Promise<Response> => {
+      try {
+        // Handle CORS preflight
+        if (this.corsHandler && request.method === 'OPTIONS') {
+          return this.corsHandler.preflight(request);
+        }
+
+        // Try to handle the request with our router
+        let response = await this.router.handle(request);
+
+        // Apply CORS headers if configured
+        if (this.corsHandler) {
+          response = this.corsHandler.corsify(response, request);
+        }
+
+        return response;
+      } catch (error) {
+        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 });
+      },
+    });
+
+    // Server logs are handled by CLI, keep this minimal
+    console.log(`→ Vector server running at http://${hostname}:${port}`);
+
+    return this.server;
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+      console.log('Server stopped');
+    }
+  }
+
+  getServer(): Server | null {
+    return this.server;
+  }
+
+  getPort(): number {
+    return this.server?.port || this.config.port || 3000;
+  }
+
+  getHostname(): string {
+    return this.server?.hostname || this.config.hostname || 'localhost';
+  }
+
+  getUrl(): string {
+    const port = this.getPort();
+    const hostname = this.getHostname();
+    return `http://${hostname}:${port}`;
+  }
+}

package/src/core/vector.ts

@@ -0,0 +1,228 @@
+import type { Server } from 'bun';
+import type { RouteEntry } from 'itty-router';
+import { AuthManager } from '../auth/protected';
+import { CacheManager } from '../cache/manager';
+import { RouteGenerator } from '../dev/route-generator';
+import { RouteScanner } from '../dev/route-scanner';
+import { MiddlewareManager } from '../middleware/manager';
+import type {
+  AfterMiddlewareHandler,
+  BeforeMiddlewareHandler,
+  CacheHandler,
+  DefaultVectorTypes,
+  ProtectedHandler,
+  RouteHandler,
+  RouteOptions,
+  VectorConfig,
+  VectorTypes,
+} from '../types';
+import { VectorRouter } from './router';
+import { VectorServer } from './server';
+
+export class Vector<TTypes extends VectorTypes = DefaultVectorTypes> {
+  private static instance: Vector<any>;
+  private router: VectorRouter<TTypes>;
+  private server: VectorServer<TTypes> | null = null;
+  private middlewareManager: MiddlewareManager<TTypes>;
+  private authManager: AuthManager<TTypes>;
+  private cacheManager: CacheManager<TTypes>;
+  private config: VectorConfig<TTypes> = {};
+  private routeScanner: RouteScanner | null = null;
+  private routeGenerator: RouteGenerator | null = null;
+  private _protectedHandler: ProtectedHandler<TTypes> | null = null;
+  private _cacheHandler: CacheHandler | null = null;
+
+  private constructor() {
+    this.middlewareManager = new MiddlewareManager<TTypes>();
+    this.authManager = new AuthManager<TTypes>();
+    this.cacheManager = new CacheManager<TTypes>();
+    this.router = new VectorRouter<TTypes>(
+      this.middlewareManager,
+      this.authManager,
+      this.cacheManager
+    );
+  }
+
+  static getInstance<T extends VectorTypes = DefaultVectorTypes>(): Vector<T> {
+    if (!Vector.instance) {
+      Vector.instance = new Vector<T>();
+    }
+    return Vector.instance as Vector<T>;
+  }
+
+  set protected(handler: ProtectedHandler<TTypes>) {
+    this._protectedHandler = handler;
+    this.authManager.setProtectedHandler(handler);
+  }
+
+  get protected(): ProtectedHandler<TTypes> | null {
+    return this._protectedHandler;
+  }
+
+  set cache(handler: CacheHandler) {
+    this._cacheHandler = handler;
+    this.cacheManager.setCacheHandler(handler);
+  }
+
+  get cache(): CacheHandler | null {
+    return this._cacheHandler;
+  }
+
+  route(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> {
+    this.config = { ...this.config, ...config };
+
+    if (config?.before) {
+      this.middlewareManager.addBefore(...config.before);
+    }
+
+    if (config?.finally) {
+      this.middlewareManager.addFinally(...config.finally);
+    }
+
+    if (this.config.autoDiscover !== false) {
+      await this.discoverRoutes();
+    }
+
+    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;
+  }
+
+  private async discoverRoutes() {
+    const routesDir = this.config.routesDir || './routes';
+
+    if (!this.routeScanner) {
+      this.routeScanner = new RouteScanner(routesDir);
+    }
+
+    if (!this.routeGenerator) {
+      this.routeGenerator = new RouteGenerator();
+    }
+
+    try {
+      const routes = await this.routeScanner.scan();
+
+      if (routes.length > 0) {
+        if (this.config.development) {
+          await this.routeGenerator.generate(routes);
+        }
+
+        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 module = await import(importPath);
+            const exported = route.name === 'default' ? module.default : module[route.name];
+
+            if (exported) {
+              if (this.isRouteEntry(exported)) {
+                this.router.addRoute(exported as RouteEntry);
+                this.logRouteLoaded(exported as RouteEntry);
+              } else if (typeof exported === 'function') {
+                this.router.route(route.options as any, exported);
+                this.logRouteLoaded(route.options);
+              }
+            }
+          } catch (error) {
+            console.error(`Failed to load route ${route.name} from ${route.path}:`, error);
+          }
+        }
+
+        // Ensure routes are properly sorted after loading all
+        this.router.sortRoutes();
+        console.log(`✅ Loaded ${routes.length} routes from ${routesDir}`);
+      }
+    } catch (error) {
+      if ((error as any).code !== 'ENOENT') {
+        console.error('Failed to discover routes:', error);
+      }
+    }
+  }
+
+  async loadRoute(routeModule: any) {
+    if (typeof routeModule === 'function') {
+      const routeEntry = routeModule();
+      if (Array.isArray(routeEntry)) {
+        this.router.addRoute(routeEntry as RouteEntry);
+      }
+    } else if (routeModule && typeof routeModule === 'object') {
+      for (const [, value] of Object.entries(routeModule)) {
+        if (typeof value === 'function') {
+          const routeEntry = (value as any)();
+          if (Array.isArray(routeEntry)) {
+            this.router.addRoute(routeEntry as RouteEntry);
+          }
+        }
+      }
+    }
+  }
+
+  private isRouteEntry(value: any): boolean {
+    return Array.isArray(value) && value.length >= 3;
+  }
+
+  private logRouteLoaded(route: RouteEntry | RouteOptions): void {
+    if (Array.isArray(route)) {
+      console.log(`  ✓ Loaded route: ${route[0]} ${route[3] || route[1]}`);
+    } else {
+      console.log(`  ✓ Loaded route: ${route.method} ${route.path}`);
+    }
+  }
+
+  stop(): void {
+    if (this.server) {
+      this.server.stop();
+      this.server = null;
+    }
+  }
+
+  getServer(): VectorServer<TTypes> | null {
+    return this.server;
+  }
+
+  getRouter(): VectorRouter<TTypes> {
+    return this.router;
+  }
+
+  getCacheManager(): CacheManager<TTypes> {
+    return this.cacheManager;
+  }
+
+  getAuthManager(): AuthManager<TTypes> {
+    return this.authManager;
+  }
+}
+
+const vector = Vector.getInstance();
+
+export default vector;

package/src/dev/route-generator.ts

@@ -0,0 +1,93 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, relative } from 'node:path';
+import type { GeneratedRoute } from '../types';
+
+export class RouteGenerator {
+  private outputPath: string;
+
+  constructor(outputPath = './.vector/routes.generated.ts') {
+    this.outputPath = outputPath;
+  }
+
+  async generate(routes: GeneratedRoute[]): Promise<void> {
+    const outputDir = dirname(this.outputPath);
+    await mkdir(outputDir, { recursive: true });
+
+    const imports: string[] = [];
+    const groupedByFile = new Map<string, GeneratedRoute[]>();
+
+    for (const route of routes) {
+      if (!groupedByFile.has(route.path)) {
+        groupedByFile.set(route.path, []);
+      }
+      groupedByFile.get(route.path)!.push(route);
+    }
+
+    let importIndex = 0;
+    const routeEntries: string[] = [];
+
+    for (const [filePath, fileRoutes] of groupedByFile) {
+      const relativePath = relative(dirname(this.outputPath), filePath)
+        .replace(/\\/g, '/')
+        .replace(/\.(ts|js)$/, '');
+
+      const importName = `route_${importIndex++}`;
+      const namedImports = fileRoutes.filter((r) => r.name !== 'default').map((r) => r.name);
+
+      if (fileRoutes.some((r) => r.name === 'default')) {
+        if (namedImports.length > 0) {
+          imports.push(
+            `import ${importName}, { ${namedImports.join(', ')} } from '${relativePath}';`
+          );
+        } else {
+          imports.push(`import ${importName} from '${relativePath}';`);
+        }
+      } else if (namedImports.length > 0) {
+        imports.push(`import { ${namedImports.join(', ')} } from '${relativePath}';`);
+      }
+
+      for (const route of fileRoutes) {
+        const routeVar = route.name === 'default' ? importName : route.name;
+        routeEntries.push(`  ${routeVar},`);
+      }
+    }
+
+    const content = `// This file is auto-generated. Do not edit manually.
+// Generated at: ${new Date().toISOString()}
+
+${imports.join('\n')}
+
+export const routes = [
+${routeEntries.join('\n')}
+];
+
+export default routes;
+`;
+
+    await writeFile(this.outputPath, content, 'utf-8');
+    console.log(`Generated routes file: ${this.outputPath}`);
+  }
+
+  async generateDynamic(routes: GeneratedRoute[]): Promise<string> {
+    const routeEntries: string[] = [];
+
+    for (const route of routes) {
+      const routeObj = JSON.stringify({
+        method: route.method,
+        path: route.options.path,
+        options: route.options,
+      });
+
+      routeEntries.push(`  await import('${route.path}').then(m => ({ 
+        ...${routeObj}, 
+        handler: m.${route.name === 'default' ? 'default' : route.name} 
+      }))`);
+    }
+
+    return `export const loadRoutes = async () => {
+  return Promise.all([
+${routeEntries.join(',\n')}
+  ]);
+};`;
+  }
+}