@protontech/drive-sdk 0.0.12 → 0.1.0

package/src/internal/events/eventManager.test.ts

@@ -1,139 +1,252 @@
 import { getMockLogger } from "../../tests/logger";
-import { NotFoundAPIError } from "../apiService";
 import { EventManager } from "./eventManager";
+import { DriveEvent, DriveEventType, EventSubscription, UnsubscribeFromEventsSourceError } from "./interface";
 
 jest.useFakeTimers();
 
+const POLLING_INTERVAL = 1;
+
 describe("EventManager", () => {
-    let manager: EventManager<string>;
-    
-    const getLastEventIdMock = jest.fn();
+    let manager: EventManager<DriveEvent>;
+
+    const getLatestEventIdMock = jest.fn();
     const getEventsMock = jest.fn();
-    const updateLatestEventIdMock = jest.fn();
     const listenerMock = jest.fn();
+    const mockLogger = getMockLogger();
+    const subscriptions: EventSubscription[] = [];
 
     beforeEach(() => {
-        jest.clearAllMocks();
-
-        getLastEventIdMock.mockImplementation(() => Promise.resolve("eventId1"));
-        getEventsMock.mockImplementation(() => Promise.resolve({
-            lastEventId: "eventId2",
-            more: false,
-            refresh: false,
-            events: ["event1", "event2"],
-        }));
+        const mockEventManager = {
+            getLogger: () => mockLogger,
+            getLatestEventId: getLatestEventIdMock,
+            getEvents: getEventsMock,
+        };
 
         manager = new EventManager(
-            getMockLogger(),
-            getLastEventIdMock,
-            getEventsMock,
-            updateLatestEventIdMock,
+            mockEventManager as any,
+            POLLING_INTERVAL,
+            null,
         );
-        manager.addListener(listenerMock);
+        const subscription = manager.addListener(listenerMock);
+        subscriptions.push(subscription);
     });
 
     afterEach(async () => {
         await manager.stop();
+        while (subscriptions.length > 0) {
+            const subscription = subscriptions.pop();
+            subscription?.dispose();
+        }
+        jest.clearAllMocks();
     });
 
-    it("should get latest event ID on first run only", async () => {
-        await manager.start();
-        expect(getLastEventIdMock).toHaveBeenCalledTimes(1);
-        expect(getEventsMock).toHaveBeenCalledTimes(0);
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
-    });
+    it("should start polling when started", async () => {
+        getLatestEventIdMock.mockResolvedValue('EventId1');
+
+        const mockEvents: DriveEvent[][] = [
+            [{
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'EventId2',
+            }],
+            [{
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'EventId3',
+            }],
+        ];
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents[0];
+        }).mockImplementationOnce(async function* () {
+            yield* mockEvents[1];
+        }).mockImplementationOnce(async function* () {
+        });
 
-    it("should notify about events in the next run", async () => {
-        await manager.start();
-        expect(getLastEventIdMock).toHaveBeenCalledTimes(1);
+        expect(getLatestEventIdMock).toHaveBeenCalledTimes(0);
         expect(getEventsMock).toHaveBeenCalledTimes(0);
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
-        updateLatestEventIdMock.mockClear();
+
+        expect(await manager.start()).toBeUndefined();
+
+        expect(getLatestEventIdMock).toHaveBeenCalledTimes(1);
+        expect(getEventsMock).toHaveBeenCalledWith('EventId1');
+
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(1);
-        expect(listenerMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId2');
+        expect(getEventsMock).toHaveBeenCalledTimes(2);
+        expect(getEventsMock).toHaveBeenCalledWith('EventId2');
     });
 
-    it("should continue with more events", async () => {
-        getEventsMock.mockImplementation((lastEventId: string) => Promise.resolve({
-            lastEventId: lastEventId === "eventId1" ? "eventId2" : "eventId3",
-            more: lastEventId === "eventId1" ? true : false,
-            refresh: false,
-            events: lastEventId === "eventId1" ? ["event1", "event2"] : ["event3"],
-        }));
+    it("should stop polling when stopped", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+        getEventsMock.mockImplementation(async function* () {
+            yield {
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId1',
+            };
+        });
+
         await manager.start();
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(2);
-        expect(listenerMock).toHaveBeenCalledTimes(2);
-        expect(listenerMock).toHaveBeenCalledWith(["event1", "event2"], false);
-        expect(listenerMock).toHaveBeenCalledWith(["event3"], false);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(3);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId2');
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId3');
+
+        const callsBeforeStop = getEventsMock.mock.calls.length;
+        await manager.stop();
+        await jest.runOnlyPendingTimersAsync();
+
+        // Should not have made additional calls after stopping
+        expect(getEventsMock).toHaveBeenCalledTimes(callsBeforeStop);
     });
 
-    it("should refresh if event does not exist", async () => {
-        getEventsMock.mockImplementation(() => Promise.reject(new NotFoundAPIError('Event not found', 2501)));
-        await manager.start();
+    it("should notify all listeners when getting events", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        const mockEvents: DriveEvent[] = [
+            {
+                type: DriveEventType.NodeCreated,
+                nodeUid: 'node1',
+                parentNodeUid: 'parent1',
+                isTrashed: false,
+                isShared: false,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId2',
+            },
+        ];
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents;
+        }).mockImplementation(async function* () {
+        });
+
+        expect(await manager.start()).toBeUndefined();
         await jest.runOnlyPendingTimersAsync();
-        expect(getLastEventIdMock).toHaveBeenCalledTimes(2);
         expect(listenerMock).toHaveBeenCalledTimes(1);
-        expect(listenerMock).toHaveBeenCalledWith([], true);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId1');
+        expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
     });
 
-    it("should retry on error", async () => {
-        let index = 0;
-        getEventsMock.mockImplementation(() => {
-            index++;
-            if (index <= 3) {
-                return Promise.reject(new Error("Error"));
+    it("should propagate unsubscription errors", async () => {
+        getLatestEventIdMock.mockImplementation(() => {
+            throw new UnsubscribeFromEventsSourceError("Not found");
+        });
+
+        await expect(manager.start()).rejects.toThrow(UnsubscribeFromEventsSourceError);
+
+        expect(getLatestEventIdMock).toHaveBeenCalledTimes(1);
+        expect(listenerMock).toHaveBeenCalledTimes(0);
+        expect(getEventsMock).toHaveBeenCalledTimes(0);
+    });
+
+    it("should continue processing multiple events", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        const mockEvents: DriveEvent[] = [
+            {
+                type: DriveEventType.NodeCreated,
+                nodeUid: 'node1',
+                parentNodeUid: 'parent1',
+                isTrashed: false,
+                isShared: false,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId2',
+            },
+            {
+                type: DriveEventType.NodeCreated,
+                nodeUid: 'node2',
+                parentNodeUid: 'parent1',
+                isTrashed: false,
+                isShared: false,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId3',
             }
-            return Promise.resolve({
-                lastEventId: "eventId2",
-                more: false,
-                refresh: false,
-                events: ["event1", "event2"],
-            });
+        ];
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents;
+        }).mockImplementation(async function* () {
+            // Empty generator for subsequent calls
         });
+
         await manager.start();
-        updateLatestEventIdMock.mockClear();
+        await jest.runOnlyPendingTimersAsync();
 
-        // First failure.
+        expect(listenerMock).toHaveBeenCalledTimes(2);
+        expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
+        expect(listenerMock).toHaveBeenNthCalledWith(2, mockEvents[1]);
+
+        getEventsMock.mockImplementationOnce(async function* () {
+            yield* mockEvents;
+        })
         await jest.runOnlyPendingTimersAsync();
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(manager.nextPollTimeout).toBe(30000);
+        expect(listenerMock).toHaveBeenCalledTimes(4);
+        expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
+        expect(listenerMock).toHaveBeenNthCalledWith(2, mockEvents[1]);
+    });
+
+    it("should retry on error with exponential backoff", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        let callCount = 0;
+        getEventsMock.mockImplementation(async function* () {
+            callCount++;
+            if (callCount <= 3) {
+                throw new Error("Network error");
+            }
+            yield {
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId3',
+            };
+        });
+
+        expect(manager['retryIndex']).toEqual(0);
+
+        expect(await manager.start()).toBeUndefined();
+        expect(getEventsMock).toHaveBeenCalledTimes(1);
+        expect(manager['retryIndex']).toEqual(1);
 
-        // Second failure.
         await jest.runOnlyPendingTimersAsync();
-        expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(manager.nextPollTimeout).toBe(60000);
+        expect(getEventsMock).toHaveBeenCalledTimes(2);
+        expect(manager['retryIndex']).toEqual(2);
 
-        // Third failure.
         await jest.runOnlyPendingTimersAsync();
+        expect(manager['retryIndex']).toEqual(3);
+
         expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(manager.nextPollTimeout).toBe(90000);
 
-        // And now it passes.
         await jest.runOnlyPendingTimersAsync();
         expect(listenerMock).toHaveBeenCalledTimes(1);
-        expect(listenerMock).toHaveBeenCalledWith(["event1", "event2"], false);
-        expect(updateLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(updateLatestEventIdMock).toHaveBeenCalledWith('eventId2');
+        // After success, retry index should reset
+        expect(manager['retryIndex']).toEqual(0);
     });
 
-    it("should stop polling", async () => {
-        await manager.start();
+    it("should stop polling when stopped immediately", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+        getEventsMock.mockImplementation(async function* () {
+            yield {
+                type: DriveEventType.FastForward,
+                treeEventScopeId: 'volume1',
+                eventId: 'eventId1',
+            };
+        });
+
+        expect(await manager.start()).toBeUndefined();
+        expect(getEventsMock).toHaveBeenCalledTimes(1);
         await manager.stop();
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(0);
+
+        // getEvents should have been called once during start, but not again after stop
+        expect(getEventsMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("should handle empty event streams", async () => {
+        getLatestEventIdMock.mockResolvedValue('eventId1');
+
+        getEventsMock.mockImplementation(async function* () {
+            // Empty generator - no events
+        });
+
+        await manager.start();
+        await jest.runOnlyPendingTimersAsync();
+
+        expect(listenerMock).toHaveBeenCalledTimes(0);
     });
 });

package/src/internal/events/eventManager.ts

@@ -1,168 +1,122 @@
 import { Logger } from "../../interface";
-import { NotFoundAPIError } from "../apiService";
-import { Events } from "./interface";
+import { EventManagerInterface, Event, EventSubscription } from "./interface";
 
-const DEFAULT_POLLING_INTERVAL_IN_SECONDS = 30;
 const FIBONACCI_LIST = [1, 1, 2, 3, 5, 8, 13];
 
-/**
- * `fullRefresh` is true when the event manager has requested a full
- * refresh of the data. That can happen if there is too many events
- * to be processed or the last event ID is too old.
- */
-type Listener<T> = (events: T[], fullRefresh: boolean) => Promise<void>;
+type Listener<T> = (event: T) => Promise<void>;
+
 
 /**
  * Event manager general helper that is responsible for fetching events
  * from the server and notifying listeners about the events.
- * 
+ *
  * The specific implementation of fetching the events from the API must
  * be passed as dependency and can be used for any type of events that
  * supports the same structure.
- * 
+ *
  * The manager will not start fetching events until the `start` method is
  * called. Once started, the manager will fetch events in a loop with
  * a timeout between each fetch. The default timeout is 30 seconds and
  * additional jitter is used in case of failure.
- * 
- * Example of usage:
- * 
- * ```typescript
- * const manager = new EventManager(
- *    logger,
- *    () => apiService.getLatestEventId(),
- *    (eventId) => apiService.getEvents(eventId),
- * );
- * 
- * manager.addListener((events, fullRefresh) => {
- *   // Process the events
- * });
- * 
- * manager.start();
- * ```
  */
-export class EventManager<T> {
+export class EventManager<T extends Event> {
+    private logger: Logger;
     private latestEventId?: string;
     private timeoutHandle?: ReturnType<typeof setTimeout>;
     private processPromise?: Promise<void>;
     private listeners: Listener<T>[] = [];
     private retryIndex: number = 0;
 
-    pollingIntervalInSeconds = DEFAULT_POLLING_INTERVAL_IN_SECONDS;
-
     constructor(
-        private logger: Logger,
-        private getLatestEventId: () => Promise<string>,
-        private getEvents: (eventId: string) => Promise<Events<T>>,
-        private updateLatestEventId: (lastEventId: string) => Promise<void>,
+        private specializedEventManager: EventManagerInterface<T>,
+        private pollingIntervalInSeconds: number,
+        latestEventId: string | null,
     ) {
-        this.logger = logger;
-        this.getLatestEventId = getLatestEventId;
-        this.getEvents = getEvents;
-        this.updateLatestEventId = updateLatestEventId;
+        if (latestEventId !== null) {
+            this.latestEventId = latestEventId;
+        }
+        this.logger = specializedEventManager.getLogger();
     }
 
-    addListener(callback: Listener<T>): void {
+    async start(): Promise<void> {
+        if (this.latestEventId === undefined) {
+            this.latestEventId = await this.specializedEventManager.getLatestEventId();
+        }
+        this.processPromise = this.processEvents();
+    }
+
+    addListener(callback: Listener<T>): EventSubscription {
         this.listeners.push(callback);
+        return {
+            dispose: (): void => {
+                const index = this.listeners.indexOf(callback);
+                this.listeners.splice(index, 1);
+            },
+        };
     }
 
-    async start(): Promise<void> {
-        this.logger.info(`Starting event manager with polling interval ${this.pollingIntervalInSeconds} seconds`);
-        await this.stop();
-        this.processPromise = this.processEvents();
+    setPollingInterval(pollingIntervalInSeconds: number): void {
+        this.pollingIntervalInSeconds = pollingIntervalInSeconds;
+    }
+
+    async stop(): Promise<void> {
+        if (this.processPromise) {
+            this.logger.info(`Stopping event manager`);
+            try {
+                await this.processPromise;
+            } catch (error) {
+                this.logger.warn(`Failed to stop cleanly: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+
+        if (!this.timeoutHandle) {
+            return;
+        }
+
+        clearTimeout(this.timeoutHandle);
+        this.timeoutHandle = undefined;
+    }
+
+    private async notifyListeners(event: T): Promise<void> {
+        for (const listener of this.listeners) {
+            await listener(event);
+        }
     }
 
     private async processEvents() {
+        let listenerError;
         try {
-            if (!this.latestEventId) {
-                this.latestEventId = await this.getLatestEventId();
-                await this.updateLatestEventId(this.latestEventId);
-            } else {
-                while (true) {
-                    let result;
-                    try {
-                        result = await this.getEvents(this.latestEventId);
-                    } catch (error: unknown) {
-                        // If last event ID is not found, we need to refresh the data.
-                        // Caller is notified via standard event update with refresh flag.
-                        if (error instanceof NotFoundAPIError) {
-                            this.logger.warn(`Last event ID not found, refreshing data`);
-                            result = {
-                                lastEventId: await this.getLatestEventId(), 
-                                more: false, 
-                                refresh: true,
-                                events: [],
-                            };
-                        } else {
-                            // Any other error is considered as a failure and we will retry
-                            // with backoff policy.
-                            throw error;
-                        }
-                    }
-                    await this.notifyListeners(result);
-                    if (result.lastEventId !== this.latestEventId) {
-                        await this.updateLatestEventId(result.lastEventId);
-                        this.latestEventId = result.lastEventId;
-                    }
-                    if (!result.more) {
-                        break;
-                    }
+            const events = this.specializedEventManager.getEvents(this.latestEventId!);
+            for await (const event of events) {
+                try {
+                    await this.notifyListeners(event);
+                } catch (internalListenerError) {
+                    listenerError = internalListenerError;
+                    break;
                 }
+                this.latestEventId = event.eventId;
             }
             this.retryIndex = 0;
         } catch (error: unknown) {
+            // This could be improved to catch api specific errors and let the listener errors bubble up directly
             this.logger.error(`Failed to process events: ${error instanceof Error ? error.message : error} (retry ${this.retryIndex}, last event ID: ${this.latestEventId})`);
             this.retryIndex++;
         }
+        if (listenerError) {
+            throw listenerError;
+        }
 
         this.timeoutHandle = setTimeout(() => {
             this.processPromise = this.processEvents();
         }, this.nextPollTimeout);
     };
 
-    private async notifyListeners(result: Events<T>): Promise<void> {
-        if (result.events.length === 0 && !result.refresh) {
-            return;
-        }
-        if (!this.listeners.length) {
-            return;
-        }
-
-        this.logger.debug(`Notifying listeners about ${result.events.length} events`);
-
-        for (const listener of this.listeners) {
-            try {
-                await listener(result.events, result.refresh);
-            } catch (error: unknown) {
-                this.logger.error(`Failed to process events: ${error instanceof Error ? error.message : error} (last event ID: ${result.lastEventId}, refresh: ${result.refresh})`);
-                throw error;
-            }
-        }
-    }
-
     /**
      * Polling timeout is using exponential backoff with Fibonacci sequence.
-     * 
-     * The timeout is public for testing purposes only.
      */
-    get nextPollTimeout(): number {
+    private get nextPollTimeout(): number {
         const retryIndex = Math.min(this.retryIndex, FIBONACCI_LIST.length - 1);
+        // FIXME jitter
         return this.pollingIntervalInSeconds * 1000 * FIBONACCI_LIST[retryIndex];
     }
-
-    async stop(): Promise<void> {
-        if (this.processPromise) {
-            this.logger.info(`Stopping event manager`);
-            try {
-                await this.processPromise;
-            } catch {}
-        }
-
-        if (!this.timeoutHandle) {
-            return;
-        }
-
-        clearTimeout(this.timeoutHandle);
-        this.timeoutHandle = undefined;
-    }
 }