@onebun/core 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",

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

@@ -9,10 +9,8 @@ import {
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { register } from 'prom-client';
 
-import type { ApplicationOptions } from './types';
+import type { ApplicationOptions } from '../types';
 
-import { OneBunApplication } from './application';
-import { Controller as BaseController } from './controller';
 import {
   Module,
   Controller,
@@ -21,8 +19,11 @@ import {
   Param,
   Query,
   Body,
-} from './decorators';
-import { makeMockLoggerLayer } from './test-utils';
+} from '../decorators/decorators';
+import { Controller as BaseController } from '../module/controller';
+import { makeMockLoggerLayer } from '../testing/test-utils';
+
+import { OneBunApplication } from './application';
 
 // Helper function to create app with mock logger to suppress logs in tests
 function createTestApp(

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

@@ -1,7 +1,7 @@
 import { Effect, type Layer } from 'effect';
 
-import type { Controller } from './controller';
-import type { WsClientData } from './ws.types';
+import type { Controller } from '../module/controller';
+import type { WsClientData } from '../websocket/ws.types';
 
 import { TypedEnv } from '@onebun/envs';
 import {
@@ -20,20 +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 { SharedRedisProvider } from './shared-redis';
+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';
-import { WsHandler, isWebSocketGateway } from './ws-handler';
+} 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
@@ -63,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,
@@ -79,6 +83,8 @@ export class OneBunApplication {
   // 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
@@ -272,12 +278,15 @@ export class OneBunApplication {
         if (isWebSocketGateway(controllerClass)) {
           const instance = this.rootModule.getControllerInstance?.(controllerClass);
           if (instance) {
-            this.wsHandler.registerGateway(controllerClass, instance as import('./ws-base-gateway').BaseWebSocketGateway);
+            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,
@@ -987,6 +996,20 @@ export class OneBunApplication {
       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();
@@ -1003,6 +1026,102 @@ export class OneBunApplication {
     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

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';

package/src/index.ts

@@ -1,7 +1,4 @@
-// export * from './metadata';
-// export * from './types';
-// export * from './config.service';
-// Re-export envs from @onebun/envs
+// Re-export from external packages
 export { Env, type EnvSchema, EnvValidationError } from '@onebun/envs';
 export type { SyncLogger } from '@onebun/logger';
 export {
@@ -15,147 +12,63 @@ export {
   type SuccessResponse,
 } from '@onebun/requests';
 export { Span } from '@onebun/trace';
+
 // Re-export Effect and Layer from effect
 export { Effect, Layer } from 'effect';
-export { OneBunApplication } from './application';
-export { Controller as BaseController } from './controller';
-export * from './decorators';
-export { defineMetadata, getMetadata } from './metadata';
-export { OneBunModule } from './module';
-export { BaseService, getServiceTag, Service } from './service';
-export {
-  FakeTimers,
-  fakeTimers,
-  useFakeTimers,
-  makeMockLoggerLayer,
-} from './test-utils';
+
+// Types (excluding WebSocket types that are re-exported from ./websocket)
 export {
   HttpMethod,
-  type RouteMetadata,
-  type ControllerMetadata,
+  ParamType,
+  type ServiceInterface,
+  type ModuleProviders,
+  type ModuleInstance,
+  type TypedEnvSchema,
+  type ApplicationOptions,
   type ParamMetadata,
   type ResponseSchemaMetadata,
-  ParamType, 
+  type RouteMetadata,
+  type ControllerMetadata,
+  // WebSocket types are exported from ./websocket
+  type WsStorageType,
+  type WsStorageOptions,
+  type WebSocketApplicationOptions,
 } from './types';
-export * from './validation';
 
-// Multi-service application
-export { MultiServiceApplication } from './multi-service-application';
-export type {
-  MultiServiceApplicationOptions,
-  ServiceConfig,
-  ServicesMap,
-  BaseServiceOptions,
-  EnvOverrideValue,
-  EnvOverrides,
-} from './multi-service.types';
+// Decorators and Metadata (exports Controller decorator, Module decorator, etc.)
+export * from './decorators';
+
+// Module System - explicitly re-export to avoid Controller conflict
+export {
+  OneBunModule,
+  Controller as BaseController,
+  BaseService,
+  Service,
+  getServiceMetadata,
+  getServiceTag,
+  createServiceLayer,
+  ConfigServiceImpl,
+  ConfigServiceTag,
+  ConfigService,
+} from './module';
 
-// Service definition and client
-export { createServiceDefinition } from './service-definition';
-export type {
-  ServiceDefinition,
-  EndpointMetadata,
-  ControllerDefinition,
-} from './service-definition';
+// Application
+export * from './application';
 
-export { createServiceClient, getServiceUrl } from './service-client';
-export type { ServiceClientOptions, ControllerClient } from './service-client.types';
+// Service Client
+export * from './service-client';
 
-// ENV resolver
-export { resolveEnvOverrides, resolveEnvOverridesSync } from './env-resolver';
+// Redis
+export * from './redis';
 
-// WebSocket Gateway
-export { BaseWebSocketGateway } from './ws-base-gateway';
-export {
-  WebSocketGateway,
-  OnConnect,
-  OnDisconnect,
-  OnJoinRoom,
-  OnLeaveRoom,
-  OnMessage,
-  Client,
-  Socket,
-  MessageData,
-  RoomName,
-  PatternParams,
-  WsServer,
-  UseWsGuards,
-  getGatewayMetadata,
-  isWebSocketGateway,
-} from './ws-decorators';
-export {
-  WsAuthGuard,
-  WsPermissionGuard,
-  WsRoomGuard,
-  WsAnyPermissionGuard,
-  WsServiceGuard,
-  WsAllGuards,
-  WsAnyGuard,
-  WsExecutionContextImpl,
-  executeGuards,
-  createGuard,
-} from './ws-guards';
-export type {
-  WsClientData,
-  WsAuthData,
-  WsRoom,
-  WsHandlerType,
-  WsParamType,
-  GatewayMetadata,
-  WsHandlerMetadata,
-  WsParamMetadata,
-  WebSocketGatewayOptions,
-  WsStorageOptions,
-  WebSocketApplicationOptions,
-  WsMessage,
-  WsHandlerResponse,
-  PatternMatch,
-  WsExecutionContext,
-  WsGuard,
-  WsServer as WsServerType,
-} from './ws.types';
-export {
-  WsHandlerType as WsHandlerTypeEnum,
-  WsParamType as WsParamTypeEnum,
-  isWsMessage,
-  isWsHandlerResponse,
-  isWsClientData,
-  isWsRoom,
-} from './ws.types';
-export {
-  matchPattern,
-  isPatternMatch,
-  createPatternMatcher,
-  isPattern,
-  getPatternParams,
-  buildFromPattern,
-} from './ws-pattern-matcher';
-export type { WsStorageAdapter, WsPubSubStorageAdapter, WsStorageEventPayload } from './ws-storage';
-export { WsStorageEvent, isPubSubAdapter } from './ws-storage';
-export { InMemoryWsStorage, createInMemoryWsStorage } from './ws-storage-memory';
-export { RedisWsStorage, createRedisWsStorage } from './ws-storage-redis';
+// WebSocket
+export * from './websocket';
 
-// Redis Client (shared)
-export { RedisClient, createRedisClient } from './redis-client';
-export type { RedisClientOptions } from './redis-client';
-export {
-  SharedRedisProvider, SharedRedisService, makeSharedRedisLayer, getSharedRedis, 
-} from './shared-redis';
-export type { SharedRedisOptions } from './shared-redis';
+// Queue System
+export * from './queue';
 
-// WebSocket Service Definition and Client
-export {
-  createWsServiceDefinition, getWsGatewayNames, getWsEventNames, getWsEndpoint, 
-} from './ws-service-definition';
-export type { WsServiceDefinition, WsGatewayDefinition, WsEndpointMetadata } from './ws-service-definition';
-export { createWsClient } from './ws-client';
-export type {
-  WsClientOptions,
-  WsClient,
-  WsGatewayClient,
-  WsEventListener,
-  WsClientEvent,
-  WsClientEventListeners,
-  TypedWsClient,
-} from './ws-client.types';
-export { WsConnectionState } from './ws-client.types';
+// Validation
+export * from './validation';
+
+// Testing Utilities
+export * from './testing';

package/src/module/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Module System
+ *
+ * Core module, controller, and service abstractions.
+ */
+
+export * from './module';
+export * from './controller';
+// Re-export Controller as BaseController for backward compatibility
+export { Controller as BaseController } from './controller';
+export * from './service';
+export * from './config.service';

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

@@ -11,9 +11,10 @@ import {
 } from 'bun:test';
 import { Context } from 'effect';
 
-import { makeDevLogger } from '../../logger/src/logger';
+import { makeDevLogger } from '@onebun/logger';
+
+import { Module } from '../decorators/decorators';
 
-import { Module } from './decorators';
 import { OneBunModule } from './module';
 import { Service } from './service';
 

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

@@ -5,7 +5,7 @@ import {
 } from 'effect';
 
 import type { Controller } from './controller';
-import type { Module } from './types';
+import type { ModuleInstance } from '../types';
 
 import {
   createSyncLogger,
@@ -21,14 +21,15 @@ import {
   getConstructorParamTypes,
   getModuleMetadata,
   registerControllerDependencies,
-} from './decorators';
+} from '../decorators/decorators';
+import { isWebSocketGateway } from '../websocket/ws-decorators';
+
 import { getServiceMetadata, getServiceTag } from './service';
-import { isWebSocketGateway } from './ws-decorators';
 
 /**
  * OneBun Module implementation
  */
-export class OneBunModule implements Module {
+export class OneBunModule implements ModuleInstance {
   private rootLayer: Layer.Layer<never, never, unknown>;
   private controllers: Function[] = [];
   private controllerInstances: Map<Function, Controller> = new Map();
@@ -438,7 +439,7 @@ export class OneBunModule implements Module {
     moduleClass: Function,
     loggerLayer?: Layer.Layer<never, never, unknown>,
     config?: unknown,
-  ): Module {
+  ): ModuleInstance {
     // Using console.log here because we don't have access to the logger instance yet
     // The instance will create its own logger in the constructor
     return new OneBunModule(moduleClass, loggerLayer, config);

package/src/queue/adapters/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Queue Adapters
+ *
+ * Built-in queue adapters for OneBun.
+ */
+
+export { InMemoryQueueAdapter, createInMemoryQueueAdapter } from './memory.adapter';
+export { RedisQueueAdapter, createRedisQueueAdapter, type RedisQueueOptions } from './redis.adapter';