@simplito/privmx-webendpoint 2.1.1 → 2.2.0

package/extra/__tests__/__mocks__/mockEventAPIs.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockInboxEventApi = exports.MockStoreEventApi = exports.MockThreadEventApi = void 0;
+const mockContainerSubscriber_1 = require("./mockContainerSubscriber");
+class MockThreadEventApi extends mockContainerSubscriber_1.MockContainerSubscriber {
+    containerChannel = 'thread';
+    containerElementChannel(id) {
+        return `thread/${id}/messages`;
+    }
+    constructor(queue) {
+        super(queue);
+    }
+    subscribeForThreadEvents() {
+        return this.subscribeForContainerEvents();
+    }
+    unsubscribeFromThreadEvents() {
+        return this.unsubscribeFromContainerEvents();
+    }
+    subscribeForMessageEvents(threadId) {
+        return this.subscribeForContainerItemEvents(threadId);
+    }
+    unsubscribeFromMessageEvents(threadId) {
+        return this.unsubscribeFromContainerItemEvents(threadId);
+    }
+}
+exports.MockThreadEventApi = MockThreadEventApi;
+class MockStoreEventApi extends mockContainerSubscriber_1.MockContainerSubscriber {
+    containerChannel = 'store';
+    containerElementChannel(id) {
+        return `store/${id}/files`;
+    }
+    constructor(queue) {
+        super(queue);
+    }
+    subscribeForStoreEvents() {
+        return this.subscribeForContainerEvents();
+    }
+    unsubscribeFromStoreEvents() {
+        return this.unsubscribeFromContainerEvents();
+    }
+    subscribeForFileEvents(storeId) {
+        return this.subscribeForContainerItemEvents(storeId);
+    }
+    unsubscribeFromFileEvents(storeId) {
+        return this.unsubscribeFromContainerItemEvents(storeId);
+    }
+}
+exports.MockStoreEventApi = MockStoreEventApi;
+class MockInboxEventApi extends mockContainerSubscriber_1.MockContainerSubscriber {
+    containerChannel = 'inbox';
+    containerElementChannel(id) {
+        return `inbox/${id}/entries`;
+    }
+    constructor(queue) {
+        super(queue);
+    }
+    subscribeForInboxEvents() {
+        return this.subscribeForContainerEvents();
+    }
+    unsubscribeFromInboxEvents() {
+        return this.unsubscribeFromContainerEvents();
+    }
+    subscribeForEntryEvents(storeId) {
+        return this.subscribeForContainerItemEvents(storeId);
+    }
+    unsubscribeFromEntryEvents(storeId) {
+        return this.unsubscribeFromContainerItemEvents(storeId);
+    }
+}
+exports.MockInboxEventApi = MockInboxEventApi;

package/extra/__tests__/__mocks__/mockEventQueue.d.ts

@@ -0,0 +1,13 @@
+import { Channel } from '../../events';
+import { Types } from "../../..";
+export declare class MockEventQueue {
+    queue: Types.Event[];
+    resolveCommand: {
+        resolver: Function;
+    } | null;
+    registeredChannels: Set<Channel>;
+    constructor();
+    dispatchEvent(event: Types.Event): void;
+    waitEvent(): Promise<Types.Event>;
+    emitBreakEvent(): Promise<void>;
+}

package/extra/__tests__/__mocks__/mockEventQueue.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEventQueue = void 0;
+class MockEventQueue {
+    queue = [];
+    resolveCommand = null;
+    registeredChannels = new Set();
+    constructor() { }
+    dispatchEvent(event) {
+        if (this.registeredChannels.has(event.channel)) {
+            this.queue.push(event);
+            if (this.resolveCommand) {
+                this.resolveCommand.resolver();
+                this.resolveCommand = null;
+            }
+        }
+    }
+    async waitEvent() {
+        const lockPromise = new Promise((resolve) => {
+            const event = this.queue.shift();
+            //if there is event in queue resolve immediately
+            if (event) {
+                resolve(event);
+            }
+            else {
+                //if not, lock promise and unlock it on new event
+                this.resolveCommand = {
+                    resolver: () => {
+                        const event = this.queue.shift();
+                        if (event) {
+                            resolve(event);
+                        }
+                    }
+                };
+            }
+        });
+        return lockPromise;
+    }
+    async emitBreakEvent() {
+        return new Promise((resolve) => {
+            resolve;
+        });
+    }
+}
+exports.MockEventQueue = MockEventQueue;

package/extra/__tests__/__mocks__/utils.d.ts

@@ -0,0 +1,8 @@
+import { MockEventQueue } from "./mockEventQueue";
+import { EventManager } from "../../events";
+export declare function utils<T>(cb: () => T): Promise<T>;
+export declare function createTestSetup(): {
+    q: MockEventQueue;
+    manager: EventManager;
+};
+export declare function waitForNextTick(): Promise<void>;

package/extra/__tests__/__mocks__/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForNextTick = exports.createTestSetup = exports.utils = void 0;
+const mockEventQueue_1 = require("./mockEventQueue");
+const events_1 = require("../../events");
+async function utils(cb) {
+    return new Promise((resolve) => {
+        setTimeout(() => resolve(cb()), 10);
+    });
+}
+exports.utils = utils;
+function createTestSetup() {
+    const q = new mockEventQueue_1.MockEventQueue();
+    const mockEventsManager = events_1.EventManager.startEventLoop(q);
+    return { q, manager: mockEventsManager };
+}
+exports.createTestSetup = createTestSetup;
+function waitForNextTick() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+exports.waitForNextTick = waitForNextTick;

package/extra/__tests__/eventsManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/eventsManager.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("../events");
+const mockEventAPIs_1 = require("./__mocks__/mockEventAPIs");
+const utils_1 = require("./__mocks__/utils");
+describe('Events Helpers', () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let mockEventsManager = new events_1.ThreadEventsManager(new mockEventAPIs_1.MockThreadEventApi(q));
+    manager.registerDispatcher(mockEventsManager);
+    beforeEach(() => {
+        let { q: _q, manager: _m } = (0, utils_1.createTestSetup)();
+        q = _q;
+        manager = _m;
+        mockEventsManager = new events_1.ThreadEventsManager(new mockEventAPIs_1.MockThreadEventApi(q));
+        manager.registerDispatcher(mockEventsManager);
+    });
+    it('should registered dispatchers', () => {
+        expect(manager.dispatchers.length).toBe(1);
+    });
+    it('should call callback for matching event', async () => {
+        const cb = jest.fn();
+        await mockEventsManager.onThreadEvent({ event: 'threadStatsChanged', callback: cb });
+        q.dispatchEvent({
+            type: 'threadStatsChanged',
+            data: {},
+            channel: 'thread',
+            connectionId: 1
+        });
+        //adding task on end of js event loop
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                expect(cb).toHaveBeenCalled();
+                resolve();
+            }, 0);
+        });
+    });
+    it('should receive multiple events', async () => {
+        const cb = jest.fn();
+        await mockEventsManager.onThreadEvent({ event: 'threadStatsChanged', callback: cb });
+        q.dispatchEvent({
+            type: 'threadStatsChanged',
+            data: {},
+            channel: 'thread',
+            connectionId: 1
+        });
+        q.dispatchEvent({
+            type: 'threadStatsChanged',
+            data: {},
+            channel: 'thread',
+            connectionId: 1
+        });
+        //adding task on end of js event loop
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                expect(cb).toHaveBeenCalledTimes(2);
+                resolve();
+            }, 0);
+        });
+        q.dispatchEvent({
+            type: 'threadStatsChanged',
+            data: {},
+            channel: 'thread',
+            connectionId: 1
+        });
+        //adding task on end of js event loop
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                expect(cb).toHaveBeenCalledTimes(3);
+                resolve();
+            }, 0);
+        });
+    });
+});

package/extra/__tests__/inboxEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/inboxEventManager.test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockEventAPIs_1 = require("./__mocks__/mockEventAPIs");
+const utils_1 = require("./__mocks__/utils");
+const constants_1 = require("./__mocks__/constants");
+describe('Inbox event manager', () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let mockEventsManager = manager.getInboxEventManager(new mockEventAPIs_1.MockInboxEventApi(q));
+    beforeEach(() => {
+        let { q: _q, manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        mockEventsManager = manager.getInboxEventManager(new mockEventAPIs_1.MockInboxEventApi(q));
+    });
+    it('should add callback for event', async () => {
+        await mockEventsManager.onInboxEvent({
+            event: 'inboxUpdated',
+            callback: () => { }
+        });
+        expect(mockEventsManager.listeners.size).toBe(1);
+    });
+    it('should function to remove callback from event', async () => {
+        const removeListener = await mockEventsManager.onInboxEvent({
+            event: 'inboxUpdated',
+            callback: () => { }
+        });
+        expect(mockEventsManager.listeners.size).toBe(1);
+        await removeListener();
+        expect(mockEventsManager.listeners.size).toBe(0);
+    });
+    it('should register multiple callbacks for channel', async () => {
+        const storeEventCb = jest.fn();
+        await mockEventsManager.onInboxEvent({ event: constants_1.MOCK_INBOX_CREATED_EVENT.type, callback: storeEventCb });
+        await mockEventsManager.onInboxEvent({ event: constants_1.MOCK_INBOX_CREATED_EVENT.type, callback: storeEventCb });
+        q.dispatchEvent(constants_1.MOCK_INBOX_CREATED_EVENT);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(storeEventCb).toHaveBeenCalledTimes(2);
+    });
+    it('should handle subscription for two channels', async () => {
+        const storeEventCb = jest.fn();
+        const messageEventCb = jest.fn();
+        const inboxId = "98dsyvb8as7ybd0asydvb0as";
+        const event = (0, constants_1.MOCK_INBOX_ENTRY_DELETED_EVENT)(inboxId);
+        await mockEventsManager.onInboxEvent({ event: constants_1.MOCK_INBOX_CREATED_EVENT.type, callback: storeEventCb });
+        await mockEventsManager.onEntryEvent(inboxId, {
+            event: event.type,
+            callback: messageEventCb
+        });
+        q.dispatchEvent(constants_1.MOCK_INBOX_CREATED_EVENT);
+        q.dispatchEvent(event);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(storeEventCb).toHaveBeenCalledTimes(1);
+        expect(messageEventCb).toHaveBeenCalledTimes(1);
+    });
+});

package/extra/__tests__/storeEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/storeEventManager.test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockEventAPIs_1 = require("./__mocks__/mockEventAPIs");
+const utils_1 = require("./__mocks__/utils");
+const constants_1 = require("./__mocks__/constants");
+describe('Store event manager', () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let mockEventsManager = manager.getStoreEventManager(new mockEventAPIs_1.MockStoreEventApi(q));
+    beforeEach(() => {
+        let { q: _q, manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        mockEventsManager = manager.getStoreEventManager(new mockEventAPIs_1.MockStoreEventApi(q));
+    });
+    it('should add callback for event', async () => {
+        await mockEventsManager.onStoreEvent({
+            event: 'storeStatsChanged',
+            callback: () => { }
+        });
+        expect(mockEventsManager.listeners.size).toBe(1);
+    });
+    it('should function to remove callback from event', async () => {
+        const removeListener = await mockEventsManager.onStoreEvent({
+            event: 'storeStatsChanged',
+            callback: () => { }
+        });
+        expect(mockEventsManager.listeners.size).toBe(1);
+        await removeListener();
+        expect(mockEventsManager.listeners.size).toBe(0);
+    });
+    it('should register multiple callbacks for channel', async () => {
+        const storeEventCb = jest.fn();
+        await mockEventsManager.onStoreEvent({ event: constants_1.MOCK_STORE_CREATED_EVENT.type, callback: storeEventCb });
+        await mockEventsManager.onStoreEvent({ event: constants_1.MOCK_STORE_CREATED_EVENT.type, callback: storeEventCb });
+        q.dispatchEvent(constants_1.MOCK_STORE_CREATED_EVENT);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(storeEventCb).toHaveBeenCalledTimes(2);
+    });
+    it('should handle subscription for two channels', async () => {
+        const storeEventCb = jest.fn();
+        const messageEventCb = jest.fn();
+        const STORE_ID = '98dsyvs87dybv9a87dyvb98';
+        const storeEvent = (0, constants_1.MOCK_STORE_FILE_DELETED_EVENT)(STORE_ID);
+        await mockEventsManager.onStoreEvent({ event: constants_1.MOCK_STORE_CREATED_EVENT.type, callback: storeEventCb });
+        await mockEventsManager.onFileEvent(STORE_ID, {
+            event: storeEvent.type,
+            callback: messageEventCb
+        });
+        q.dispatchEvent(constants_1.MOCK_STORE_CREATED_EVENT);
+        q.dispatchEvent(storeEvent);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(storeEventCb).toHaveBeenCalledTimes(1);
+        expect(messageEventCb).toHaveBeenCalledTimes(1);
+    });
+});

package/extra/__tests__/threadEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/threadEventManager.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockEventAPIs_1 = require("./__mocks__/mockEventAPIs");
+const utils_1 = require("./__mocks__/utils");
+const constants_1 = require("./__mocks__/constants");
+describe('Thread event manager', () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let mockEventsManager = manager.getThreadEventManager(new mockEventAPIs_1.MockThreadEventApi(q));
+    beforeEach(() => {
+        let { q: _q, manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        mockEventsManager = manager.getThreadEventManager(new mockEventAPIs_1.MockThreadEventApi(q));
+    });
+    it('should create manager', async () => {
+        expect(mockEventsManager).toBeDefined();
+        expect(manager.dispatchers.length).toBe(1);
+    });
+    it('should add callback for event', async () => {
+        await mockEventsManager.onThreadEvent({
+            event: 'threadStatsChanged',
+            callback: () => { }
+        });
+        expect(mockEventsManager.listeners.size).toBe(1);
+    });
+    it('should function to remove callback from event', async () => {
+        const removeListener = await mockEventsManager.onThreadEvent({
+            event: 'threadStatsChanged',
+            callback: () => { }
+        });
+        expect(mockEventsManager.listeners.size).toBe(1);
+        await removeListener();
+        expect(mockEventsManager.listeners.size).toBe(0);
+    });
+    it('should register multiple callbacks for channel', async () => {
+        const threadEventCb = jest.fn();
+        await mockEventsManager.onThreadEvent({ event: constants_1.MOCK_THREAD_CREATED_EVENT.type, callback: threadEventCb });
+        await mockEventsManager.onThreadEvent({ event: constants_1.MOCK_THREAD_CREATED_EVENT.type, callback: threadEventCb });
+        q.dispatchEvent(constants_1.MOCK_THREAD_CREATED_EVENT);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(threadEventCb).toHaveBeenCalledTimes(2);
+    });
+    it('should handle subscription for two channels', async () => {
+        const threadEventCb = jest.fn();
+        const messageEventCb = jest.fn();
+        const THREAD_ID = '823yrcby32987yc23984b7y3w';
+        const threadEvent = (0, constants_1.MOCK_THREAD_MESSAGE_DELETED_EVENT)(THREAD_ID);
+        await mockEventsManager.onThreadEvent({ event: constants_1.MOCK_THREAD_CREATED_EVENT.type, callback: threadEventCb });
+        await mockEventsManager.onMessageEvent(THREAD_ID, {
+            event: threadEvent.type,
+            callback: messageEventCb
+        });
+        q.dispatchEvent(constants_1.MOCK_THREAD_CREATED_EVENT);
+        q.dispatchEvent(threadEvent);
+        //adding task on end of js event loop
+        await (0, utils_1.waitForNextTick)();
+        expect(threadEventCb).toHaveBeenCalledTimes(1);
+        expect(messageEventCb).toHaveBeenCalledTimes(1);
+    });
+});

package/extra/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/utils.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+describe('Serialization Helpers', () => {
+    test('serializeObject should correctly serialize objects', () => {
+        const obj = { key: 'value', num: 42 };
+        const result = (0, utils_1.serializeObject)(obj);
+        expect(result).toBeInstanceOf(Uint8Array);
+        expect((0, utils_1.uint8ToStr)(result)).toBe(JSON.stringify(obj));
+    });
+    test('serializeObject should throw an error for invalid inputs', () => {
+        expect(() => (0, utils_1.serializeObject)(null)).toThrow(TypeError);
+        expect(() => (0, utils_1.serializeObject)('string')).toThrow(TypeError);
+    });
+    test('deserializeObject should correctly deserialize Uint8Array', () => {
+        const obj = { key: 'value', num: 42 };
+        const serialized = (0, utils_1.strToUint8)(JSON.stringify(obj));
+        const result = (0, utils_1.deserializeObject)(serialized);
+        expect(result).toEqual(obj);
+    });
+    test('deserializeObject should handle empty input gracefully', () => {
+        const empty = new Uint8Array();
+        const result = (0, utils_1.deserializeObject)(empty);
+        expect(result).toEqual({});
+    });
+    test('deserializeObject should throw an error for invalid inputs', () => {
+        expect(() => (0, utils_1.deserializeObject)(null)).toThrow(TypeError);
+        expect(() => (0, utils_1.deserializeObject)('string')).toThrow(TypeError);
+        const invalidJson = (0, utils_1.strToUint8)('{ key: value }');
+        expect(() => (0, utils_1.deserializeObject)(invalidJson)).toThrow(SyntaxError);
+    });
+    test('uint8ToStr should correctly convert Uint8Array to string', () => {
+        const str = 'Hello, world!';
+        const arr = (0, utils_1.strToUint8)(str);
+        const result = (0, utils_1.uint8ToStr)(arr);
+        expect(result).toBe(str);
+    });
+    test('uint8ToStr should throw an error for invalid inputs', () => {
+        expect(() => (0, utils_1.uint8ToStr)(null)).toThrow(TypeError);
+        expect(() => (0, utils_1.uint8ToStr)('string')).toThrow(TypeError);
+    });
+    test('strToUint8 should correctly convert string to Uint8Array', () => {
+        const str = 'Hello, world!';
+        const result = (0, utils_1.strToUint8)(str);
+        expect(result).toBeInstanceOf(Uint8Array);
+        expect((0, utils_1.uint8ToStr)(result)).toBe(str);
+    });
+    test('strToUint8 should throw an error for invalid inputs', () => {
+        expect(() => (0, utils_1.strToUint8)(null)).toThrow(TypeError);
+        expect(() => (0, utils_1.strToUint8)(42)).toThrow(TypeError);
+    });
+});