bxo 0.0.5-dev.6 → 0.0.5-dev.60

package/src/core/bxo.ts

@@ -0,0 +1,438 @@
+import type { 
+  Route, 
+  WSRoute, 
+  Handler, 
+  WebSocketHandler, 
+  RouteConfig, 
+  LifecycleHooks, 
+  Plugin, 
+  BXOOptions 
+} from '../types';
+import { RequestHandler } from '../handlers/request-handler';
+
+export default class BXO {
+  private _routes: Route[] = [];
+  private _wsRoutes: WSRoute[] = [];
+  private plugins: BXO[] = [];
+  private middleware: Plugin[] = [];
+  private hooks: LifecycleHooks = {};
+  private server?: any;
+  private isRunning: boolean = false;
+  private serverPort?: number;
+  private serverHostname?: string;
+  private enableValidation: boolean = true;
+  private requestHandler: RequestHandler;
+
+  constructor(options?: BXOOptions) {
+    this.enableValidation = options?.enableValidation ?? true;
+    this.requestHandler = new RequestHandler(
+      this._routes,
+      this._wsRoutes,
+      this.plugins,
+      this.middleware,
+      this.hooks,
+      this.enableValidation
+    );
+  }
+
+  // Lifecycle hook methods
+  onBeforeStart(handler: (instance: BXO) => Promise<void> | void): this {
+    this.hooks.onBeforeStart = handler;
+    return this;
+  }
+
+  onAfterStart(handler: (instance: BXO) => Promise<void> | void): this {
+    this.hooks.onAfterStart = handler;
+    return this;
+  }
+
+  onBeforeStop(handler: (instance: BXO) => Promise<void> | void): this {
+    this.hooks.onBeforeStop = handler;
+    return this;
+  }
+
+  onAfterStop(handler: (instance: BXO) => Promise<void> | void): this {
+    this.hooks.onAfterStop = handler;
+    return this;
+  }
+
+  onRequest(handler: (ctx: any, instance: BXO) => Promise<void> | void): this {
+    this.hooks.onRequest = handler;
+    return this;
+  }
+
+  onResponse(handler: (ctx: any, response: any, instance: BXO) => Promise<any> | any): this {
+    this.hooks.onResponse = handler;
+    return this;
+  }
+
+  onError(handler: (ctx: any, error: Error, instance: BXO) => Promise<any> | any): this {
+    this.hooks.onError = handler;
+    return this;
+  }
+
+  // Plugin system - now accepts both BXO instances and middleware plugins
+  use(plugin: BXO | Plugin): this {
+    if ('_routes' in plugin) {
+      // It's a BXO instance
+      this.plugins.push(plugin);
+    } else {
+      // It's a middleware plugin
+      this.middleware.push(plugin);
+    }
+    this.updateRequestHandler();
+    return this;
+  }
+
+  // HTTP method handlers with overloads for type safety
+  get<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>
+  ): this;
+  get<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config: TConfig
+  ): this;
+  get<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config?: TConfig
+  ): this {
+    this._routes.push({ method: 'GET', path, handler, config });
+    this.updateRequestHandler();
+    return this;
+  }
+
+  post<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>
+  ): this;
+  post<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config: TConfig
+  ): this;
+  post<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config?: TConfig
+  ): this {
+    this._routes.push({ method: 'POST', path, handler, config });
+    this.updateRequestHandler();
+    return this;
+  }
+
+  put<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>
+  ): this;
+  put<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config: TConfig
+  ): this;
+  put<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config?: TConfig
+  ): this {
+    this._routes.push({ method: 'PUT', path, handler, config });
+    this.updateRequestHandler();
+    return this;
+  }
+
+  delete<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>
+  ): this;
+  delete<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config: TConfig
+  ): this;
+  delete<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config?: TConfig
+  ): this {
+    this._routes.push({ method: 'DELETE', path, handler, config });
+    this.updateRequestHandler();
+    return this;
+  }
+
+  patch<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>
+  ): this;
+  patch<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config: TConfig
+  ): this;
+  patch<TConfig extends RouteConfig = {}>(
+    path: string,
+    handler: Handler<TConfig>,
+    config?: TConfig
+  ): this {
+    this._routes.push({ method: 'PATCH', path, handler, config });
+    this.updateRequestHandler();
+    return this;
+  }
+
+  // WebSocket route handler
+  ws(path: string, handler: WebSocketHandler): this {
+    this._wsRoutes.push({ path, handler });
+    this.updateRequestHandler();
+    return this;
+  }
+
+  // Update the request handler with current routes and configuration
+  private updateRequestHandler(): void {
+    this.requestHandler = new RequestHandler(
+      this.getAllRoutes(),
+      this.getAllWSRoutes(),
+      this.plugins,
+      this.middleware,
+      this.hooks,
+      this.enableValidation
+    );
+  }
+
+  // Helper methods to get all routes including plugin routes
+  private getAllRoutes(): Route[] {
+    const allRoutes = [...this._routes];
+    for (const plugin of this.plugins) {
+      allRoutes.push(...plugin._routes);
+    }
+    return allRoutes;
+  }
+
+  private getAllWSRoutes(): WSRoute[] {
+    const allWSRoutes = [...this._wsRoutes];
+    for (const plugin of this.plugins) {
+      allWSRoutes.push(...plugin._wsRoutes);
+    }
+    return allWSRoutes;
+  }
+
+  // Server management methods
+  async start(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
+    if (this.isRunning) {
+      return;
+    }
+
+    try {
+      // Before start hook
+      if (this.hooks.onBeforeStart) {
+        await this.hooks.onBeforeStart(this);
+      }
+
+      this.server = Bun.serve({
+        port,
+        hostname,
+        fetch: (request, server) => this.requestHandler.handleRequest(request, server),
+        websocket: {
+          message: (ws: any, message: any) => {
+            const handler = ws.data?.handler;
+            if (handler?.onMessage) {
+              handler.onMessage(ws, message);
+            }
+          },
+          open: (ws: any) => {
+            const handler = ws.data?.handler;
+            if (handler?.onOpen) {
+              handler.onOpen(ws);
+            }
+          },
+          close: (ws: any, code?: number, reason?: string) => {
+            const handler = ws.data?.handler;
+            if (handler?.onClose) {
+              handler.onClose(ws, code, reason);
+            }
+          }
+        }
+      });
+
+      // Verify server was created successfully
+      if (!this.server) {
+        throw new Error('Failed to create server instance');
+      }
+
+      this.isRunning = true;
+      this.serverPort = port;
+      this.serverHostname = hostname;
+
+      // After start hook
+      if (this.hooks.onAfterStart) {
+        await this.hooks.onAfterStart(this);
+      }
+
+      // Handle graceful shutdown
+      const shutdownHandler = async () => {
+        await this.stop();
+        process.exit(0);
+      };
+
+      process.on('SIGINT', shutdownHandler);
+      process.on('SIGTERM', shutdownHandler);
+
+    } catch (error) {
+      console.error('❌ Failed to start server:', error);
+      throw error;
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isRunning) {
+      return;
+    }
+
+    try {
+      // Before stop hook
+      if (this.hooks.onBeforeStop) {
+        await this.hooks.onBeforeStop(this);
+      }
+
+      if (this.server) {
+        try {
+          // Try to stop the server gracefully
+          if (typeof this.server.stop === 'function') {
+            this.server.stop();
+          } else {
+            console.warn('⚠️  Server stop method not available');
+          }
+        } catch (stopError) {
+          console.error('❌ Error calling server.stop():', stopError);
+        }
+
+        // Clear the server reference
+        this.server = undefined;
+      }
+
+      // Reset state regardless of server.stop() success
+      this.isRunning = false;
+      this.serverPort = undefined;
+      this.serverHostname = undefined;
+
+      // After stop hook
+      if (this.hooks.onAfterStop) {
+        await this.hooks.onAfterStop(this);
+      }
+
+    } catch (error) {
+      console.error('❌ Error stopping server:', error);
+      // Even if there's an error, reset the state
+      this.isRunning = false;
+      this.server = undefined;
+      this.serverPort = undefined;
+      this.serverHostname = undefined;
+      throw error;
+    }
+  }
+
+  // Backward compatibility
+  async listen(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
+    return this.start(port, hostname);
+  }
+
+  // Server status
+  isServerRunning(): boolean {
+    return this.isRunning && this.server !== undefined;
+  }
+
+  getServerInfo(): { running: boolean } {
+    return {
+      running: this.isRunning
+    };
+  }
+
+  // Get server information (alias for getServerInfo)
+  get info() {
+    // Calculate total routes including plugins
+    const totalRoutes = this._routes.length + this.plugins.reduce((total, plugin) => total + plugin._routes.length, 0);
+    const totalWsRoutes = this._wsRoutes.length + this.plugins.reduce((total, plugin) => total + plugin._wsRoutes.length, 0);
+
+    return {
+      // Server status
+      running: this.isRunning,
+      server: this.server ? 'Bun' : null,
+
+      // Connection details
+      hostname: this.serverHostname,
+      port: this.serverPort,
+      url: this.isRunning && this.serverHostname && this.serverPort
+        ? `http://${this.serverHostname}:${this.serverPort}`
+        : null,
+
+      // Application statistics
+      totalRoutes,
+      totalWsRoutes,
+      totalPlugins: this.plugins.length,
+
+      // System information
+      runtime: 'Bun',
+      version: typeof Bun !== 'undefined' ? Bun.version : 'unknown',
+      pid: process.pid,
+      uptime: this.isRunning ? process.uptime() : 0
+    };
+  }
+
+  // Get all routes information
+  get routes() {
+    // Get routes from main instance
+    const mainRoutes = this._routes.map((route: Route) => ({
+      method: route.method,
+      path: route.path,
+      hasConfig: !!route.config,
+      config: route.config || null,
+      source: 'main' as const
+    }));
+
+    // Get routes from all plugins
+    const pluginRoutes = this.plugins.flatMap((plugin, pluginIndex) =>
+      plugin._routes.map((route: Route) => ({
+        method: route.method,
+        path: route.path,
+        hasConfig: !!route.config,
+        config: route.config || null,
+        source: 'plugin' as const,
+        pluginIndex
+      }))
+    );
+
+    return [...mainRoutes, ...pluginRoutes];
+  }
+
+  // Get all WebSocket routes information
+  get wsRoutes() {
+    // Get WebSocket routes from main instance
+    const mainWsRoutes = this._wsRoutes.map((route: WSRoute) => ({
+      path: route.path,
+      hasHandlers: {
+        onOpen: !!route.handler.onOpen,
+        onMessage: !!route.handler.onMessage,
+        onClose: !!route.handler.onClose,
+        onError: !!route.handler.onError
+      },
+      source: 'main' as const
+    }));
+
+    // Get WebSocket routes from all plugins
+    const pluginWsRoutes = this.plugins.flatMap((plugin, pluginIndex) =>
+      plugin._wsRoutes.map((route: WSRoute) => ({
+        path: route.path,
+        hasHandlers: {
+          onOpen: !!route.handler.onOpen,
+          onMessage: !!route.handler.onMessage,
+          onClose: !!route.handler.onClose,
+          onError: !!route.handler.onError
+        },
+        source: 'plugin' as const,
+        pluginIndex
+      }))
+    );
+
+    return [...mainWsRoutes, ...pluginWsRoutes];
+  }
+}

package/src/handlers/request-handler.ts

@@ -0,0 +1,229 @@
+import type { Context, Route, WSRoute, Plugin, LifecycleHooks } from '../types';
+import { parseQuery, parseHeaders, parseCookies, parseRequestBody } from '../utils';
+import { matchRoute, matchWSRoute } from '../utils/route-matcher';
+import { createContext, createOptionsContext, getInternalCookies } from '../utils/context-factory';
+import { processResponse, createValidationErrorResponse, createErrorResponse } from '../utils/response-handler';
+
+export class RequestHandler {
+  constructor(
+    private routes: Route[],
+    private wsRoutes: WSRoute[],
+    private plugins: any[],
+    private middleware: Plugin[],
+    private hooks: LifecycleHooks,
+    private enableValidation: boolean
+  ) { }
+
+  async handleRequest(request: Request, server?: any): Promise<Response | undefined> {
+    const url = new URL(request.url);
+    const method = request.method;
+    const rawPathname = url.pathname;
+    let pathname: string;
+
+    try {
+      pathname = decodeURI(rawPathname);
+    } catch {
+      pathname = rawPathname;
+    }
+
+    // Check for WebSocket upgrade
+    if (request.headers.get('upgrade') === 'websocket') {
+      return this.handleWebSocketUpgrade(request, pathname, server);
+    }
+
+    // Handle OPTIONS requests for CORS preflight before route matching
+    if (method === 'OPTIONS') {
+      return this.handleOptionsRequest(request, pathname);
+    }
+
+    // Find matching route
+    const matchResult = matchRoute(method, pathname, this.routes);
+    if (!matchResult) {
+      return new Response('Not Found', { status: 404 });
+    }
+
+    const { route, params } = matchResult;
+    let ctx: Context | null = null
+
+    try {
+      // Parse request data
+      const query = parseQuery(url.searchParams);
+      const headers = parseHeaders(request.headers);
+      const cookies = parseCookies(request.headers.get('cookie'));
+      const body = await parseRequestBody(request);
+
+      // Create context
+      ctx = createContext(
+        params,
+        query,
+        body,
+        headers,
+        cookies,
+        pathname,
+        request,
+        route.config,
+        this.enableValidation
+      );
+
+      // Run middleware and hooks
+      await this.runRequestHooks(ctx);
+
+      // Execute route handler
+      let response = await route.handler(ctx);
+
+      // Run response hooks
+      response = await this.runResponseHooks(ctx, response);
+
+      // Process and return response
+      const internalCookies = getInternalCookies(ctx);
+      return processResponse(response, ctx, internalCookies, this.enableValidation, route.config);
+
+    } catch (error) {
+      // Run error hooks
+      const errorResponse = await this.runErrorHooks(ctx as Context, error as Error);
+      if (errorResponse) {
+        return errorResponse;
+      }
+
+      // Default error response
+      if (error instanceof Error && ('errors' in error || 'issues' in error)) {
+        return createValidationErrorResponse(error, 400);
+      }
+
+      return createErrorResponse(error as Error);
+    }
+  }
+
+  private handleWebSocketUpgrade(request: Request, pathname: string, server?: any): Response | undefined {
+    const wsMatchResult = matchWSRoute(pathname, this.wsRoutes);
+    if (wsMatchResult && server) {
+      const success = server.upgrade(request, {
+        data: {
+          handler: wsMatchResult.route.handler,
+          params: wsMatchResult.params,
+          pathname
+        }
+      });
+
+      if (success) {
+        return; // undefined response means upgrade was successful
+      }
+    }
+    return new Response('WebSocket upgrade failed', { status: 400 });
+  }
+
+  private async handleOptionsRequest(request: Request, pathname: string): Promise<Response> {
+    const headers = parseHeaders(request.headers);
+    const ctx = createOptionsContext(pathname, request, headers);
+
+    // Run middleware onRequest hooks for OPTIONS requests
+    for (const plugin of this.middleware) {
+      if (plugin.onRequest) {
+        const result = await plugin.onRequest(ctx);
+        if (result instanceof Response) {
+          return result;
+        }
+      }
+    }
+
+    // Run global onRequest hook
+    if (this.hooks.onRequest) {
+      const result = await this.hooks.onRequest(ctx, this) as any
+      if (result instanceof Response) {
+        return result;
+      }
+    }
+
+    // Run BXO instance onRequest hooks
+    for (const bxoInstance of this.plugins) {
+      if (bxoInstance.hooks?.onRequest) {
+        const result = await bxoInstance.hooks.onRequest(ctx, this);
+        if (result instanceof Response) {
+          return result;
+        }
+      }
+    }
+
+    // If no middleware handled the OPTIONS request, return a default response
+    return new Response(null, {
+      status: 204,
+      headers: ctx.set.headers || {}
+    });
+  }
+
+  private async runRequestHooks(ctx: Context): Promise<void> {
+    // Run middleware onRequest hooks
+    for (const plugin of this.middleware) {
+      if (plugin.onRequest) {
+        await plugin.onRequest(ctx);
+      }
+    }
+
+    // Run global onRequest hook
+    if (this.hooks.onRequest) {
+      await this.hooks.onRequest(ctx, this);
+    }
+
+    // Run BXO instance onRequest hooks
+    for (const bxoInstance of this.plugins) {
+      if (bxoInstance.hooks?.onRequest) {
+        await bxoInstance.hooks.onRequest(ctx, this);
+      }
+    }
+  }
+
+  private async runResponseHooks(ctx: Context, response: any): Promise<any> {
+    // Run middleware onResponse hooks
+    for (const plugin of this.middleware) {
+      if (plugin.onResponse) {
+        response = await plugin.onResponse(ctx, response) || response;
+      }
+    }
+
+    // Run global onResponse hook
+    if (this.hooks.onResponse) {
+      response = await this.hooks.onResponse(ctx, response, this) || response;
+    }
+
+    // Run BXO instance onResponse hooks
+    for (const bxoInstance of this.plugins) {
+      if (bxoInstance.hooks?.onResponse) {
+        response = await bxoInstance.hooks.onResponse(ctx, response, this) || response;
+      }
+    }
+
+    return response;
+  }
+
+  private async runErrorHooks(ctx: Context, error: Error): Promise<Response | null> {
+    let errorResponse: any = null;
+
+    // Run middleware onError hooks
+    for (const plugin of this.middleware) {
+      if (plugin.onError) {
+        errorResponse = await plugin.onError(ctx, error) || errorResponse;
+      }
+    }
+
+    // Run global onError hook
+    if (this.hooks.onError) {
+      errorResponse = await this.hooks.onError(ctx, error, this);
+    }
+
+    // Run BXO instance onError hooks
+    for (const bxoInstance of this.plugins) {
+      if (bxoInstance.hooks?.onError) {
+        errorResponse = await bxoInstance.hooks.onError(ctx, error, this) || errorResponse;
+      }
+    }
+
+    if (errorResponse) {
+      if (errorResponse instanceof Response) {
+        return errorResponse;
+      }
+      return createErrorResponse(errorResponse, 500);
+    }
+
+    return null;
+  }
+}