wexa-chat 0.1.21 → 0.1.22

package/README.md

@@ -286,9 +286,97 @@ You can also send:
 ```ts
 send({ type: 'leave-conversation', conversationId });
 send({ type: 'typing', conversationId, isTyping: true });
+
+// New: User-based subscriptions
+send({ type: 'subscribe-to-user', userId: 'user-123' });
+send({ type: 'unsubscribe-from-user', userId: 'user-123' });
 ```
 
-## Events (server → client)
+## User-Based Subscriptions
+
+The chat core now supports subscribing to all messages for a specific user, allowing you to receive messages from all conversations involving that user without needing to join each conversation individually.
+
+### Server-Side Usage
+
+The transport layer exposes new methods for user-based subscriptions:
+
+```ts
+// Access the transport from your chat instance
+const { transport } = await getChatInstance();
+
+// Subscribe a socket to all messages for a user
+transport.subscribeToUser(userId, socketId);
+
+// Unsubscribe a socket from a user's messages
+transport.unsubscribeFromUser(userId, socketId);
+
+// Check if a socket is subscribed to a user
+const isSubscribed = transport.isSubscribedToUser(userId, socketId);
+
+// Fan out a message to all subscribers of a user
+transport.fanoutToUser(userId, payload, (toSocketId, event) => {
+  // Your emit logic here
+});
+```
+
+### Client-Side Usage
+
+Subscribe to all messages for a user:
+
+```tsx
+import { useEffect } from 'react';
+import { useSocket } from 'wexa-chat/client';
+
+export function GlobalMessageListener({ userId }: { userId: string }) {
+  const { isConnected, send, onEvent } = useSocket();
+
+  // Subscribe to user messages
+  useEffect(() => {
+    if (isConnected && userId) {
+      send({ type: 'subscribe-to-user', userId });
+    }
+    
+    return () => {
+      if (isConnected && userId) {
+        send({ type: 'unsubscribe-from-user', userId });
+      }
+    };
+  }, [isConnected, userId, send]);
+
+  // Listen for messages
+  useEffect(() => {
+    const off = onEvent((event) => {
+      if (event.type === 'message:created') {
+        // Handle message from any conversation involving the subscribed user
+        console.log('New message:', event.message);
+      }
+    });
+    
+    return off;
+  }, [onEvent]);
+
+  return null; // This component just listens for messages
+}
+```
+
+### Use Cases
+
+- **Global notifications**: Receive notifications for all messages involving a user
+- **Unread message tracking**: Track unread messages across all conversations
+- **Real-time updates**: Keep conversation lists updated without joining each conversation
+- **Background message sync**: Sync messages even when not actively viewing conversations
+
+## Events
+
+### Client → Server
+
+- `join-conversation` — `{ type: 'join-conversation', conversationId }`
+- `leave-conversation` — `{ type: 'leave-conversation', conversationId }`
+- `typing` — `{ type: 'typing', conversationId, isTyping: boolean }`
+- `subscribe-to-user` — `{ type: 'subscribe-to-user', userId }` *(New)*
+- `unsubscribe-from-user` — `{ type: 'unsubscribe-from-user', userId }` *(New)*
+
+### Server → Client
 
 - `message:created` — `{ type: 'message:created', message }`
 - `conversation:read` — `{ type: 'conversation:read', conversationId, messageId, participantModel, participantId, at }`

package/dist/index.d.cts

@@ -315,7 +315,7 @@ declare function createMessagesService(models: {
 }, hooks?: MessageServiceHooks): MessagesService;
 
 /**
- * In-memory subscription maps for conversations and sockets
+ * In-memory subscription maps for conversations, users, and sockets
  */
 /**
  * Subscribe a socket to a conversation
@@ -341,6 +341,36 @@ declare function cleanupLocal(socketId: string): void;
  * @param emitter Function to emit events to socket IDs
  */
 declare function fanoutLocal(conversationId: string, payload: any, emitter: (toSocketId: string, event: any) => void): void;
+/**
+ * Subscribe a socket to all messages for a user
+ * @param userId The user ID to subscribe to
+ * @param socketId The socket ID to subscribe
+ */
+declare function subscribeToUser(userId: string, socketId: string): void;
+/**
+ * Unsubscribe a socket from a user's messages
+ * @param userId The user ID to unsubscribe from
+ * @param socketId The socket ID to unsubscribe
+ */
+declare function unsubscribeFromUser(userId: string, socketId: string): void;
+/**
+ * Check if a socket is subscribed to a user
+ * @param userId The user ID to check
+ * @param socketId The socket ID to check
+ */
+declare function isSubscribedToUser(userId: string, socketId: string): boolean;
+/**
+ * Get all sockets subscribed to a user
+ * @param userId The user ID
+ */
+declare function getSocketsForUser(userId: string): Set<string>;
+/**
+ * Fan out a message to all local subscribers of a user
+ * @param userId The user ID to fan out to
+ * @param payload The payload to send
+ * @param emitter Function to emit events to socket IDs
+ */
+declare function fanoutToUser(userId: string, payload: any, emitter: (toSocketId: string, event: any) => void): void;
 
 interface SocketConfig {
     path?: string;
@@ -355,6 +385,7 @@ declare class SocketTransport {
     private sockets;
     private users;
     private joinedConversations;
+    private subscribedToUsers;
     private authenticate?;
     private ioShim;
     constructor(server: Server, transport: Transport, config?: SocketConfig);
@@ -391,6 +422,11 @@ interface Transport {
     unsubscribeLocal: typeof unsubscribeLocal;
     cleanupLocal: typeof cleanupLocal;
     fanoutLocal: typeof fanoutLocal;
+    subscribeToUser: typeof subscribeToUser;
+    unsubscribeFromUser: typeof unsubscribeFromUser;
+    isSubscribedToUser: typeof isSubscribedToUser;
+    getSocketsForUser: typeof getSocketsForUser;
+    fanoutToUser: typeof fanoutToUser;
     publishToConversation: (conversationId: string, payload: any) => Promise<number>;
     startRedisListener: (onEvent: (conversationId: string, payload: any) => void) => (() => void) | null;
 }

package/dist/index.d.ts

@@ -315,7 +315,7 @@ declare function createMessagesService(models: {
 }, hooks?: MessageServiceHooks): MessagesService;
 
 /**
- * In-memory subscription maps for conversations and sockets
+ * In-memory subscription maps for conversations, users, and sockets
  */
 /**
  * Subscribe a socket to a conversation
@@ -341,6 +341,36 @@ declare function cleanupLocal(socketId: string): void;
  * @param emitter Function to emit events to socket IDs
  */
 declare function fanoutLocal(conversationId: string, payload: any, emitter: (toSocketId: string, event: any) => void): void;
+/**
+ * Subscribe a socket to all messages for a user
+ * @param userId The user ID to subscribe to
+ * @param socketId The socket ID to subscribe
+ */
+declare function subscribeToUser(userId: string, socketId: string): void;
+/**
+ * Unsubscribe a socket from a user's messages
+ * @param userId The user ID to unsubscribe from
+ * @param socketId The socket ID to unsubscribe
+ */
+declare function unsubscribeFromUser(userId: string, socketId: string): void;
+/**
+ * Check if a socket is subscribed to a user
+ * @param userId The user ID to check
+ * @param socketId The socket ID to check
+ */
+declare function isSubscribedToUser(userId: string, socketId: string): boolean;
+/**
+ * Get all sockets subscribed to a user
+ * @param userId The user ID
+ */
+declare function getSocketsForUser(userId: string): Set<string>;
+/**
+ * Fan out a message to all local subscribers of a user
+ * @param userId The user ID to fan out to
+ * @param payload The payload to send
+ * @param emitter Function to emit events to socket IDs
+ */
+declare function fanoutToUser(userId: string, payload: any, emitter: (toSocketId: string, event: any) => void): void;
 
 interface SocketConfig {
     path?: string;
@@ -355,6 +385,7 @@ declare class SocketTransport {
     private sockets;
     private users;
     private joinedConversations;
+    private subscribedToUsers;
     private authenticate?;
     private ioShim;
     constructor(server: Server, transport: Transport, config?: SocketConfig);
@@ -391,6 +422,11 @@ interface Transport {
     unsubscribeLocal: typeof unsubscribeLocal;
     cleanupLocal: typeof cleanupLocal;
     fanoutLocal: typeof fanoutLocal;
+    subscribeToUser: typeof subscribeToUser;
+    unsubscribeFromUser: typeof unsubscribeFromUser;
+    isSubscribedToUser: typeof isSubscribedToUser;
+    getSocketsForUser: typeof getSocketsForUser;
+    fanoutToUser: typeof fanoutToUser;
     publishToConversation: (conversationId: string, payload: any) => Promise<number>;
     startRedisListener: (onEvent: (conversationId: string, payload: any) => void) => (() => void) | null;
 }

package/dist/index.js

@@ -665,6 +665,8 @@ function createMessagesService(models, hooks = {}) {
 // src/transport/localSubs.ts
 var convSubs = /* @__PURE__ */ new Map();
 var socketSubs = /* @__PURE__ */ new Map();
+var userSubs = /* @__PURE__ */ new Map();
+var socketUserSubs = /* @__PURE__ */ new Map();
 function subscribeLocal(conversationId, socketId) {
   var _a, _b;
   if (!convSubs.has(conversationId)) {
@@ -706,6 +708,19 @@ function cleanupLocal(socketId) {
     }
     socketSubs.delete(socketId);
   }
+  const users = socketUserSubs.get(socketId);
+  if (users) {
+    for (const userId of users) {
+      const sockets = userSubs.get(userId);
+      if (sockets) {
+        sockets.delete(socketId);
+        if (sockets.size === 0) {
+          userSubs.delete(userId);
+        }
+      }
+    }
+    socketUserSubs.delete(socketId);
+  }
 }
 function fanoutLocal(conversationId, payload, emitter) {
   const sockets = convSubs.get(conversationId);
@@ -719,6 +734,52 @@ function fanoutLocal(conversationId, payload, emitter) {
     }
   }
 }
+function subscribeToUser(userId, socketId) {
+  var _a, _b;
+  if (!userSubs.has(userId)) {
+    userSubs.set(userId, /* @__PURE__ */ new Set());
+  }
+  (_a = userSubs.get(userId)) == null ? void 0 : _a.add(socketId);
+  if (!socketUserSubs.has(socketId)) {
+    socketUserSubs.set(socketId, /* @__PURE__ */ new Set());
+  }
+  (_b = socketUserSubs.get(socketId)) == null ? void 0 : _b.add(userId);
+}
+function unsubscribeFromUser(userId, socketId) {
+  const sockets = userSubs.get(userId);
+  if (sockets) {
+    sockets.delete(socketId);
+    if (sockets.size === 0) {
+      userSubs.delete(userId);
+    }
+  }
+  const users = socketUserSubs.get(socketId);
+  if (users) {
+    users.delete(userId);
+    if (users.size === 0) {
+      socketUserSubs.delete(socketId);
+    }
+  }
+}
+function isSubscribedToUser(userId, socketId) {
+  var _a;
+  return ((_a = socketUserSubs.get(socketId)) == null ? void 0 : _a.has(userId)) || false;
+}
+function getSocketsForUser(userId) {
+  return userSubs.get(userId) || /* @__PURE__ */ new Set();
+}
+function fanoutToUser(userId, payload, emitter) {
+  const sockets = userSubs.get(userId);
+  if (sockets) {
+    for (const socketId of sockets) {
+      try {
+        emitter(socketId, payload);
+      } catch (error) {
+        console.error(`Error emitting to socket ${socketId}:`, error);
+      }
+    }
+  }
+}
 var SHARED_CLIENT = null;
 var SHARED_CFG_FINGERPRINT = null;
 function createRedisClient(config) {
@@ -815,6 +876,8 @@ var SocketTransport = class {
     this.sockets = /* @__PURE__ */ new Map();
     this.users = /* @__PURE__ */ new Map();
     this.joinedConversations = /* @__PURE__ */ new Map();
+    // socketId -> convIds
+    this.subscribedToUsers = /* @__PURE__ */ new Map();
     // Socket.IO-like shim for getIO().sockets.sockets.get(id).emit('chat-event', payload)
     this.ioShim = {
       sockets: {
@@ -924,6 +987,7 @@ var SocketTransport = class {
         this.joinedConversations.set(socketId, /* @__PURE__ */ new Set());
         syncShim();
         ws$1.on("message", (raw) => {
+          var _a;
           try {
             const msg = JSON.parse(raw.toString());
             const type = msg == null ? void 0 : msg.type;
@@ -994,6 +1058,17 @@ var SocketTransport = class {
                 }
               });
               this.transport.publishToConversation(convId, payload);
+            } else if (type === "subscribe-to-user" && typeof msg.userId === "string") {
+              const userId2 = msg.userId;
+              this.transport.subscribeToUser(userId2, socketId);
+              if (!this.subscribedToUsers.has(socketId)) {
+                this.subscribedToUsers.set(socketId, /* @__PURE__ */ new Set());
+              }
+              this.subscribedToUsers.get(socketId).add(userId2);
+            } else if (type === "unsubscribe-from-user" && typeof msg.userId === "string") {
+              const userId2 = msg.userId;
+              this.transport.unsubscribeFromUser(userId2, socketId);
+              (_a = this.subscribedToUsers.get(socketId)) == null ? void 0 : _a.delete(userId2);
             }
           } catch {
           }
@@ -1022,6 +1097,13 @@ var SocketTransport = class {
               });
             }
           }
+          const subscribedUsers = this.subscribedToUsers.get(socketId);
+          if (subscribedUsers) {
+            for (const userId2 of subscribedUsers) {
+              this.transport.unsubscribeFromUser(userId2, socketId);
+            }
+            this.subscribedToUsers.delete(socketId);
+          }
           this.transport.cleanupLocal(socketId);
           this.sockets.delete(socketId);
           this.users.delete(socketId);
@@ -1086,6 +1168,12 @@ function createTransport(config, server) {
     unsubscribeLocal,
     cleanupLocal,
     fanoutLocal,
+    // User subscription methods
+    subscribeToUser,
+    unsubscribeFromUser,
+    isSubscribedToUser,
+    getSocketsForUser,
+    fanoutToUser,
     // Redis methods
     publishToConversation: (conversationId, payload) => publishToConversation(redisClient, conversationId, payload),
     startRedisListener: (onEvent) => startRedisListener(redisClient, onEvent)