@simplito/privmx-webendpoint 2.6.2 → 2.6.4

package/extra/managers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionEventsManager = exports.ConnectionChannels = exports.KvdbEventsManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.BaseEventDispatcherManager = void 0;
+exports.UserEventsManager = exports.ConnectionEventsManager = exports.ConnectionChannels = exports.CustomEventsManager = exports.KvdbEventsManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.BaseEventDispatcherManager = void 0;
 const subscriptions_1 = require("./subscriptions");
 class BaseEventDispatcherManager {
     _listenersSymbols = new Map();
@@ -9,7 +9,10 @@ class BaseEventDispatcherManager {
         return this._listeners;
     }
     dispatchEvent(event) {
-        const callbacks = event.subscriptions.flatMap((s) => this._listeners.get(s));
+        const callbacks = event.subscriptions.flatMap((s) => {
+            const listeners = this._listeners.get(s);
+            return listeners ?? [];
+        });
         for (const listener of callbacks) {
             listener.callback(event);
         }
@@ -39,14 +42,19 @@ class BaseEventDispatcherManager {
         return subscriptionIds;
     }
     async unsubscribeFrom(subscriptionsId) {
+        const knownIds = [];
         for (const subscriptionId of subscriptionsId) {
             for (const [key, callbackSubscription,] of this._listenersSymbols.entries()) {
                 if (callbackSubscription === subscriptionId) {
+                    knownIds.push(subscriptionId);
                     this.unregisterCallback(key);
                 }
             }
         }
-        return this.apiUnsubscribeFrom(subscriptionsId);
+        if (knownIds.length === 0) {
+            return Promise.resolve();
+        }
+        return this.apiUnsubscribeFrom(knownIds);
     }
 }
 exports.BaseEventDispatcherManager = BaseEventDispatcherManager;
@@ -130,10 +138,30 @@ class KvdbEventsManager extends BaseEventDispatcherManager {
     }
 }
 exports.KvdbEventsManager = KvdbEventsManager;
+class CustomEventsManager extends BaseEventDispatcherManager {
+    eventsApi;
+    constructor(eventsApi) {
+        super();
+        this.eventsApi = eventsApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.eventsApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.eventsApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.eventsApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.CustomEventsManager = CustomEventsManager;
 exports.ConnectionChannels = {
-    [subscriptions_1.ConnectionEventType.LIB_CONNECTED]: "channel/lib_connected",
-    [subscriptions_1.ConnectionEventType.LIB_DISCONNECTED]: "channel/lib_disconnected",
-    [subscriptions_1.ConnectionEventType.LIB_PLATFORM_DISCONNECTED]: "channel/lib_platform_disconnected",
+    [subscriptions_1.ConnectionStatusEventType.LIB_CONNECTED]: "channel/lib_connected",
+    [subscriptions_1.ConnectionStatusEventType.LIB_DISCONNECTED]: "channel/lib_disconnected",
+    [subscriptions_1.ConnectionStatusEventType.LIB_PLATFORM_DISCONNECTED]: "channel/lib_platform_disconnected",
 };
 class ConnectionEventsManager extends BaseEventDispatcherManager {
     connectionId;
@@ -149,9 +177,29 @@ class ConnectionEventsManager extends BaseEventDispatcherManager {
     }
     async subscribeFor(subscriptions) {
         const subscriptionChannels = subscriptions.map((x) => {
-            return `${this.connectionId}/${subscriptions_1.ConnectionEventType[x.type]}`;
+            return `${this.connectionId}/${exports.ConnectionChannels[x.type]}`;
         });
         return this.prepareSubscription(subscriptionChannels, subscriptions);
     }
 }
 exports.ConnectionEventsManager = ConnectionEventsManager;
+class UserEventsManager extends BaseEventDispatcherManager {
+    userEventsApi;
+    constructor(userEventsApi) {
+        super();
+        this.userEventsApi = userEventsApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.userEventsApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.userEventsApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.userEventsApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.UserEventsManager = UserEventsManager;

package/extra/subscriptions.d.ts

@@ -1,5 +1,4 @@
 import { Types } from "..";
-import { ThreadEventSelectorType, ThreadEventType } from "../Types";
 import { GenericEvent } from "./managers";
 export type ThreadCallbackPayload = {
     [Types.ThreadEventType.THREAD_CREATE]: Types.Thread;
@@ -75,8 +74,14 @@ export type KvdbCallbackPayload = {
     };
     [Types.KvdbEventType.COLLECTION_CHANGE]: Types.CollectionChangedEventData;
 };
+export type UserEventCallbackPayload = {
+    [Types.ConnectionEventType.USER_ADD]: Types.ContextUserEventData;
+    [Types.ConnectionEventType.USER_REMOVE]: Types.ContextUserEventData;
+    [Types.ConnectionEventType.USER_STATUS]: Types.ContextUsersStatusChangedEventData;
+};
+export type EventsCallbackPayload = Types.ContextCustomEventData;
 export type EventCallback = {
-    callback: (e: Types.Event) => void;
+    callback: (e: Types.Event | GenericEvent<unknown>) => void;
     symbol: Symbol;
 };
 export interface Subscription<T, S> {
@@ -129,37 +134,54 @@ export declare function createInboxSubscription<T extends Types.InboxEventType,
     selector: S;
     id: string;
 };
-export declare enum ConnectionEventType {
+export declare function createEventSubscription(s: {
+    channel: string;
+    selector: Types.EventsEventSelectorType;
+    id: string;
+    callbacks: ((arg: GenericEvent<EventsCallbackPayload>) => void)[];
+}): Subscription<string, Types.EventsEventSelectorType> & {
+    channel: string;
+};
+export declare enum ConnectionStatusEventType {
     LIB_DISCONNECTED = 0,
     LIB_PLATFORM_DISCONNECTED = 1,
     LIB_CONNECTED = 2
 }
-export declare function createConnectionSubscription(s: {
-    type: ConnectionEventType;
-    callbacks: ((arg: GenericEvent<undefined>) => void)[];
-}): {
+export type ConnectionSubscription = {
+    type: ConnectionStatusEventType;
     callbacks: EventCallback[];
-    type: ConnectionEventType;
 };
+export declare function createConnectionSubscription(s: {
+    type: ConnectionStatusEventType;
+    callbacks: ((arg: GenericEvent<undefined>) => void)[];
+}): ConnectionSubscription;
+export declare function createUserEventSubscription<T extends Types.ConnectionEventType, S extends Types.ConnectionEventSelectorType>(s: {
+    type: T;
+    selector: S;
+    id: string;
+    callbacks: ((arg: GenericEvent<UserEventCallbackPayload[T]>) => void)[];
+}): Subscription<T, S>;
 export interface EventSubscriber<E, S> {
     /**
-     * Subscribe for the Thread events on the given subscription query.
+     * Subscribe for events on the given subscription queries.
      * @param {string[]} subscriptionQueries list of queries
      */
     subscribeFor(subscriptionQueries: string[]): Promise<string[]>;
     /**
-     * Unsubscribes from events for the given subscriptionId.
+     * Unsubscribe from events for the given subscriptionIds.
      */
     unsubscribeFrom(subscriptionIds: string[]): Promise<void>;
     /**
-     * Generate subscription Query for the Thread events.
-     * @param {EventType} eventType type of event which you listen for
-     * @param {EventSelectorType} selectorType scope on which you listen for events
+     * Generate subscription query string for the requested event scope.
+     * @param {E} eventType type of event which you listen for
+     * @param {S} selectorType scope on which you listen for events
      * @param {string} selectorId ID of the selector
      */
     buildSubscriptionQuery(eventType: E, selectorType: S, selectorId: string): Promise<string>;
 }
-export type SubscriberForThreadsEvents = EventSubscriber<ThreadEventType, ThreadEventSelectorType>;
+export type SubscriberForThreadsEvents = EventSubscriber<Types.ThreadEventType, Types.ThreadEventSelectorType>;
 export type SubscriberForStoreEvents = EventSubscriber<Types.StoreEventType, Types.StoreEventSelectorType>;
 export type SubscriberForInboxEvents = EventSubscriber<Types.InboxEventType, Types.InboxEventSelectorType>;
 export type SubscriberForKvdbEvents = EventSubscriber<Types.KvdbEventType, Types.KvdbEventSelectorType>;
+export type SubscriberForUserEvents = EventSubscriber<Types.ConnectionEventType, Types.ConnectionEventSelectorType>;
+export type SubscriberForEvents = EventSubscriber<string, Types.EventsEventSelectorType>;

package/extra/subscriptions.js

@@ -1,51 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionEventType = void 0;
+exports.ConnectionStatusEventType = void 0;
 exports.createThreadSubscription = createThreadSubscription;
 exports.createStoreSubscription = createStoreSubscription;
 exports.createKvdbSubscription = createKvdbSubscription;
 exports.createInboxSubscription = createInboxSubscription;
+exports.createEventSubscription = createEventSubscription;
 exports.createConnectionSubscription = createConnectionSubscription;
+exports.createUserEventSubscription = createUserEventSubscription;
 const __1 = require("..");
 function toEventCallback(f) {
     return {
         callback: f,
-        symbol: Symbol()
+        symbol: Symbol(),
     };
 }
 function createThreadSubscription(s) {
     return {
         ...s,
-        callbacks: s.callbacks.map(toEventCallback)
+        callbacks: s.callbacks.map(toEventCallback),
     };
 }
 function createStoreSubscription(s) {
     return {
         ...s,
-        callbacks: s.callbacks.map(toEventCallback)
+        callbacks: s.callbacks.map(toEventCallback),
     };
 }
 function createKvdbSubscription(s) {
     return {
         ...s,
-        callbacks: s.callbacks.map(toEventCallback)
+        callbacks: s.callbacks.map(toEventCallback),
     };
 }
 function createInboxSubscription(s) {
     return {
         ...s,
-        callbacks: s.callbacks.map(toEventCallback)
+        callbacks: s.callbacks.map(toEventCallback),
     };
 }
-var ConnectionEventType;
-(function (ConnectionEventType) {
-    ConnectionEventType[ConnectionEventType["LIB_DISCONNECTED"] = 0] = "LIB_DISCONNECTED";
-    ConnectionEventType[ConnectionEventType["LIB_PLATFORM_DISCONNECTED"] = 1] = "LIB_PLATFORM_DISCONNECTED";
-    ConnectionEventType[ConnectionEventType["LIB_CONNECTED"] = 2] = "LIB_CONNECTED";
-})(ConnectionEventType || (exports.ConnectionEventType = ConnectionEventType = {}));
+function createEventSubscription(s) {
+    return {
+        type: s.channel,
+        selector: s.selector,
+        id: s.id,
+        callbacks: s.callbacks.map(toEventCallback),
+        channel: s.channel,
+    };
+}
+var ConnectionStatusEventType;
+(function (ConnectionStatusEventType) {
+    ConnectionStatusEventType[ConnectionStatusEventType["LIB_DISCONNECTED"] = 0] = "LIB_DISCONNECTED";
+    ConnectionStatusEventType[ConnectionStatusEventType["LIB_PLATFORM_DISCONNECTED"] = 1] = "LIB_PLATFORM_DISCONNECTED";
+    ConnectionStatusEventType[ConnectionStatusEventType["LIB_CONNECTED"] = 2] = "LIB_CONNECTED";
+})(ConnectionStatusEventType || (exports.ConnectionStatusEventType = ConnectionStatusEventType = {}));
 function createConnectionSubscription(s) {
     return {
         ...s,
-        callbacks: s.callbacks.map(toEventCallback)
+        callbacks: s.callbacks.map(toEventCallback),
+    };
+}
+function createUserEventSubscription(s) {
+    return {
+        ...s,
+        callbacks: s.callbacks.map(toEventCallback),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simplito/privmx-webendpoint",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "description": "PrivMX Web Endpoint library",
   "author": "Simplito",
   "license": "PrivMX Free License",