@onebun/core 0.1.1 → 0.1.3

package/src/{application.ts → application/application.ts}

@@ -1,6 +1,7 @@
 import { Effect, type Layer } from 'effect';
 
-import type { Controller } from './controller';
+import type { Controller } from '../module/controller';
+import type { WsClientData } from '../websocket/ws.types';
 
 import { TypedEnv } from '@onebun/envs';
 import {
@@ -19,18 +20,24 @@ import {
 } from '@onebun/requests';
 import { makeTraceService, TraceService } from '@onebun/trace';
 
-import { ConfigServiceImpl } from './config.service';
-import { getControllerMetadata } from './decorators';
-import { OneBunModule } from './module';
+import { getControllerMetadata } from '../decorators/decorators';
+import { ConfigServiceImpl } from '../module/config.service';
+import { OneBunModule } from '../module/module';
+import { QueueService, type QueueAdapter } from '../queue';
+import { InMemoryQueueAdapter } from '../queue/adapters/memory.adapter';
+import { RedisQueueAdapter } from '../queue/adapters/redis.adapter';
+import { hasQueueDecorators } from '../queue/decorators';
+import { SharedRedisProvider } from '../redis/shared-redis';
 import {
   type ApplicationOptions,
   type HttpMethod,
-  type Module,
+  type ModuleInstance,
   type ParamMetadata,
   ParamType,
   type RouteMetadata,
-} from './types';
-import { validateOrThrow } from './validation';
+} from '../types';
+import { validateOrThrow } from '../validation';
+import { WsHandler, isWebSocketGateway } from '../websocket/ws-handler';
 
 // Conditionally import metrics
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -60,7 +67,7 @@ function clearGlobalTraceContext(): void {
  * OneBun Application
  */
 export class OneBunApplication {
-  private rootModule: Module;
+  private rootModule: ModuleInstance;
   private server: ReturnType<typeof Bun.serve> | null = null;
   private options: ApplicationOptions = {
     port: 3000,
@@ -75,6 +82,9 @@ export class OneBunApplication {
   private metricsService: any = null;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private traceService: any = null;
+  private wsHandler: WsHandler | null = null;
+  private queueService: QueueService | null = null;
+  private queueAdapter: QueueAdapter | null = null;
 
   /**
    * Create application instance
@@ -260,6 +270,23 @@ export class OneBunApplication {
       const controllers = this.rootModule.getControllers();
       this.logger.debug(`Loaded ${controllers.length} controllers`);
 
+      // Initialize WebSocket handler and detect gateways
+      this.wsHandler = new WsHandler(this.logger, this.options.websocket);
+      
+      // Register WebSocket gateways (they are in controllers array but decorated with @WebSocketGateway)
+      for (const controllerClass of controllers) {
+        if (isWebSocketGateway(controllerClass)) {
+          const instance = this.rootModule.getControllerInstance?.(controllerClass);
+          if (instance) {
+            this.wsHandler.registerGateway(controllerClass, instance as import('../websocket/ws-base-gateway').BaseWebSocketGateway);
+            this.logger.info(`Registered WebSocket gateway: ${controllerClass.name}`);
+          }
+        }
+      }
+
+      // Initialize Queue system if configured or handlers exist
+      await this.initializeQueue(controllers);
+
       // Create a map of routes with metadata
       const routes = new Map<
         string,
@@ -359,15 +386,48 @@ export class OneBunApplication {
 
       // Create server with proper context binding
       const app = this;
-      this.server = Bun.serve({
+      const hasWebSocketGateways = this.wsHandler?.hasGateways() ?? false;
+      
+      // Prepare WebSocket handlers if gateways exist
+      // When no gateways, use no-op handlers (required by Bun.serve)
+      const wsHandlers = hasWebSocketGateways ? this.wsHandler!.createWebSocketHandlers() : {
+         
+        open() { /* no-op */ },
+         
+        message() { /* no-op */ },
+         
+        close() { /* no-op */ },
+         
+        drain() { /* no-op */ },
+      };
+      
+      this.server = Bun.serve<WsClientData>({
         port: this.options.port,
         hostname: this.options.host,
-        async fetch(req) {
+        // WebSocket handlers
+        websocket: wsHandlers,
+        async fetch(req, server) {
           const url = new URL(req.url);
           const path = url.pathname;
           const method = req.method;
           const startTime = Date.now();
 
+          // Handle WebSocket upgrade if gateways exist
+          if (hasWebSocketGateways && app.wsHandler) {
+            const upgradeHeader = req.headers.get('upgrade')?.toLowerCase();
+            
+            // Check for WebSocket upgrade or Socket.IO polling
+            if (upgradeHeader === 'websocket' || path.startsWith('/socket.io')) {
+              const response = await app.wsHandler.handleUpgrade(req, server);
+              if (response === undefined) {
+                return undefined; // Successfully upgraded
+              }
+
+              // Return response if upgrade failed
+              return response;
+            }
+          }
+
           // Setup tracing context if available and enabled
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           let traceSpan: any = null;
@@ -675,6 +735,12 @@ export class OneBunApplication {
         },
       });
 
+      // Initialize WebSocket gateways with server
+      if (hasWebSocketGateways && this.wsHandler && this.server) {
+        this.wsHandler.initializeGateways(this.server);
+        this.logger.info(`WebSocket server enabled at ws://${this.options.host}:${this.options.port}`);
+      }
+
       this.logger.info(`Server started on http://${this.options.host}:${this.options.port}`);
       if (this.metricsService) {
         this.logger.info(
@@ -685,6 +751,11 @@ export class OneBunApplication {
           'Metrics enabled but @onebun/metrics module not available. Install with: bun add @onebun/metrics',
         );
       }
+
+      // Enable graceful shutdown by default (can be disabled with gracefulShutdown: false)
+      if (this.options.gracefulShutdown !== false) {
+        this.enableGracefulShutdown();
+      }
     } catch (error) {
       this.logger.error(
         'Failed to start application:',
@@ -910,14 +981,169 @@ export class OneBunApplication {
   }
 
   /**
-   * Stop the application
+   * Stop the application with graceful shutdown
+   * @param options - Shutdown options
    */
-  stop(): void {
+  async stop(options?: { closeSharedRedis?: boolean }): Promise<void> {
+    const closeRedis = options?.closeSharedRedis ?? true;
+
+    this.logger.info('Stopping OneBun application...');
+
+    // Cleanup WebSocket resources
+    if (this.wsHandler) {
+      this.logger.debug('Cleaning up WebSocket handler');
+      await this.wsHandler.cleanup();
+      this.wsHandler = null;
+    }
+
+    // Stop queue service
+    if (this.queueService) {
+      this.logger.debug('Stopping queue service');
+      await this.queueService.stop();
+      this.queueService = null;
+    }
+
+    // Disconnect queue adapter
+    if (this.queueAdapter) {
+      this.logger.debug('Disconnecting queue adapter');
+      await this.queueAdapter.disconnect();
+      this.queueAdapter = null;
+    }
+
+    // Stop HTTP server
     if (this.server) {
       this.server.stop();
       this.server = null;
-      this.logger.info('OneBun application stopped');
+      this.logger.debug('HTTP server stopped');
+    }
+
+    // Close shared Redis connection if configured and requested
+    if (closeRedis && SharedRedisProvider.isConnected()) {
+      this.logger.debug('Disconnecting shared Redis');
+      await SharedRedisProvider.disconnect();
     }
+
+    this.logger.info('OneBun application stopped');
+  }
+
+  /**
+   * Initialize the queue system based on configuration and detected handlers
+   */
+  private async initializeQueue(controllers: Function[]): Promise<void> {
+    const queueOptions = this.options.queue;
+    
+    // Check if any controller has queue-related decorators
+    const hasQueueHandlers = controllers.some(controller => {
+      const instance = this.rootModule.getControllerInstance?.(controller);
+      if (!instance) {
+        return false;
+      }
+
+      return hasQueueDecorators(instance.constructor);
+    });
+
+    // Determine if queue should be enabled
+    const shouldEnableQueue = queueOptions?.enabled ?? hasQueueHandlers;
+    if (!shouldEnableQueue) {
+      this.logger.debug('Queue system not enabled (no handlers detected or explicitly disabled)');
+
+      return;
+    }
+
+    // Create the appropriate adapter
+    const adapterType = queueOptions?.adapter ?? 'memory';
+    
+    if (adapterType === 'memory') {
+      this.queueAdapter = new InMemoryQueueAdapter();
+      this.logger.info('Queue system initialized with in-memory adapter');
+    } else if (adapterType === 'redis') {
+      const redisOptions = queueOptions?.redis ?? {};
+      if (redisOptions.useSharedProvider !== false) {
+        // Use shared Redis provider
+        this.queueAdapter = new RedisQueueAdapter({
+          useSharedClient: true,
+          keyPrefix: redisOptions.prefix ?? 'onebun:queue:',
+        });
+        this.logger.info('Queue system initialized with Redis adapter (shared provider)');
+      } else if (redisOptions.url) {
+        // Create dedicated Redis connection
+        this.queueAdapter = new RedisQueueAdapter({
+          useSharedClient: false,
+          url: redisOptions.url,
+          keyPrefix: redisOptions.prefix ?? 'onebun:queue:',
+        });
+        this.logger.info('Queue system initialized with Redis adapter (dedicated connection)');
+      } else {
+        throw new Error('Redis queue adapter requires either useSharedProvider: true or a url');
+      }
+    } else {
+      throw new Error(`Unknown queue adapter type: ${adapterType}`);
+    }
+
+    // Connect the adapter
+    await this.queueAdapter.connect();
+
+    // Create queue service with config
+    this.queueService = new QueueService({
+      adapter: adapterType,
+      options: queueOptions?.redis,
+    });
+    
+    // Initialize with the adapter
+    await this.queueService.initialize(this.queueAdapter);
+
+    // Register handlers from controllers using registerService
+    for (const controllerClass of controllers) {
+      const instance = this.rootModule.getControllerInstance?.(controllerClass);
+      if (!instance) {
+        continue;
+      }
+      
+      // Only register if the controller has queue decorators
+      if (hasQueueDecorators(controllerClass)) {
+        await this.queueService.registerService(
+          instance,
+          controllerClass as new (...args: unknown[]) => unknown,
+        );
+        this.logger.debug(`Registered queue handlers for controller: ${controllerClass.name}`);
+      }
+    }
+
+    // Start the queue service
+    await this.queueService.start();
+    this.logger.info('Queue service started');
+  }
+
+  /**
+   * Get the queue service instance
+   * @returns The queue service or null if not enabled
+   */
+  getQueueService(): QueueService | null {
+    return this.queueService;
+  }
+
+  /**
+   * Register signal handlers for graceful shutdown
+   * Call this after start() to enable automatic shutdown on SIGTERM/SIGINT
+   * 
+   * @example
+   * ```typescript
+   * const app = new OneBunApplication(AppModule, options);
+   * await app.start();
+   * app.enableGracefulShutdown();
+   * ```
+   */
+  enableGracefulShutdown(): void {
+    const shutdown = async (signal: string) => {
+      this.logger.info(`Received ${signal}, initiating graceful shutdown...`);
+      await this.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+
+    this.logger.debug('Graceful shutdown handlers registered');
   }
 
   /**

package/src/application/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Application Module
+ *
+ * Application bootstrapping and multi-service support.
+ */
+
+export * from './multi-service.types';
+export * from './application';
+export * from './multi-service-application';

package/src/{multi-service-application.test.ts → application/multi-service-application.test.ts}

@@ -7,7 +7,8 @@ import {
 
 import { TypedEnv } from '@onebun/envs';
 
-import { Module } from './decorators';
+import { Module } from '../decorators/decorators';
+
 import { MultiServiceApplication } from './multi-service-application';
 
 // Test modules

package/src/{multi-service-application.ts → application/multi-service-application.ts}

@@ -15,8 +15,9 @@ import {
   type SyncLogger,
 } from '@onebun/logger';
 
+import { resolveEnvOverrides } from '../service-client/env-resolver';
+
 import { OneBunApplication } from './application';
-import { resolveEnvOverrides } from './env-resolver';
 
 /**
  * ENV schema for service filtering

package/src/{multi-service.types.ts → application/multi-service.types.ts}

@@ -1,4 +1,4 @@
-import type { ApplicationOptions } from './types';
+import type { ApplicationOptions } from '../types';
 
 import type { EnvLoadOptions, EnvSchema } from '@onebun/envs';
 

package/src/{decorators.test.ts → decorators/decorators.test.ts}

@@ -12,6 +12,8 @@ import {
   beforeEach,
 } from 'bun:test';
 
+import { HttpMethod, ParamType } from '../types';
+
 import {
   injectable,
   Controller,
@@ -39,7 +41,6 @@ import {
   getModuleMetadata,
   ApiResponse,
 } from './decorators';
-import { HttpMethod, ParamType } from './types';
 
 describe('decorators', () => {
   beforeEach(() => {

package/src/{decorators.ts → decorators/decorators.ts}

@@ -1,13 +1,14 @@
 import './metadata'; // Import polyfill first
 import type { Type } from 'arktype';
 
-import { getConstructorParamTypes as getDesignParamTypes, Reflect } from './metadata';
 import {
   type ControllerMetadata,
   HttpMethod,
   type ParamMetadata,
   ParamType,
-} from './types';
+} from '../types';
+
+import { getConstructorParamTypes as getDesignParamTypes, Reflect } from './metadata';
 
 /**
  * Metadata storage for controllers

package/src/decorators/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Decorators Module
+ *
+ * HTTP decorators and metadata utilities.
+ */
+
+// Export metadata utilities (excluding getConstructorParamTypes which is re-exported from decorators)
+export {
+  defineMetadata,
+  getMetadata,
+  Reflect,
+} from './metadata';
+
+// Export all decorators (including getConstructorParamTypes)
+export * from './decorators';