@onebun/core 0.1.1 → 0.1.3

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,51 +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';
+
+// Application
+export * from './application';
 
-// Service definition and client
-export { createServiceDefinition } from './service-definition';
-export type {
-  ServiceDefinition,
-  EndpointMetadata,
-  ControllerDefinition,
-} from './service-definition';
+// Service Client
+export * from './service-client';
 
-export { createServiceClient, getServiceUrl } from './service-client';
-export type { ServiceClientOptions, ControllerClient } from './service-client.types';
+// Redis
+export * from './redis';
+
+// WebSocket
+export * from './websocket';
+
+// Queue System
+export * from './queue';
+
+// Validation
+export * from './validation';
 
-// ENV resolver
-export { resolveEnvOverrides, resolveEnvOverridesSync } from './env-resolver';
+// 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,13 +21,15 @@ import {
   getConstructorParamTypes,
   getModuleMetadata,
   registerControllerDependencies,
-} from './decorators';
+} from '../decorators/decorators';
+import { isWebSocketGateway } from '../websocket/ws-decorators';
+
 import { getServiceMetadata, getServiceTag } from './service';
 
 /**
  * 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();
@@ -331,14 +333,19 @@ export class OneBunModule implements Module {
       const controllerConstructor = controllerClass as new (...args: unknown[]) => Controller;
       const controller = new controllerConstructor(...dependencies);
 
-      // Initialize controller with logger and config
-      controller.initializeController(this.logger, this.config);
+      // Initialize controller with logger and config (skip for WebSocket gateways)
+      if (!isWebSocketGateway(controllerClass) && typeof controller.initializeController === 'function') {
+        controller.initializeController(this.logger, this.config);
+      }
 
       this.controllerInstances.set(controllerClass, controller);
 
       // Inject all services into controller (for legacy compatibility)
-      for (const [tag, serviceInstance] of this.serviceInstances.entries()) {
-        controller.setService(tag, serviceInstance);
+      // Skip for WebSocket gateways which don't have setService
+      if (!isWebSocketGateway(controllerClass) && typeof controller.setService === 'function') {
+        for (const [tag, serviceInstance] of this.serviceInstances.entries()) {
+          controller.setService(tag, serviceInstance);
+        }
       }
 
       if (paramTypes && paramTypes.length > 0) {
@@ -432,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';

package/src/queue/adapters/memory.adapter.test.ts

@@ -0,0 +1,405 @@
+/**
+ * In-Memory Queue Adapter Tests
+ */
+
+import {
+  describe,
+  it,
+  expect,
+  beforeEach,
+  afterEach,
+} from 'bun:test';
+
+import type { Message } from '../types';
+
+import { InMemoryQueueAdapter, createInMemoryQueueAdapter } from './memory.adapter';
+
+describe('InMemoryQueueAdapter', () => {
+  let adapter: InMemoryQueueAdapter;
+
+  beforeEach(() => {
+    adapter = new InMemoryQueueAdapter();
+  });
+
+  afterEach(async () => {
+    await adapter.disconnect();
+  });
+
+  describe('lifecycle', () => {
+    it('should connect successfully', async () => {
+      expect(adapter.isConnected()).toBe(false);
+      await adapter.connect();
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    it('should disconnect successfully', async () => {
+      await adapter.connect();
+      expect(adapter.isConnected()).toBe(true);
+      await adapter.disconnect();
+      expect(adapter.isConnected()).toBe(false);
+    });
+
+    it('should handle multiple connect calls', async () => {
+      await adapter.connect();
+      await adapter.connect();
+      expect(adapter.isConnected()).toBe(true);
+    });
+
+    it('should have correct name and type', () => {
+      expect(adapter.name).toBe('memory');
+      expect(adapter.type).toBe('memory');
+    });
+  });
+
+  describe('publish/subscribe', () => {
+    it('should publish and receive messages', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      await adapter.subscribe('orders.created', async (message) => {
+        received.push(message);
+      });
+
+      await adapter.publish('orders.created', { orderId: 123 });
+
+      expect(received.length).toBe(1);
+      expect(received[0].data).toEqual({ orderId: 123 });
+      expect(received[0].pattern).toBe('orders.created');
+    });
+
+    it('should match wildcard patterns', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      await adapter.subscribe('orders.*', async (message) => {
+        received.push(message);
+      });
+
+      await adapter.publish('orders.created', { type: 'created' });
+      await adapter.publish('orders.updated', { type: 'updated' });
+      await adapter.publish('users.created', { type: 'user' }); // Should not match
+
+      expect(received.length).toBe(2);
+      expect(received[0].data).toEqual({ type: 'created' });
+      expect(received[1].data).toEqual({ type: 'updated' });
+    });
+
+    it('should match multi-level wildcard (#)', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      await adapter.subscribe('events.#', async (message) => {
+        received.push(message);
+      });
+
+      await adapter.publish('events.user.created', { type: 'user' });
+      await adapter.publish('events.order.payment.completed', { type: 'payment' });
+
+      expect(received.length).toBe(2);
+    });
+
+    it('should return message ID on publish', async () => {
+      await adapter.connect();
+
+      const messageId = await adapter.publish('test', { data: 'test' });
+      expect(messageId).toMatch(/^msg-\d+-\d+$/);
+    });
+
+    it('should use custom message ID when provided', async () => {
+      await adapter.connect();
+
+      const messageId = await adapter.publish('test', { data: 'test' }, { messageId: 'custom-id' });
+      expect(messageId).toBe('custom-id');
+    });
+  });
+
+  describe('delayed messages', () => {
+    it('should delay message delivery', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      await adapter.subscribe('delayed', async (message) => {
+        received.push(message);
+      });
+
+      await adapter.publish('delayed', { data: 'delayed' }, { delay: 50 });
+
+      // Message should not be received immediately
+      expect(received.length).toBe(0);
+
+      // Wait for delay + processing
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      expect(received.length).toBe(1);
+      expect(received[0].data).toEqual({ data: 'delayed' });
+    });
+  });
+
+  describe('subscription management', () => {
+    it('should unsubscribe successfully', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      const subscription = await adapter.subscribe('test', async (message) => {
+        received.push(message);
+      });
+
+      await adapter.publish('test', { count: 1 });
+      expect(received.length).toBe(1);
+
+      await subscription.unsubscribe();
+
+      await adapter.publish('test', { count: 2 });
+      expect(received.length).toBe(1); // Still 1, no new messages
+    });
+
+    it('should pause and resume subscription', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      const subscription = await adapter.subscribe('test', async (message) => {
+        received.push(message);
+      });
+
+      await adapter.publish('test', { count: 1 });
+      expect(received.length).toBe(1);
+
+      subscription.pause();
+
+      await adapter.publish('test', { count: 2 });
+      expect(received.length).toBe(1); // Paused
+
+      subscription.resume();
+
+      await adapter.publish('test', { count: 3 });
+      expect(received.length).toBe(2);
+    });
+
+    it('should report subscription state', async () => {
+      await adapter.connect();
+
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      const subscription = await adapter.subscribe('test', async () => {});
+
+      expect(subscription.isActive).toBe(true);
+      expect(subscription.pattern).toBe('test');
+
+      subscription.pause();
+      expect(subscription.isActive).toBe(false);
+
+      subscription.resume();
+      expect(subscription.isActive).toBe(true);
+
+      await subscription.unsubscribe();
+      expect(subscription.isActive).toBe(false);
+    });
+  });
+
+  describe('batch publishing', () => {
+    it('should publish multiple messages', async () => {
+      await adapter.connect();
+
+      const received: Message[] = [];
+      await adapter.subscribe('batch.*', async (message) => {
+        received.push(message);
+      });
+
+      const ids = await adapter.publishBatch([
+        { pattern: 'batch.1', data: { index: 1 } },
+        { pattern: 'batch.2', data: { index: 2 } },
+        { pattern: 'batch.3', data: { index: 3 } },
+      ]);
+
+      expect(ids.length).toBe(3);
+      expect(received.length).toBe(3);
+    });
+  });
+
+  describe('message acknowledgment', () => {
+    it('should auto-ack by default', async () => {
+      await adapter.connect();
+
+      let messageRef: Message | null = null;
+      await adapter.subscribe('test', async (message) => {
+        messageRef = message;
+      });
+
+      await adapter.publish('test', { data: 'test' });
+
+      expect(messageRef).not.toBeNull();
+      // In auto mode, ack is called automatically
+    });
+
+    it('should support manual ack mode', async () => {
+      await adapter.connect();
+
+      let messageRef: Message | null = null;
+      await adapter.subscribe(
+        'test',
+        async (message) => {
+          messageRef = message;
+          // In manual mode, we need to ack
+          await message.ack();
+        },
+        { ackMode: 'manual' },
+      );
+
+      await adapter.publish('test', { data: 'test' });
+
+      expect(messageRef).not.toBeNull();
+    });
+
+    it('should support nack with requeue', async () => {
+      await adapter.connect();
+
+      let callCount = 0;
+      await adapter.subscribe(
+        'test',
+        async (message) => {
+          callCount++;
+          if (callCount === 1) {
+            await message.nack(true); // Requeue
+          } else {
+            await message.ack();
+          }
+        },
+        { ackMode: 'manual' },
+      );
+
+      await adapter.publish('test', { data: 'test' });
+
+      // Wait for requeue processing (setImmediate is used for requeue)
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      expect(callCount).toBeGreaterThanOrEqual(2); // Should be called at least twice due to requeue
+    });
+  });
+
+  describe('events', () => {
+    it('should emit onReady event on connect', async () => {
+      let readyEmitted = false;
+      adapter.on('onReady', () => {
+        readyEmitted = true;
+      });
+
+      await adapter.connect();
+      expect(readyEmitted).toBe(true);
+    });
+
+    it('should emit onMessageReceived event', async () => {
+      await adapter.connect();
+
+      let receivedMessage: Message | null = null;
+      adapter.on('onMessageReceived', (message) => {
+        receivedMessage = message as Message;
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      await adapter.subscribe('test', async () => {});
+      await adapter.publish('test', { data: 'test' });
+
+      expect(receivedMessage).not.toBeNull();
+      expect(receivedMessage!.pattern).toBe('test');
+    });
+
+    it('should emit onMessageProcessed event', async () => {
+      await adapter.connect();
+
+      let processed = false;
+      adapter.on('onMessageProcessed', () => {
+        processed = true;
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      await adapter.subscribe('test', async () => {});
+      await adapter.publish('test', { data: 'test' });
+
+      expect(processed).toBe(true);
+    });
+
+    it('should emit onMessageFailed event on error', async () => {
+      await adapter.connect();
+
+      let failedMessage: Message | null = null;
+      let failedError: Error | null = null;
+      adapter.on('onMessageFailed', (message, error) => {
+        failedMessage = message as Message;
+        failedError = error as Error;
+      });
+
+      await adapter.subscribe('test', async () => {
+        throw new Error('Handler error');
+      });
+      await adapter.publish('test', { data: 'test' });
+
+      expect(failedMessage).not.toBeNull();
+      expect(failedError).not.toBeNull();
+      expect(failedError!.message).toBe('Handler error');
+    });
+
+    it('should unregister event handlers', async () => {
+      let callCount = 0;
+      const handler = () => {
+        callCount++;
+      };
+
+      adapter.on('onReady', handler);
+      await adapter.connect();
+      expect(callCount).toBe(1);
+
+      await adapter.disconnect();
+      adapter.off('onReady', handler);
+
+      await adapter.connect();
+      expect(callCount).toBe(1); // Should still be 1
+    });
+  });
+
+  describe('feature support', () => {
+    it('should support pattern-subscriptions', () => {
+      expect(adapter.supports('pattern-subscriptions')).toBe(true);
+    });
+
+    it('should support delayed-messages', () => {
+      expect(adapter.supports('delayed-messages')).toBe(true);
+    });
+
+    it('should support priority', () => {
+      expect(adapter.supports('priority')).toBe(true);
+    });
+
+    it('should support scheduled-jobs', () => {
+      expect(adapter.supports('scheduled-jobs')).toBe(true);
+    });
+
+    it('should not support consumer-groups', () => {
+      expect(adapter.supports('consumer-groups')).toBe(false);
+    });
+
+    it('should not support dead-letter-queue', () => {
+      expect(adapter.supports('dead-letter-queue')).toBe(false);
+    });
+
+    it('should not support retry', () => {
+      expect(adapter.supports('retry')).toBe(false);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw when publishing without connecting', async () => {
+      await expect(adapter.publish('test', { data: 'test' })).rejects.toThrow();
+    });
+
+    it('should throw when subscribing without connecting', async () => {
+      // eslint-disable-next-line @typescript-eslint/no-empty-function
+      await expect(adapter.subscribe('test', async () => {})).rejects.toThrow();
+    });
+  });
+
+  describe('createInMemoryQueueAdapter', () => {
+    it('should create adapter instance', () => {
+      const created = createInMemoryQueueAdapter();
+      expect(created).toBeInstanceOf(InMemoryQueueAdapter);
+    });
+  });
+});