@ooneex/pub-sub 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ooneex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,648 @@
+# @ooneex/pub-sub
+
+A publish-subscribe messaging pattern implementation for TypeScript applications with Redis support. This package provides an abstract base class for creating pub/sub handlers and a Redis client for distributed messaging across application components.
+
+![Bun](https://img.shields.io/badge/Bun-Compatible-orange?style=flat-square&logo=bun)
+![Deno](https://img.shields.io/badge/Deno-Compatible-blue?style=flat-square&logo=deno)
+![Node.js](https://img.shields.io/badge/Node.js-Compatible-green?style=flat-square&logo=node.js)
+![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)
+![MIT License](https://img.shields.io/badge/License-MIT-yellow?style=flat-square)
+
+## Features
+
+✅ **Redis Integration** - Built-in Redis pub/sub client for distributed messaging
+
+✅ **Abstract Base Class** - Create custom pub/sub handlers with consistent interface
+
+✅ **Channel Management** - Subscribe, unsubscribe, and publish to channels
+
+✅ **Type-Safe** - Full TypeScript support with generic data types
+
+✅ **Container Integration** - Works seamlessly with dependency injection
+
+✅ **Auto Reconnection** - Redis client with automatic reconnection support
+
+✅ **Key Support** - Optional message keys for routing and filtering
+
+## Installation
+
+### Bun
+```bash
+bun add @ooneex/pub-sub
+```
+
+### pnpm
+```bash
+pnpm add @ooneex/pub-sub
+```
+
+### Yarn
+```bash
+yarn add @ooneex/pub-sub
+```
+
+### npm
+```bash
+npm install @ooneex/pub-sub
+```
+
+## Usage
+
+### Basic Pub/Sub Handler
+
+```typescript
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+import type { ScalarType } from '@ooneex/types';
+
+interface NotificationData extends Record<string, ScalarType> {
+  userId: string;
+  title: string;
+  body: string;
+}
+
+class NotificationPubSub extends PubSub<NotificationData> {
+  public getChannel(): string {
+    return 'notifications';
+  }
+
+  public async handler(context: { 
+    data: NotificationData; 
+    channel: string; 
+    key?: string 
+  }): Promise<void> {
+    const { data, channel, key } = context;
+    
+    console.log(`Received on ${channel}:`, data);
+    
+    // Handle the notification
+    await this.sendPushNotification(data.userId, data.title, data.body);
+  }
+
+  private async sendPushNotification(
+    userId: string, 
+    title: string, 
+    body: string
+  ): Promise<void> {
+    // Push notification logic
+  }
+}
+
+// Create Redis client
+const redisClient = new RedisPubSub({
+  connectionString: 'redis://localhost:6379'
+});
+
+// Create pub/sub handler
+const notificationPubSub = new NotificationPubSub(redisClient);
+
+// Subscribe to channel
+await notificationPubSub.subscribe();
+
+// Publish a message
+await notificationPubSub.publish({
+  userId: 'user-123',
+  title: 'New Message',
+  body: 'You have a new message!'
+});
+```
+
+### Using Environment Variables
+
+```typescript
+import { RedisPubSub } from '@ooneex/pub-sub';
+
+// Automatically uses CACHE_REDIS_URL environment variable
+const client = new RedisPubSub();
+```
+
+**Environment Variables:**
+- `CACHE_REDIS_URL` - Redis connection string
+
+### Publishing with Keys
+
+```typescript
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+
+interface OrderEvent extends Record<string, ScalarType> {
+  orderId: string;
+  status: string;
+  amount: number;
+}
+
+class OrderPubSub extends PubSub<OrderEvent> {
+  public getChannel(): string {
+    return 'orders';
+  }
+
+  public async handler(context: { 
+    data: OrderEvent; 
+    channel: string; 
+    key?: string 
+  }): Promise<void> {
+    const { data, key } = context;
+    
+    // Route based on key
+    switch (key) {
+      case 'created':
+        await this.handleOrderCreated(data);
+        break;
+      case 'completed':
+        await this.handleOrderCompleted(data);
+        break;
+      case 'cancelled':
+        await this.handleOrderCancelled(data);
+        break;
+    }
+  }
+}
+
+const orderPubSub = new OrderPubSub(new RedisPubSub());
+
+// Subscribe
+await orderPubSub.subscribe();
+
+// Publish with keys
+await orderPubSub.publish({
+  orderId: 'order-456',
+  status: 'created',
+  amount: 99.99
+}, 'created');
+
+await orderPubSub.publish({
+  orderId: 'order-456',
+  status: 'completed',
+  amount: 99.99
+}, 'completed');
+```
+
+### Dynamic Channels
+
+```typescript
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+
+interface ChatMessage extends Record<string, ScalarType> {
+  userId: string;
+  message: string;
+  timestamp: number;
+}
+
+class ChatRoomPubSub extends PubSub<ChatMessage> {
+  constructor(
+    client: RedisPubSub,
+    private readonly roomId: string
+  ) {
+    super(client);
+  }
+
+  public getChannel(): string {
+    return `chat:room:${this.roomId}`;
+  }
+
+  public async handler(context: { 
+    data: ChatMessage; 
+    channel: string 
+  }): Promise<void> {
+    const { data, channel } = context;
+    console.log(`[${channel}] ${data.userId}: ${data.message}`);
+  }
+}
+
+// Create room-specific pub/sub
+const room1 = new ChatRoomPubSub(new RedisPubSub(), 'room-1');
+const room2 = new ChatRoomPubSub(new RedisPubSub(), 'room-2');
+
+await room1.subscribe();
+await room2.subscribe();
+
+// Publish to specific room
+await room1.publish({
+  userId: 'user-123',
+  message: 'Hello Room 1!',
+  timestamp: Date.now()
+});
+```
+
+### Async Channel Names
+
+```typescript
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+
+interface UserEvent extends Record<string, ScalarType> {
+  action: string;
+  data: string;
+}
+
+class UserEventPubSub extends PubSub<UserEvent> {
+  constructor(
+    client: RedisPubSub,
+    private readonly getUserId: () => Promise<string>
+  ) {
+    super(client);
+  }
+
+  public async getChannel(): Promise<string> {
+    const userId = await this.getUserId();
+    return `user:${userId}:events`;
+  }
+
+  public async handler(context: { 
+    data: UserEvent; 
+    channel: string 
+  }): Promise<void> {
+    console.log('User event:', context.data);
+  }
+}
+```
+
+## API Reference
+
+### Classes
+
+#### `PubSub<Data>` (Abstract)
+
+Abstract base class for creating pub/sub handlers.
+
+**Type Parameter:**
+- `Data` - Data type extending `Record<string, ScalarType>`
+
+**Constructor:**
+```typescript
+new PubSub(client: IPubSubClient<Data>)
+```
+
+**Abstract Methods:**
+
+##### `getChannel(): string | Promise<string>`
+
+Returns the channel name to subscribe/publish to.
+
+**Returns:** Channel name (sync or async)
+
+##### `handler(context: { data: Data; channel: string; key?: string }): Promise<void> | void`
+
+Handle incoming messages on the channel.
+
+**Parameters:**
+- `context.data` - The message data
+- `context.channel` - The channel name
+- `context.key` - Optional message key
+
+**Concrete Methods:**
+
+##### `publish(data: Data, key?: string): Promise<void>`
+
+Publish a message to the channel.
+
+**Parameters:**
+- `data` - The data to publish
+- `key` - Optional key for message routing
+
+##### `subscribe(): Promise<void>`
+
+Subscribe to the channel and start receiving messages.
+
+##### `unsubscribe(): Promise<void>`
+
+Unsubscribe from the channel.
+
+##### `unsubscribeAll(): Promise<void>`
+
+Unsubscribe from all channels.
+
+---
+
+#### `RedisPubSub`
+
+Redis-based pub/sub client implementation.
+
+**Constructor:**
+```typescript
+new RedisPubSub(options?: RedisPubSubOptionsType)
+```
+
+**Parameters:**
+- `options.connectionString` - Redis URL (default: `CACHE_REDIS_URL` env var)
+- `options.connectionTimeout` - Connection timeout in ms (default: 10000)
+- `options.idleTimeout` - Idle timeout in ms (default: 30000)
+- `options.autoReconnect` - Enable auto reconnection (default: true)
+- `options.maxRetries` - Maximum retry attempts (default: 3)
+- `options.enableOfflineQueue` - Queue commands when offline (default: true)
+- `options.enableAutoPipelining` - Enable auto pipelining (default: true)
+- `options.tls` - TLS configuration (optional)
+
+**Methods:**
+
+##### `publish(config: { channel: string; data: Data; key?: string }): Promise<void>`
+
+Publish a message to a channel.
+
+##### `subscribe(channel: string, handler: PubSubMessageHandlerType<Data>): Promise<void>`
+
+Subscribe to a channel with a message handler.
+
+##### `unsubscribe(channel: string): Promise<void>`
+
+Unsubscribe from a specific channel.
+
+##### `unsubscribeAll(): Promise<void>`
+
+Unsubscribe from all channels.
+
+### Types
+
+#### `PubSubMessageHandlerType<Data>`
+
+Handler function type for incoming messages.
+
+```typescript
+type PubSubMessageHandlerType<Data> = (context: {
+  data: Data;
+  channel: string;
+  key?: string;
+}) => Promise<void> | void;
+```
+
+#### `RedisPubSubOptionsType`
+
+Configuration options for Redis pub/sub client.
+
+```typescript
+type RedisPubSubOptionsType = {
+  connectionString?: string;
+  connectionTimeout?: number;
+  idleTimeout?: number;
+  autoReconnect?: boolean;
+  maxRetries?: number;
+  enableOfflineQueue?: boolean;
+  enableAutoPipelining?: boolean;
+  tls?: boolean | object;
+};
+```
+
+#### `IPubSubClient<Data>`
+
+Interface for pub/sub client implementations.
+
+```typescript
+interface IPubSubClient<Data> {
+  publish: (config: { channel: string; data: Data; key?: string }) => Promise<void>;
+  subscribe: (channel: string, handler: PubSubMessageHandlerType<Data>) => Promise<void>;
+  unsubscribe: (channel: string) => Promise<void>;
+  unsubscribeAll: () => Promise<void>;
+}
+```
+
+#### `IPubSub<Data>`
+
+Interface for pub/sub handler implementations.
+
+```typescript
+interface IPubSub<Data> {
+  getChannel: () => Promise<string> | string;
+  handler: (context: { data: Data; channel: string; key?: string }) => Promise<void> | void;
+  publish: (data: Data, key?: string) => Promise<void> | void;
+  subscribe: () => Promise<void> | void;
+  unsubscribe: () => Promise<void> | void;
+  unsubscribeAll: () => Promise<void> | void;
+}
+```
+
+#### `PubSubClassType`
+
+Type for pub/sub class constructors.
+
+```typescript
+type PubSubClassType = new (...args: any[]) => IPubSub;
+```
+
+### Exceptions
+
+#### `PubSubException`
+
+Thrown when pub/sub operations fail.
+
+```typescript
+import { PubSub, PubSubException, RedisPubSub } from '@ooneex/pub-sub';
+
+try {
+  const client = new RedisPubSub();
+  await client.publish({ channel: 'test', data: { message: 'hello' } });
+} catch (error) {
+  if (error instanceof PubSubException) {
+    console.error('PubSub error:', error.message);
+  }
+}
+```
+
+### Decorators
+
+#### `@decorator.pubsub()`
+
+Decorator to register pub/sub classes with the DI container.
+
+```typescript
+import { PubSub, decorator, RedisPubSub } from '@ooneex/pub-sub';
+
+@decorator.pubsub()
+class MyEventPubSub extends PubSub {
+  // Implementation
+}
+```
+
+## Advanced Usage
+
+### Multiple Subscribers
+
+```typescript
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+
+interface EventData extends Record<string, ScalarType> {
+  type: string;
+  payload: string;
+}
+
+// Subscriber 1: Log events
+class EventLoggerPubSub extends PubSub<EventData> {
+  public getChannel(): string {
+    return 'events';
+  }
+
+  public async handler(context: { data: EventData }): Promise<void> {
+    console.log('Event logged:', context.data);
+  }
+}
+
+// Subscriber 2: Process events
+class EventProcessorPubSub extends PubSub<EventData> {
+  public getChannel(): string {
+    return 'events';
+  }
+
+  public async handler(context: { data: EventData }): Promise<void> {
+    await this.processEvent(context.data);
+  }
+}
+
+// Both subscribe to the same channel
+const client = new RedisPubSub();
+const logger = new EventLoggerPubSub(client);
+const processor = new EventProcessorPubSub(client);
+
+await logger.subscribe();
+await processor.subscribe();
+
+// Both receive this message
+await logger.publish({ type: 'user.created', payload: '{"id":"123"}' });
+```
+
+### Error Handling
+
+```typescript
+import { PubSub, RedisPubSub, PubSubException } from '@ooneex/pub-sub';
+
+class ResilientPubSub extends PubSub<Record<string, ScalarType>> {
+  public getChannel(): string {
+    return 'resilient';
+  }
+
+  public async handler(context: { data: Record<string, ScalarType> }): Promise<void> {
+    try {
+      await this.processMessage(context.data);
+    } catch (error) {
+      console.error('Failed to process message:', error);
+      // Optionally republish to dead letter channel
+      await this.publishToDeadLetter(context.data, error);
+    }
+  }
+
+  private async publishToDeadLetter(
+    data: Record<string, ScalarType>, 
+    error: unknown
+  ): Promise<void> {
+    // Dead letter queue logic
+  }
+}
+```
+
+### Integration with WebSocket
+
+```typescript
+import { Route } from '@ooneex/routing';
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+import type { IController, ContextType } from '@ooneex/socket';
+
+interface ChatData extends Record<string, ScalarType> {
+  roomId: string;
+  userId: string;
+  message: string;
+}
+
+// Pub/Sub for distributing messages across server instances
+class ChatPubSub extends PubSub<ChatData> {
+  public getChannel(): string {
+    return 'chat:messages';
+  }
+
+  public async handler(context: { data: ChatData }): Promise<void> {
+    // Broadcast to all connected WebSocket clients
+    await this.broadcastToRoom(context.data.roomId, context.data);
+  }
+}
+
+// WebSocket controller uses pub/sub for distributed messaging
+@Route.socket({
+  name: 'api.chat.send',
+  path: '/ws/chat/:roomId',
+  description: 'Send chat message'
+})
+class ChatController implements IController {
+  private readonly chatPubSub = new ChatPubSub(new RedisPubSub());
+
+  public async index(context: ContextType): Promise<IResponse> {
+    const { roomId } = context.params;
+    const { message } = context.payload;
+
+    // Publish through Redis for distribution to all server instances
+    await this.chatPubSub.publish({
+      roomId,
+      userId: context.user?.id ?? 'anonymous',
+      message
+    });
+
+    return context.response.json({ sent: true });
+  }
+}
+```
+
+### Pattern-Based Subscriptions
+
+```typescript
+import { PubSub, RedisPubSub } from '@ooneex/pub-sub';
+
+interface SystemEvent extends Record<string, ScalarType> {
+  service: string;
+  event: string;
+  severity: string;
+}
+
+class SystemMonitorPubSub extends PubSub<SystemEvent> {
+  constructor(
+    client: RedisPubSub,
+    private readonly servicePattern: string
+  ) {
+    super(client);
+  }
+
+  public getChannel(): string {
+    return `system:${this.servicePattern}:events`;
+  }
+
+  public async handler(context: { 
+    data: SystemEvent; 
+    channel: string 
+  }): Promise<void> {
+    const { data, channel } = context;
+    
+    if (data.severity === 'critical') {
+      await this.alertOncall(channel, data);
+    }
+    
+    await this.logToMonitoring(data);
+  }
+}
+
+// Monitor specific services
+const apiMonitor = new SystemMonitorPubSub(new RedisPubSub(), 'api');
+const dbMonitor = new SystemMonitorPubSub(new RedisPubSub(), 'database');
+const cacheMonitor = new SystemMonitorPubSub(new RedisPubSub(), 'cache');
+
+await apiMonitor.subscribe();
+await dbMonitor.subscribe();
+await cacheMonitor.subscribe();
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
+
+### Development Setup
+
+1. Clone the repository
+2. Install dependencies: `bun install`
+3. Run tests: `bun run test`
+4. Build the project: `bun run build`
+
+### Guidelines
+
+- Write tests for new features
+- Follow the existing code style
+- Update documentation for API changes
+- Ensure all tests pass before submitting PR
+
+---
+
+Made with ❤️ by the Ooneex team

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import { EContainerScope } from "@ooneex/container";
+import { ScalarType } from "@ooneex/types";
+type PubSubMessageHandlerType<Data extends Record<string, ScalarType> = Record<string, ScalarType>> = (context: {
+	data: Data;
+	channel: string;
+	key?: string;
+}) => Promise<void> | void;
+type RedisPubSubOptionsType = {
+	connectionString?: string;
+	connectionTimeout?: number;
+	idleTimeout?: number;
+	autoReconnect?: boolean;
+	maxRetries?: number;
+	enableOfflineQueue?: boolean;
+	enableAutoPipelining?: boolean;
+	tls?: boolean | object;
+};
+interface IPubSubClient<Data extends Record<string, ScalarType> = Record<string, ScalarType>> {
+	publish: (config: {
+		channel: string;
+		data: Data;
+		key?: string;
+	}) => Promise<void>;
+	subscribe: (channel: string, handler: PubSubMessageHandlerType<Data>) => Promise<void>;
+	unsubscribe: (channel: string) => Promise<void>;
+	unsubscribeAll: () => Promise<void>;
+}
+interface IPubSub<Data extends Record<string, ScalarType> = Record<string, ScalarType>> {
+	getChannel: () => Promise<string> | string;
+	handler: (context: {
+		data: Data;
+		channel: string;
+		key?: string;
+	}) => Promise<void> | void;
+	publish: (data: Data, key?: string) => Promise<void> | void;
+	subscribe: () => Promise<void> | void;
+	unsubscribe: () => Promise<void> | void;
+	unsubscribeAll: () => Promise<void> | void;
+}
+type PubSubClassType = new (...args: any[]) => IPubSub;
+declare const decorator: {
+	pubSub: (scope?: EContainerScope) => (target: PubSubClassType) => void;
+};
+import { ScalarType as ScalarType2 } from "@ooneex/types";
+declare abstract class PubSub<Data extends Record<string, ScalarType2> = Record<string, ScalarType2>> implements IPubSub<Data> {
+	protected readonly client: IPubSubClient<Data>;
+	constructor(client: IPubSubClient<Data>);
+	abstract handler(context: {
+		data: Data;
+		channel: string;
+		key?: string;
+	}): Promise<void> | void;
+	publish(data: Data, key?: string): Promise<void>;
+	subscribe(): Promise<void>;
+	unsubscribe(): Promise<void>;
+	unsubscribeAll(): Promise<void>;
+}
+import { Exception } from "@ooneex/exception";
+declare class PubSubException extends Exception {
+	constructor(message: string, data?: Record<string, unknown>);
+}
+import { ScalarType as ScalarType3 } from "@ooneex/types";
+declare class RedisPubSubClient<Data extends Record<string, ScalarType3>> implements IPubSubClient<Data> {
+	private client;
+	private subscriber;
+	constructor(options?: RedisPubSubOptionsType);
+	private connect;
+	private connectSubscriber;
+	publish(config: {
+		channel: string;
+		data: Data;
+		key?: string;
+	}): Promise<void>;
+	subscribe(channel: string, handler: PubSubMessageHandlerType<Data>): Promise<void>;
+	unsubscribe(channel: string): Promise<void>;
+	unsubscribeAll(): Promise<void>;
+}
+export { decorator, RedisPubSubOptionsType, RedisPubSubClient as RedisPubSub, PubSubMessageHandlerType, PubSubException, PubSubClassType, PubSub, IPubSubClient, IPubSub };

package/dist/index.js

@@ -0,0 +1,4 @@
+// @bun
+var b=function(e,t,i,n){var o=arguments.length,s=o<3?t:n===null?n=Object.getOwnPropertyDescriptor(t,i):n,a;if(typeof Reflect==="object"&&typeof Reflect.decorate==="function")s=Reflect.decorate(e,t,i,n);else for(var u=e.length-1;u>=0;u--)if(a=e[u])s=(o<3?a(s):o>3?a(t,i,s):a(t,i))||s;return o>3&&s&&Object.defineProperty(t,i,s),s};var l=(e,t)=>{if(typeof Reflect==="object"&&typeof Reflect.metadata==="function")return Reflect.metadata(e,t)};import{container as p,EContainerScope as d}from"@ooneex/container";var m={pubSub:(e=d.Singleton)=>{return(t)=>{p.add(t,e),p.get(t).subscribe()}}};class h{client;constructor(e){this.client=e}async publish(e,t){await this.client.publish({channel:await this.getChannel(),data:e,...t!==void 0&&{key:t}})}async subscribe(){await this.client.subscribe(await this.getChannel(),this.handler.bind(this))}async unsubscribe(){await this.client.unsubscribe(await this.getChannel())}async unsubscribeAll(){await this.client.unsubscribeAll()}}import{Exception as S}from"@ooneex/exception";import{HttpStatus as y}from"@ooneex/http-status";class r extends S{constructor(e,t={}){super(e,{status:y.Code.InternalServerError,data:t});this.name="PubSubException"}}import{injectable as P}from"@ooneex/container";class c{client;subscriber=null;constructor(e={}){let t=e.connectionString||Bun.env.PUBSUB_REDIS_URL;if(!t)throw new r("Redis connection string is required. Please provide a connection string either through the constructor options or set the PUBSUB_REDIS_URL environment variable.");let{connectionString:i,...n}=e,s={...{connectionTimeout:1e4,idleTimeout:30000,autoReconnect:!0,maxRetries:3,enableOfflineQueue:!0,enableAutoPipelining:!0},...n};this.client=new Bun.RedisClient(t,s)}async connect(){if(!this.client.connected)await this.client.connect()}async connectSubscriber(){if(!this.subscriber)this.subscriber=await this.client.duplicate();if(!this.subscriber.connected)await this.subscriber.connect()}async publish(e){try{await this.connect();let t=JSON.stringify(e.data);await this.client.publish(e.channel,t)}catch(t){throw new r(`Failed to publish message to channel "${e.channel}": ${t}`)}finally{this.client.close()}}async subscribe(e,t){try{await this.connectSubscriber(),await this.subscriber?.subscribe(e,(i,n)=>{let o=JSON.parse(i);t({data:o,channel:n})})}catch(i){throw new r(`Failed to subscribe to channel "${e}": ${i}`)}}async unsubscribe(e){try{if(!this.subscriber)return;await this.subscriber.unsubscribe(e)}catch(t){throw new r(`Failed to unsubscribe from channel "${e}": ${t}`)}}async unsubscribeAll(){try{if(!this.subscriber)return;await this.subscriber.unsubscribe()}catch(e){throw new r(`Failed to unsubscribe from all channels: ${e}`)}}}c=b([P(),l("design:paramtypes",[typeof RedisPubSubOptionsType==="undefined"?Object:RedisPubSubOptionsType])],c);export{m as decorator,c as RedisPubSub,r as PubSubException,h as PubSub};
+
+//# debugId=71EA4C698ED7AF9C64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["src/decorators.ts", "src/PubSub.ts", "src/PubSubException.ts", "src/RedisPubSubClient.ts"],
+  "sourcesContent": [
+    "import { container, EContainerScope } from \"@ooneex/container\";\nimport type { IPubSub, PubSubClassType } from \"./types\";\n\nexport const decorator = {\n  pubSub: (scope: EContainerScope = EContainerScope.Singleton) => {\n    return (target: PubSubClassType): void => {\n      container.add(target, scope);\n      const pubsub = container.get<IPubSub>(target);\n      pubsub.subscribe();\n    };\n  },\n};\n",
+    "import type { ScalarType } from \"@ooneex/types\";\nimport type { IPubSub, IPubSubClient } from \"./types\";\n\nexport abstract class PubSub<Data extends Record<string, ScalarType> = Record<string, ScalarType>>\n  implements IPubSub<Data>\n{\n  constructor(protected readonly client: IPubSubClient<Data>) {}\n\n  public abstract getChannel(): string | Promise<string>;\n  public abstract handler(context: { data: Data; channel: string; key?: string }): Promise<void> | void;\n\n  public async publish(data: Data, key?: string): Promise<void> {\n    await this.client.publish({\n      channel: await this.getChannel(),\n      data,\n      ...(key !== undefined && { key }),\n    });\n  }\n\n  public async subscribe(): Promise<void> {\n    await this.client.subscribe(await this.getChannel(), this.handler.bind(this));\n  }\n\n  public async unsubscribe(): Promise<void> {\n    await this.client.unsubscribe(await this.getChannel());\n  }\n\n  public async unsubscribeAll(): Promise<void> {\n    await this.client.unsubscribeAll();\n  }\n}\n",
+    "import { Exception } from \"@ooneex/exception\";\nimport { HttpStatus } from \"@ooneex/http-status\";\n\nexport class PubSubException extends Exception {\n  constructor(message: string, data: Record<string, unknown> = {}) {\n    super(message, {\n      status: HttpStatus.Code.InternalServerError,\n      data,\n    });\n    this.name = \"PubSubException\";\n  }\n}\n",
+    "import { injectable } from \"@ooneex/container\";\nimport type { ScalarType } from \"@ooneex/types\";\nimport { PubSubException } from \"./PubSubException\";\nimport type { IPubSubClient, PubSubMessageHandlerType, RedisPubSubOptionsType } from \"./types\";\n\n@injectable()\nexport class RedisPubSubClient<Data extends Record<string, ScalarType>> implements IPubSubClient<Data> {\n  private client: Bun.RedisClient;\n  private subscriber: Bun.RedisClient | null = null;\n\n  constructor(options: RedisPubSubOptionsType = {}) {\n    const connectionString = options.connectionString || Bun.env.PUBSUB_REDIS_URL;\n\n    if (!connectionString) {\n      throw new PubSubException(\n        \"Redis connection string is required. Please provide a connection string either through the constructor options or set the PUBSUB_REDIS_URL environment variable.\",\n      );\n    }\n\n    const { connectionString: _, ...userOptions } = options;\n\n    const defaultOptions = {\n      connectionTimeout: 10_000,\n      idleTimeout: 30_000,\n      autoReconnect: true,\n      maxRetries: 3,\n      enableOfflineQueue: true,\n      enableAutoPipelining: true,\n    };\n\n    const clientOptions = { ...defaultOptions, ...userOptions };\n\n    this.client = new Bun.RedisClient(connectionString, clientOptions);\n  }\n\n  private async connect(): Promise<void> {\n    if (!this.client.connected) {\n      await this.client.connect();\n    }\n  }\n\n  private async connectSubscriber(): Promise<void> {\n    if (!this.subscriber) {\n      this.subscriber = await this.client.duplicate();\n    }\n\n    if (!this.subscriber.connected) {\n      await this.subscriber.connect();\n    }\n  }\n\n  public async publish(config: { channel: string; data: Data; key?: string }): Promise<void> {\n    try {\n      await this.connect();\n      const message = JSON.stringify(config.data);\n      await this.client.publish(config.channel, message);\n    } catch (error) {\n      throw new PubSubException(`Failed to publish message to channel \"${config.channel}\": ${error}`);\n    } finally {\n      this.client.close();\n    }\n  }\n\n  public async subscribe(channel: string, handler: PubSubMessageHandlerType<Data>): Promise<void> {\n    try {\n      await this.connectSubscriber();\n      await this.subscriber?.subscribe(channel, (message: string, ch: string) => {\n        const data = JSON.parse(message) as Data;\n        handler({ data, channel: ch });\n      });\n    } catch (error) {\n      throw new PubSubException(`Failed to subscribe to channel \"${channel}\": ${error}`);\n    }\n  }\n\n  public async unsubscribe(channel: string): Promise<void> {\n    try {\n      if (!this.subscriber) {\n        return;\n      }\n\n      await this.subscriber.unsubscribe(channel);\n    } catch (error) {\n      throw new PubSubException(`Failed to unsubscribe from channel \"${channel}\": ${error}`);\n    }\n  }\n\n  public async unsubscribeAll(): Promise<void> {\n    try {\n      if (!this.subscriber) {\n        return;\n      }\n\n      await this.subscriber.unsubscribe();\n    } catch (error) {\n      throw new PubSubException(`Failed to unsubscribe from all channels: ${error}`);\n    }\n  }\n}\n"
+  ],
+  "mappings": ";ybAAA,oBAAS,qBAAW,0BAGb,IAAM,EAAY,CACvB,OAAQ,CAAC,EAAyB,EAAgB,YAAc,CAC9D,MAAO,CAAC,IAAkC,CACxC,EAAU,IAAI,EAAQ,CAAK,EACZ,EAAU,IAAa,CAAM,EACrC,UAAU,GAGvB,ECRO,MAAe,CAEtB,CACiC,OAA/B,WAAW,CAAoB,EAA6B,CAA7B,mBAKlB,QAAO,CAAC,EAAY,EAA6B,CAC5D,MAAM,KAAK,OAAO,QAAQ,CACxB,QAAS,MAAM,KAAK,WAAW,EAC/B,UACI,IAAQ,QAAa,CAAE,KAAI,CACjC,CAAC,OAGU,UAAS,EAAkB,CACtC,MAAM,KAAK,OAAO,UAAU,MAAM,KAAK,WAAW,EAAG,KAAK,QAAQ,KAAK,IAAI,CAAC,OAGjE,YAAW,EAAkB,CACxC,MAAM,KAAK,OAAO,YAAY,MAAM,KAAK,WAAW,CAAC,OAG1C,eAAc,EAAkB,CAC3C,MAAM,KAAK,OAAO,eAAe,EAErC,CC9BA,oBAAS,0BACT,qBAAS,4BAEF,MAAM,UAAwB,CAAU,CAC7C,WAAW,CAAC,EAAiB,EAAgC,CAAC,EAAG,CAC/D,MAAM,EAAS,CACb,OAAQ,EAAW,KAAK,oBACxB,MACF,CAAC,EACD,KAAK,KAAO,kBAEhB,CCXA,qBAAS,0BAMF,MAAM,CAA0F,CAC7F,OACA,WAAqC,KAE7C,WAAW,CAAC,EAAkC,CAAC,EAAG,CAChD,IAAM,EAAmB,EAAQ,kBAAoB,IAAI,IAAI,iBAE7D,GAAI,CAAC,EACH,MAAM,IAAI,EACR,kKACF,EAGF,IAAQ,iBAAkB,KAAM,GAAgB,EAW1C,EAAgB,IATC,CACrB,kBAAmB,IACnB,YAAa,MACb,cAAe,GACf,WAAY,EACZ,mBAAoB,GACpB,qBAAsB,EACxB,KAE8C,CAAY,EAE1D,KAAK,OAAS,IAAI,IAAI,YAAY,EAAkB,CAAa,OAGrD,QAAO,EAAkB,CACrC,GAAI,CAAC,KAAK,OAAO,UACf,MAAM,KAAK,OAAO,QAAQ,OAIhB,kBAAiB,EAAkB,CAC/C,GAAI,CAAC,KAAK,WACR,KAAK,WAAa,MAAM,KAAK,OAAO,UAAU,EAGhD,GAAI,CAAC,KAAK,WAAW,UACnB,MAAM,KAAK,WAAW,QAAQ,OAIrB,QAAO,CAAC,EAAsE,CACzF,GAAI,CACF,MAAM,KAAK,QAAQ,EACnB,IAAM,EAAU,KAAK,UAAU,EAAO,IAAI,EAC1C,MAAM,KAAK,OAAO,QAAQ,EAAO,QAAS,CAAO,EACjD,MAAO,EAAO,CACd,MAAM,IAAI,EAAgB,yCAAyC,EAAO,aAAa,GAAO,SAC9F,CACA,KAAK,OAAO,MAAM,QAIT,UAAS,CAAC,EAAiB,EAAwD,CAC9F,GAAI,CACF,MAAM,KAAK,kBAAkB,EAC7B,MAAM,KAAK,YAAY,UAAU,EAAS,CAAC,EAAiB,IAAe,CACzE,IAAM,EAAO,KAAK,MAAM,CAAO,EAC/B,EAAQ,CAAE,OAAM,QAAS,CAAG,CAAC,EAC9B,EACD,MAAO,EAAO,CACd,MAAM,IAAI,EAAgB,mCAAmC,OAAa,GAAO,QAIxE,YAAW,CAAC,EAAgC,CACvD,GAAI,CACF,GAAI,CAAC,KAAK,WACR,OAGF,MAAM,KAAK,WAAW,YAAY,CAAO,EACzC,MAAO,EAAO,CACd,MAAM,IAAI,EAAgB,uCAAuC,OAAa,GAAO,QAI5E,eAAc,EAAkB,CAC3C,GAAI,CACF,GAAI,CAAC,KAAK,WACR,OAGF,MAAM,KAAK,WAAW,YAAY,EAClC,MAAO,EAAO,CACd,MAAM,IAAI,EAAgB,4CAA4C,GAAO,GAGnF,CA5Fa,EAAN,GADN,EAAW,EACL,oGAAM",
+  "debugId": "71EA4C698ED7AF9C64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@ooneex/pub-sub",
+  "description": "Publish-subscribe messaging pattern implementation for event-driven communication between application components",
+  "version": "0.0.4",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "package.json"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "bunup",
+    "lint": "tsgo --noEmit && bunx biome lint",
+    "publish": "bun publish --access public || true",
+    "test": "bun test tests"
+  },
+  "dependencies": {
+    "@ooneex/container": "0.0.2",
+    "@ooneex/exception": "0.0.1",
+    "@ooneex/http-status": "0.0.1"
+  },
+  "devDependencies": {
+    "@ooneex/types": "0.0.1"
+  },
+  "keywords": [
+    "bun",
+    "events",
+    "messaging",
+    "ooneex",
+    "pub-sub",
+    "pubsub",
+    "typescript"
+  ]
+}