@wix/realtime 1.0.46 → 1.0.47

package/es/build/index.d.ts

@@ -1,7 +1,7 @@
 export * as site from '@wix/sdk_realtime_site';
 export * as publisher from './publisher/publisher.context.js';
 export * as subscriber from './subscriber/subscriber.context.js';
-import type { Channel, Message, MessageHandler, Publisher, SubscriptionErrorHandler, SubscriptionHandler, SubscriptionOptions, UnsubscribeOptions } from './types.js';
+import type { PublishChannel, SubscribeChannel, Message, MessageHandler, Publisher, SubscriptionErrorHandler, SubscriptionHandler, SubscriptionOptions, UnsubscribeOptions } from './types.js';
 import { RealtimeError, RealtimeErrorCode } from './types.js';
-export type { Channel, Message, MessageHandler, Publisher, SubscriptionErrorHandler, SubscriptionHandler, SubscriptionOptions, UnsubscribeOptions, };
+export type { PublishChannel, SubscribeChannel, Message, MessageHandler, Publisher, SubscriptionErrorHandler, SubscriptionHandler, SubscriptionOptions, UnsubscribeOptions, };
 export { RealtimeError, RealtimeErrorCode };

package/es/build/publisher/publisher.public.d.ts

@@ -1,7 +1,7 @@
-import type { Channel } from '@wix/realtime-common/types';
+import type { PublishChannel } from '@wix/realtime-common/types';
 import type { HttpClient } from '@wix/sdk-types';
 interface PublishSignature {
-    (channel: Channel, payload: Record<string, any>): Promise<void>;
+    (channel: PublishChannel, payload: Record<string, any>): Promise<void>;
 }
 /**
  * Publish a message to a channel.

package/es/build/subscriber/errors.d.ts

@@ -1,16 +1,19 @@
-import { RealtimeError, type Channel } from '@wix/realtime-common/types';
+import { RealtimeError, type PublishChannel, type Channel, type SubscribeChannel } from '@wix/realtime-common/types';
 export declare function missingChannelOrSubscriptionId(): RealtimeError;
 export declare function channelMismatch(): RealtimeError;
+export declare function channelAppIdMismatch(passedAppId: string, subscribedAppId: string): RealtimeError;
+export declare function unsubscribeRequiresAppId(channel: PublishChannel, crossAppIds: string[]): RealtimeError;
+export declare function unknownChannelAppId(channel: SubscribeChannel, existingAppIds: string[]): RealtimeError;
 export declare function invalidChannel(channel: Channel): RealtimeError;
 export declare function validateChannel(channel: Channel): void;
 export declare function disconnectedError(recoverable?: boolean, message?: string): RealtimeError;
 export declare function connectError(recoverable?: boolean, message?: string): RealtimeError;
-export declare function subscribeFailed(channel: Channel, payload?: {
+export declare function subscribeFailed(channel: SubscribeChannel, payload?: {
     status?: number;
     message?: string;
 }): RealtimeError;
-export declare function resubscribeFailed(channel: Channel, payload?: {
+export declare function resubscribeFailed(channel: SubscribeChannel, payload?: {
     status?: number;
     message?: string;
 }): RealtimeError;
-export declare function subscribeError(error: unknown, channel: Channel): RealtimeError;
+export declare function subscribeError(error: unknown, channel: SubscribeChannel): RealtimeError;

package/es/build/subscriber/errors.js

@@ -1,11 +1,31 @@
 import { RealtimeError, RealtimeErrorCode, } from '@wix/realtime-common/types';
+import { CHANNEL_NAME_MAX_LENGTH, CHANNEL_NAME_PATTERN, } from '@wix/realtime-common';
 export function missingChannelOrSubscriptionId() {
     return new RealtimeError(RealtimeErrorCode.BadInput, 'channel or subscriptionId is required');
 }
 export function channelMismatch() {
     return new RealtimeError(RealtimeErrorCode.BadInput, 'channel does not match subscriptionId');
 }
-import { CHANNEL_NAME_MAX_LENGTH, CHANNEL_NAME_PATTERN, } from '@wix/realtime-common';
+export function channelAppIdMismatch(passedAppId, subscribedAppId) {
+    return new RealtimeError(RealtimeErrorCode.BadInput, `channel.appId "${passedAppId}" does not match subscription (subscribed with appId "${subscribedAppId}")`);
+}
+export function unsubscribeRequiresAppId(channel, crossAppIds) {
+    const target = channel.resourceId
+        ? `"${channel.name}" / "${channel.resourceId}"`
+        : `"${channel.name}"`;
+    return new RealtimeError(RealtimeErrorCode.BadInput, `Unsubscribe on ${target} requires channel.appId because the matching subscription(s) were opened cross-app to ${crossAppIds
+        .map((id) => `"${id}"`)
+        .join(', ')}. Pass channel.appId to scope the removal.`);
+}
+export function unknownChannelAppId(channel, existingAppIds) {
+    const target = channel.resourceId
+        ? `"${channel.name}" / "${channel.resourceId}"`
+        : `"${channel.name}"`;
+    const knownAppIds = existingAppIds.length
+        ? existingAppIds.map((id) => `"${id}"`).join(', ')
+        : '(none)';
+    return new RealtimeError(RealtimeErrorCode.BadInput, `No subscription on ${target} matches channel.appId "${channel.appId}". Existing subscriptions on this channel are scoped to ${knownAppIds}.`);
+}
 export function invalidChannel(channel) {
     const { name, resourceId } = channel;
     const reasons = [];

package/es/build/subscriber/subscriber.public.d.ts

@@ -1,7 +1,7 @@
-import { type Channel, type MessageHandler, type SubscriptionOptions, type UnsubscribeOptions } from '@wix/realtime-common/types';
+import { type SubscribeChannel, type MessageHandler, type SubscriptionOptions, type UnsubscribeOptions } from '@wix/realtime-common/types';
 import type { HttpClient } from '@wix/sdk-types';
 interface SubscribeSignature {
-    (channel: Channel, messageHandler: MessageHandler, options?: SubscriptionOptions): string;
+    (channel: SubscribeChannel, messageHandler: MessageHandler, options?: SubscriptionOptions): string;
 }
 export declare function subscribe(httpClient: HttpClient): SubscribeSignature;
 interface UnsubscribeSignature {

package/es/build/subscriber/subscriber.public.js

@@ -3,8 +3,11 @@ import { DUPLEXER_EVENTS, MESSAGE_EVENT_NAME, getAppInfoFromAuthToken, tokenToAp
 import { v4 as uuidv4 } from 'uuid';
 import { resolveDuplexerChannelName } from '../channel-utils.js';
 import { DUPLEXER_HOST_URL } from '../constants.js';
-import { missingChannelOrSubscriptionId, channelMismatch, disconnectedError, connectError, subscribeFailed, resubscribeFailed, subscribeError, validateChannel, } from './errors.js';
+import { missingChannelOrSubscriptionId, channelMismatch, channelAppIdMismatch, unsubscribeRequiresAppId, unknownChannelAppId, disconnectedError, connectError, subscribeFailed, resubscribeFailed, subscribeError, validateChannel, } from './errors.js';
 import { SubscriptionManager } from './subscription-manager.js';
+function socketKey(socketAppId, siteId) {
+    return `${socketAppId}:${siteId}`;
+}
 const instanceConnections = new Map();
 const subscriptionManager = new SubscriptionManager();
 export function subscribe(httpClient) {
@@ -14,6 +17,8 @@ export function subscribe(httpClient) {
         subscriptionManager.set(subscriptionId, {
             channelName: channel.name,
             channelResourceId: channel.resourceId,
+            maybeCrossAppId: channel.appId,
+            socketAppId: channel.appId,
             removeListeners: () => { },
             onSubscribed: options?.onSubscribed,
             onSubscriptionError: options?.onSubscriptionError,
@@ -50,57 +55,92 @@ function unsubscribeById(subscriptionId, channel) {
     if (!subscription) {
         return;
     }
-    if (channel &&
-        (channel.name !== subscription.channelName ||
-            channel.resourceId !== subscription.channelResourceId)) {
-        throw channelMismatch();
+    if (channel) {
+        const channelNameMismatch = channel.name !== undefined && channel.name !== subscription.channelName;
+        const channelResourceIdMismatch = channel.resourceId !== undefined &&
+            channel.resourceId !== subscription.channelResourceId;
+        if (channelNameMismatch || channelResourceIdMismatch) {
+            throw channelMismatch();
+        }
+        const appIdMismatch = channel.appId !== undefined &&
+            subscription.socketAppId !== undefined &&
+            channel.appId !== subscription.socketAppId;
+        if (appIdMismatch) {
+            throw channelAppIdMismatch(channel.appId, subscription.socketAppId);
+        }
     }
     subscription.removeListeners();
-    const { channelName, channelResourceId, instanceId, channelEmitter } = subscription;
-    // If subscription is still pending (no channelEmitter/instanceId), mark
-    // cancelled so the in-flight setupSubscription knows to bail out.
-    if (!channelEmitter || !instanceId) {
+    const { channelName, channelResourceId, socketAppId, siteId, channelEmitter, } = subscription;
+    if (!channelEmitter || !socketAppId || !siteId) {
         subscription.cancelled = true;
         subscriptionManager.delete(subscriptionId);
-        if (instanceId) {
-            cleanupConnectionIfIdle(instanceId);
+        if (socketAppId && siteId) {
+            cleanupConnectionIfIdle(socketAppId, siteId);
         }
         return;
     }
     // If no other subscriptions remain on this channel, fire-and-forget
     // the duplexer unsubscribe.
-    const hasOtherSubscriptionsOnChannel = subscriptionManager.deleteAndStillHasRemainingOnChannel(instanceId, subscriptionId, channelName, channelResourceId);
+    const hasOtherSubscriptionsOnChannel = subscriptionManager.deleteAndStillHasRemainingOnChannel(socketAppId, siteId, subscriptionId, channelName, channelResourceId);
     if (!hasOtherSubscriptionsOnChannel) {
-        const conn = instanceConnections.get(instanceId);
+        const conn = instanceConnections.get(socketKey(socketAppId, siteId));
         if (conn) {
             conn.socket.unsubscribe(channelName, channelResourceId);
         }
     }
-    cleanupConnectionIfIdle(instanceId);
+    cleanupConnectionIfIdle(socketAppId, siteId);
+}
+function distinctDefined(items, pickItemFunction) {
+    const out = new Set();
+    for (const item of items) {
+        const v = pickItemFunction(item);
+        if (v !== undefined)
+            out.add(v);
+    }
+    return [...out];
 }
 function unsubscribeByChannel(channel) {
-    const entriesToRemove = subscriptionManager.findByChannel(channel.name, channel.resourceId);
-    for (const [id] of entriesToRemove) {
-        unsubscribeById(id);
+    const matches = subscriptionManager.findByChannel(channel.name, channel.resourceId);
+    if (matches.length === 0) {
+        return;
     }
+    if (channel.appId === undefined) {
+        const sameAppMatches = matches.filter(([, sub]) => sub.maybeCrossAppId === undefined);
+        if (sameAppMatches.length === 0) {
+            const crossAppIds = distinctDefined(matches, ([, sub]) => sub.maybeCrossAppId);
+            throw unsubscribeRequiresAppId(channel, crossAppIds);
+        }
+        for (const [id] of sameAppMatches)
+            unsubscribeById(id);
+        return;
+    }
+    // appId passed: scope to subs whose socket lives in that namespace.
+    const scoped = matches.filter(([, sub]) => sub.socketAppId === channel.appId);
+    if (scoped.length === 0) {
+        const existingAppIds = distinctDefined(matches, ([, sub]) => sub.socketAppId);
+        throw unknownChannelAppId(channel, existingAppIds);
+    }
+    for (const [id] of scoped)
+        unsubscribeById(id);
 }
-function closeConnection(instanceId) {
-    const conn = instanceConnections.get(instanceId);
+function closeConnection(socketAppId, siteId) {
+    const key = socketKey(socketAppId, siteId);
+    const conn = instanceConnections.get(key);
     if (conn) {
         conn.socket.removeAllListeners();
         conn.socket.disconnect();
         conn.duplexer.close();
-        instanceConnections.delete(instanceId);
+        instanceConnections.delete(key);
     }
 }
-/** Clean up the connection for an instanceId if it has no remaining subscriptions. */
-function cleanupConnectionIfIdle(instanceId) {
-    if (!subscriptionManager.hasSubscriptionsForInstanceId(instanceId)) {
-        closeConnection(instanceId);
+function cleanupConnectionIfIdle(socketAppId, siteId) {
+    if (!subscriptionManager.hasSubscriptionsForSocket(socketAppId, siteId)) {
+        closeConnection(socketAppId, siteId);
     }
 }
-function getOrCreateConnection(httpClient, appId, instanceId) {
-    const existing = instanceConnections.get(instanceId);
+function getOrCreateConnection(httpClient, socketAppId, siteId) {
+    const key = socketKey(socketAppId, siteId);
+    const existing = instanceConnections.get(key);
     if (existing) {
         return existing;
     }
@@ -110,10 +150,10 @@ function getOrCreateConnection(httpClient, appId, instanceId) {
         },
     });
     const socket = duplexer.connect({
-        appDefId: appId,
+        appDefId: socketAppId,
     });
     const notifySubscriptionError = (realtimeError) => {
-        for (const subId of subscriptionManager.getSubscriptionIdsByInstanceId(instanceId)) {
+        for (const subId of subscriptionManager.getSubscriptionIdsBySocket(socketAppId, siteId)) {
             subscriptionManager
                 .get(subId)
                 ?.onSubscriptionError?.(realtimeError, subId);
@@ -126,15 +166,21 @@ function getOrCreateConnection(httpClient, appId, instanceId) {
         notifySubscriptionError(connectError(error?.recoverable, error?.message));
     });
     const connection = { duplexer, socket };
-    instanceConnections.set(instanceId, connection);
+    instanceConnections.set(key, connection);
     return connection;
 }
 async function setupSubscription(httpClient, subscriptionId, channel, messageHandler) {
     try {
-        const [{ appId, instanceId }, duplexerChannelName] = await Promise.all([
+        const [{ appId: callerAppId, siteId }, duplexerChannelName] = await Promise.all([
             getAppInfoFromAuthToken(httpClient),
             resolveDuplexerChannelName(channel),
         ]);
+        const socketAppId = channel.appId ?? callerAppId;
+        const maybeCrossAppId = channel.appId === callerAppId ? undefined : channel.appId;
+        channel = {
+            ...channel,
+            appId: socketAppId,
+        };
         const subscriptionEntry = subscriptionManager.get(subscriptionId);
         // Entry was already deleted (e.g., unsubscribe called during the await)
         // or explicitly cancelled — bail out.
@@ -142,13 +188,13 @@ async function setupSubscription(httpClient, subscriptionId, channel, messageHan
             subscriptionManager.delete(subscriptionId);
             return;
         }
-        // Index the subscription by instanceId now so cleanupConnectionIfIdle
-        // correctly counts it while the duplexer subscription is being set up.
         subscriptionManager.set(subscriptionId, {
             ...subscriptionEntry,
-            instanceId,
+            maybeCrossAppId,
+            socketAppId,
+            siteId,
         });
-        const { socket } = getOrCreateConnection(httpClient, appId, instanceId);
+        const { socket } = getOrCreateConnection(httpClient, socketAppId, siteId);
         const onMessageCallback = (payload, { publisher }) => {
             messageHandler({
                 payload,
@@ -163,7 +209,7 @@ async function setupSubscription(httpClient, subscriptionId, channel, messageHan
             // server-side subscription leak.
             if (!subscriptionManager.get(subscriptionId)) {
                 socket.unsubscribe(duplexerChannelName, channel.resourceId);
-                cleanupConnectionIfIdle(instanceId);
+                cleanupConnectionIfIdle(socketAppId, siteId);
                 return;
             }
             subscribedChannel.on(MESSAGE_EVENT_NAME, onMessageCallback);
@@ -191,7 +237,9 @@ async function setupSubscription(httpClient, subscriptionId, channel, messageHan
             subscriptionManager.set(subscriptionId, {
                 channelName: channel.name,
                 channelResourceId: channel.resourceId,
-                instanceId,
+                maybeCrossAppId,
+                socketAppId,
+                siteId,
                 channelEmitter: subscribedChannel,
                 onSubscribed: currentEntry?.onSubscribed,
                 onSubscriptionError: currentEntry?.onSubscriptionError,
@@ -207,7 +255,7 @@ async function setupSubscription(httpClient, subscriptionId, channel, messageHan
             const failedEntry = subscriptionManager.get(subscriptionId);
             subscriptionManager.delete(subscriptionId);
             failedEntry?.onSubscriptionError?.(subscribeFailed(channel, payload), subscriptionId);
-            cleanupConnectionIfIdle(instanceId);
+            cleanupConnectionIfIdle(socketAppId, siteId);
         }
         // Subscribe to the duplexer channel and register lifecycle listeners
         // in the same synchronous block so no events can be missed.

package/es/build/subscriber/subscription-manager.d.ts

@@ -3,7 +3,9 @@ import type { SubscriptionHandler, SubscriptionErrorHandler } from '@wix/realtim
 export interface SubscriptionEntry {
     channelName: string;
     channelResourceId?: string;
-    instanceId?: string;
+    maybeCrossAppId?: string;
+    siteId?: string;
+    socketAppId?: string;
     channelEmitter?: ReturnType<ReturnType<Duplexer['connect']>['subscribe']>;
     removeListeners: () => void;
     cancelled?: boolean;
@@ -12,15 +14,15 @@ export interface SubscriptionEntry {
 }
 export declare class SubscriptionManager {
     private subscriptionsBySubId;
-    private instanceIdToSubscriptionIds;
+    private socketKeyToSubscriptionIds;
     set(id: string, entry: SubscriptionEntry): void;
     get(id: string): SubscriptionEntry | undefined;
     delete(id: string): void;
     findByChannel(channelName: string, channelResourceId?: string): [string, SubscriptionEntry][];
-    deleteAndStillHasRemainingOnChannel(instanceId: string, subscriptionIdToDelete: string, channelName: string, resourceId?: string): boolean;
-    hasSubscriptionsForInstanceId(instanceId: string): boolean;
-    getSubscriptionIdsByInstanceId(instanceId: string): string[];
+    deleteAndStillHasRemainingOnChannel(socketAppId: string, siteId: string, subscriptionIdToDelete: string, channelName: string, resourceId?: string): boolean;
+    hasSubscriptionsForSocket(socketAppId: string, siteId: string): boolean;
+    getSubscriptionIdsBySocket(socketAppId: string, siteId: string): string[];
     removeAll(): void;
-    private addToInstanceIndex;
-    private removeFromInstanceIndex;
+    private addToSocketIndex;
+    private removeFromSocketIndex;
 }

package/es/build/subscriber/subscription-manager.js

@@ -1,10 +1,13 @@
+function socketKey(socketAppId, siteId) {
+    return `${socketAppId}:${siteId}`;
+}
 export class SubscriptionManager {
     subscriptionsBySubId = new Map();
-    instanceIdToSubscriptionIds = new Map();
+    socketKeyToSubscriptionIds = new Map();
     set(id, entry) {
         this.subscriptionsBySubId.set(id, entry);
-        if (entry.instanceId) {
-            this.addToInstanceIndex(entry.instanceId, id);
+        if (entry.socketAppId && entry.siteId) {
+            this.addToSocketIndex(socketKey(entry.socketAppId, entry.siteId), id);
         }
     }
     get(id) {
@@ -12,8 +15,8 @@ export class SubscriptionManager {
     }
     delete(id) {
         const entry = this.subscriptionsBySubId.get(id);
-        if (entry?.instanceId) {
-            this.removeFromInstanceIndex(entry.instanceId, id);
+        if (entry?.socketAppId && entry.siteId) {
+            this.removeFromSocketIndex(socketKey(entry.socketAppId, entry.siteId), id);
         }
         this.subscriptionsBySubId.delete(id);
     }
@@ -21,9 +24,9 @@ export class SubscriptionManager {
         return [...this.subscriptionsBySubId.entries()].filter(([, sub]) => sub.channelName === channelName &&
             sub.channelResourceId === channelResourceId);
     }
-    deleteAndStillHasRemainingOnChannel(instanceId, subscriptionIdToDelete, channelName, resourceId) {
+    deleteAndStillHasRemainingOnChannel(socketAppId, siteId, subscriptionIdToDelete, channelName, resourceId) {
         this.delete(subscriptionIdToDelete);
-        const candidateIds = this.instanceIdToSubscriptionIds.get(instanceId);
+        const candidateIds = this.socketKeyToSubscriptionIds.get(socketKey(socketAppId, siteId));
         if (!candidateIds)
             return false;
         for (const id of candidateIds) {
@@ -36,12 +39,12 @@ export class SubscriptionManager {
         }
         return false;
     }
-    hasSubscriptionsForInstanceId(instanceId) {
-        const ids = this.instanceIdToSubscriptionIds.get(instanceId);
+    hasSubscriptionsForSocket(socketAppId, siteId) {
+        const ids = this.socketKeyToSubscriptionIds.get(socketKey(socketAppId, siteId));
         return !!ids && ids.size > 0;
     }
-    getSubscriptionIdsByInstanceId(instanceId) {
-        const ids = this.instanceIdToSubscriptionIds.get(instanceId);
+    getSubscriptionIdsBySocket(socketAppId, siteId) {
+        const ids = this.socketKeyToSubscriptionIds.get(socketKey(socketAppId, siteId));
         return ids ? [...ids] : [];
     }
     removeAll() {
@@ -49,22 +52,22 @@ export class SubscriptionManager {
             sub.removeListeners();
         }
         this.subscriptionsBySubId.clear();
-        this.instanceIdToSubscriptionIds.clear();
+        this.socketKeyToSubscriptionIds.clear();
     }
-    addToInstanceIndex(instanceId, id) {
-        let ids = this.instanceIdToSubscriptionIds.get(instanceId);
+    addToSocketIndex(key, id) {
+        let ids = this.socketKeyToSubscriptionIds.get(key);
         if (!ids) {
             ids = new Set();
-            this.instanceIdToSubscriptionIds.set(instanceId, ids);
+            this.socketKeyToSubscriptionIds.set(key, ids);
         }
         ids.add(id);
     }
-    removeFromInstanceIndex(instanceId, id) {
-        const ids = this.instanceIdToSubscriptionIds.get(instanceId);
+    removeFromSocketIndex(key, id) {
+        const ids = this.socketKeyToSubscriptionIds.get(key);
         if (ids) {
             ids.delete(id);
             if (ids.size === 0) {
-                this.instanceIdToSubscriptionIds.delete(instanceId);
+                this.socketKeyToSubscriptionIds.delete(key);
             }
         }
     }

package/es/build/types.d.ts

@@ -1 +1 @@
-export { RealtimeErrorCode, RealtimeError, type Channel, type Publisher, type Message, type MessageHandler, type SubscriptionHandler, type SubscriptionErrorHandler, type SubscriptionOptions, type UnsubscribeOptions, } from '@wix/realtime-common/types';
+export { RealtimeErrorCode, RealtimeError, type PublishChannel, type SubscribeChannel, type Publisher, type Message, type MessageHandler, type SubscriptionHandler, type SubscriptionErrorHandler, type SubscriptionOptions, type UnsubscribeOptions, } from '@wix/realtime-common/types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/realtime",
-  "version": "1.0.46",
+  "version": "1.0.47",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -44,11 +44,11 @@
     "@wix/auto_sdk_duplexer_publisher": "^1.0.10",
     "@wix/auto_sdk_duplexer_realtime-permissions-provider": "^1.0.0",
     "@wix/duplexer-js": "^2.0.6",
-    "@wix/realtime-common": "1.0.16",
+    "@wix/realtime-common": "1.0.17",
     "@wix/sdk": "^1.21.4",
     "@wix/sdk-runtime": "^1.0.9",
     "@wix/sdk-types": "^1.17.5",
-    "@wix/sdk_realtime_site": "1.0.35",
+    "@wix/sdk_realtime_site": "1.0.36",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
@@ -72,5 +72,5 @@
       "isRootPublicSdk": true
     }
   },
-  "falconPackageHash": "dd2be6f5c00f1549f81637c9949a103ccb60fa0cd8161ae4a21f61c6"
+  "falconPackageHash": "9d0366754fb3d0e319f47cd14f651bc19f84e19ddcff7ad474301df2"
 }