@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/events/index.ts

@@ -1,16 +1,18 @@
-import { ProtonDriveEntitiesCache, Logger, ProtonDriveTelemetry } from "../../interface";
-import { DriveAPIService } from "../apiService";
-import { DriveListener } from "./interface";
-import { EventsAPIService } from "./apiService";
-import { EventsCache } from "./cache";
-import { CoreEventManager } from "./coreEventManager";
-import { VolumeEventManager } from "./volumeEventManager";
-
-export type { DriveEvent, DriveListener } from "./interface";
-export { DriveEventType } from "./interface";
+import { Logger, ProtonDriveTelemetry } from '../../interface';
+import { DriveAPIService } from '../apiService';
+import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider } from './interface';
+import { EventsAPIService } from './apiService';
+import { CoreEventManager } from './coreEventManager';
+import { VolumeEventManager } from './volumeEventManager';
+import { EventManager } from './eventManager';
+import { SharesManager } from '../shares/manager';
+
+export type { DriveEvent, DriveListener } from './interface';
+export { DriveEventType } from './interface';
 
 const OWN_VOLUME_POLLING_INTERVAL = 30;
 const OTHER_VOLUME_POLLING_INTERVAL = 60;
+const CORE_POLLING_INTERVAL = 30;
 
 /**
  * Service for listening to drive events. The service is responsible for
@@ -19,113 +21,91 @@ const OTHER_VOLUME_POLLING_INTERVAL = 60;
  */
 export class DriveEventsService {
     private apiService: EventsAPIService;
-    private cache: EventsCache;
-    private subscribedToRemoteDataUpdates: boolean = false;
-    private listeners: DriveListener[] = [];
-    private coreEvents: CoreEventManager;
-    private volumesEvents: { [volumeId: string]: VolumeEventManager };
+    private coreEvents?: EventManager<DriveEvent>;
+    private volumeEventManagers: { [volumeId: string]: EventManager<DriveEvent> };
     private logger: Logger;
 
-    constructor(private telemetry: ProtonDriveTelemetry, apiService: DriveAPIService, driveEntitiesCache: ProtonDriveEntitiesCache) {
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        apiService: DriveAPIService,
+        private shareManagement: SharesManager,
+        private cacheEventListeners: DriveListener[] = [],
+        private latestEventIdProvider?: LatestEventIdProvider,
+    ) {
         this.telemetry = telemetry;
         this.logger = telemetry.getLogger('events');
         this.apiService = new EventsAPIService(apiService);
-        this.cache = new EventsCache(driveEntitiesCache);
-
-        // FIXME: Allow to pass own core events manager from the public interface.
-        this.coreEvents = new CoreEventManager(this.logger, this.apiService, this.cache);
-        this.volumesEvents = {};
-    }
-
-    /**
-     * Loads all the subscribed volumes (including core events) from the
-     * cache and starts listening to their events. Any additional volume
-     * that is subscribed to later will be automatically started.
-     */
-    async subscribeToRemoteDataUpdates(): Promise<void> {
-        if (this.subscribedToRemoteDataUpdates) {
-            return;
-        }
-
-        await this.loadSubscribedVolumeEventServices();
-        this.sendNumberOfVolumeSubscriptionsToTelemetry();
-
-        this.subscribedToRemoteDataUpdates = true;
-        await this.coreEvents.startSubscription();
-        await Promise.all(
-            Object.values(this.volumesEvents)
-                .map((volumeEvents) => volumeEvents.startSubscription())
-        );
+        this.volumeEventManagers = {};
     }
 
     /**
-     * Subscribe to given volume. The volume will be polled for events
-     * with the polling interval depending on the type of the volume.
-     * Own volumes are polled with highest frequency, while others are
-     * polled with lower frequency depending on the total number of
-     * subscriptions.
-     * 
-     * @param isOwnVolume - Owned volumes are polled with higher frequency.
+     * Subscribe to drive events. The treeEventScopeId can be obtained from a node.
      */
-    async listenToVolume(volumeId: string, isOwnVolume = false): Promise<void> {
-        await this.loadSubscribedVolumeEventServices();
-
-        if (this.volumesEvents[volumeId]) {
-            return;
-        }
+    async subscribeToTreeEvents(treeEventScopeId: string, callback: DriveListener): Promise<EventSubscription> {
+        const volumeId = treeEventScopeId;
         this.logger.debug(`Creating volume event manager for volume ${volumeId}`);
-        const manager = this.createVolumeEventManager(volumeId, isOwnVolume);
-
-        // FIXME: Use dynamic algorithm to determine polling interval for non-own volumes.
-        manager.setPollingInterval(isOwnVolume ? OWN_VOLUME_POLLING_INTERVAL : OTHER_VOLUME_POLLING_INTERVAL);
-        if (this.subscribedToRemoteDataUpdates) {
-            await manager.startSubscription();
+        let manager = this.volumeEventManagers[volumeId];
+        let started = true;
+        if (manager === undefined) {
+            manager = await this.createVolumeEventManager(volumeId);
+            this.volumeEventManagers[volumeId] = manager;
+            started = false;
             this.sendNumberOfVolumeSubscriptionsToTelemetry();
         }
+        const eventSubscription = manager.addListener(callback);
+        if (!started) {
+            await manager.start();
+        }
+        return eventSubscription;
     }
 
-    private async loadSubscribedVolumeEventServices() {
-        for (const volumeId of await this.cache.getSubscribedVolumeIds()) {
-            if (!this.volumesEvents[volumeId]) {
-                const isOwnVolume = await this.cache.isOwnVolume(volumeId) || false;
-                this.createVolumeEventManager(volumeId, isOwnVolume);
+    // FIXME: Allow to pass own core events manager from the public interface.
+    async subscribeToCoreEvents(callback: DriveListener): Promise<EventSubscription> {
+        if (this.latestEventIdProvider === null || this.latestEventIdProvider === undefined) {
+            throw new Error(
+                'Cannot subscribe to events without passing a latestEventIdProvider in ProtonDriveClient initialization',
+            );
+        }
+        if (this.coreEvents === undefined) {
+            const coreEventManager = new CoreEventManager(this.logger, this.apiService);
+            const latestEventId = this.latestEventIdProvider.getLatestEventId('core') ?? null;
+            this.coreEvents = new EventManager(coreEventManager, CORE_POLLING_INTERVAL, latestEventId);
+            for (const listener of this.cacheEventListeners) {
+                this.coreEvents.addListener(listener);
             }
         }
+        const eventSubscription = this.coreEvents.addListener(callback);
+        await this.coreEvents.start();
+        return eventSubscription;
     }
 
     private sendNumberOfVolumeSubscriptionsToTelemetry() {
         this.telemetry.logEvent({
             eventName: 'volumeEventsSubscriptionsChanged',
-            numberOfVolumeSubscriptions: Object.keys(this.volumesEvents).length,
+            numberOfVolumeSubscriptions: Object.keys(this.volumeEventManagers).length,
         });
     }
 
-    private createVolumeEventManager(volumeId: string, isOwnVolume: boolean): VolumeEventManager {
-        const manager = new VolumeEventManager(this.logger, this.apiService, this.cache, volumeId, isOwnVolume);
-        for (const listener of this.listeners) {
-            manager.addListener(listener);
+    private async createVolumeEventManager(volumeId: string): Promise<EventManager<DriveEvent>> {
+        if (this.latestEventIdProvider === null || this.latestEventIdProvider === undefined) {
+            throw new Error(
+                'Cannot subscribe to events without passing a latestEventIdProvider in ProtonDriveClient initialization',
+            );
+        }
+        const isOwnVolume = await this.shareManagement.isOwnVolume(volumeId);
+        const pollingInterval = this.getDefaultVolumePollingInterval(isOwnVolume);
+        const volumeEventManager = new VolumeEventManager(this.logger, this.apiService, volumeId);
+        const latestEventId = this.latestEventIdProvider.getLatestEventId(volumeId);
+        const eventManager = new EventManager<DriveEvent>(volumeEventManager, pollingInterval, latestEventId);
+        for (const listener of this.cacheEventListeners) {
+            eventManager.addListener(listener);
         }
-        this.volumesEvents[volumeId] = manager;
-        return manager;
+        await eventManager.start();
+        this.volumeEventManagers[volumeId] = eventManager;
+        return eventManager;
     }
 
-    /**
-     * Listen to the drive events. The listener will be called with the
-     * new events as they arrive.
-     * 
-     * One call always provides events from withing the same volume. The
-     * second argument of the callback `fullRefreshVolumeId` is thus single
-     * ID and if multiple volumes must be fully refreshed, client will
-     * receive multiple calls.
-     */
-    addListener(callback: DriveListener): void {
-        // Add new listener to the list for any new event manager.
-        this.listeners.push(callback);
-
-        // Add new listener to all existings managers.
-        this.coreEvents.addListener(callback);
-        for (const volumeEvents of Object.values(this.volumesEvents)) {
-            volumeEvents.addListener(callback);
-        }
+    private getDefaultVolumePollingInterval(isOwnVolume: boolean): number {
+        return isOwnVolume ? OWN_VOLUME_POLLING_INTERVAL : OTHER_VOLUME_POLLING_INTERVAL;
     }
 }

package/src/internal/events/interface.ts

@@ -1,51 +1,114 @@
+import { Logger } from '../../interface';
+
 /**
  * Callback that accepts list of Drive events and flag whether no
  * event should be processed, but rather full cache refresh should be
  * performed.
- * 
+ *
  * @param fullRefreshVolumeId - ID of the volume that should be fully refreshed.
  */
-export type DriveListener = (events: DriveEvent[], fullRefreshVolumeId?: string) => Promise<void>;
+export type DriveListener = (event: DriveEvent) => Promise<void>;
+
+export interface Event {
+    eventId: string;
+}
+
+export interface EventSubscription {
+    dispose(): void;
+}
+
+export interface LatestEventIdProvider {
+    getLatestEventId(treeEventScopeId: string): string | null;
+}
 
 /**
  * Generic internal event interface representing a list of events
  * with metadata about the last event ID, whether there are more
  * events to fetch, or whether the listener should refresh its state.
  */
-export type Events<T> = {
-    lastEventId: string,
-    more: boolean,
-    refresh: boolean,
-    events: T[],
-}
+export type EventsListWithStatus<T> = {
+    latestEventId: string;
+    more: boolean;
+    refresh: boolean;
+    events: T[];
+};
 
 /**
  * Internal event interface representing a list of specific Drive events.
  */
-export type DriveEvents = Events<DriveEvent>;
-
-export type DriveEvent = {
-    type: DriveEventType.NodeCreated | DriveEventType.NodeUpdated | DriveEventType.NodeUpdatedMetadata,
-    nodeUid: string,
-    parentNodeUid?: string,
-    isTrashed: boolean,
-    isShared: boolean,
-    isOwnVolume: boolean,
-} | {
-    type: DriveEventType.NodeDeleted,
-    nodeUid: string,
-    parentNodeUid?: string,
-    isTrashed?: boolean,
-    isShared?: boolean,
-    isOwnVolume: boolean,
-} | {
-    type: DriveEventType.ShareWithMeUpdated,
-}
+export type DriveEventsListWithStatus = EventsListWithStatus<DriveEvent>;
+
+type NodeCruEventType = DriveEventType.NodeCreated | DriveEventType.NodeUpdated;
+export type NodeEventType = NodeCruEventType | DriveEventType.NodeDeleted;
+
+export type NodeEvent =
+    | {
+          type: NodeCruEventType;
+          nodeUid: string;
+          parentNodeUid?: string;
+          isTrashed: boolean;
+          isShared: boolean;
+          treeEventScopeId: string;
+          eventId: string;
+      }
+    | {
+          type: DriveEventType.NodeDeleted;
+          nodeUid: string;
+          parentNodeUid?: string;
+          treeEventScopeId: string;
+          eventId: string;
+      };
+
+export type FastForwardEvent = {
+    type: DriveEventType.FastForward;
+    treeEventScopeId: string;
+    eventId: string;
+};
+
+export type TreeRefreshEvent = {
+    type: DriveEventType.TreeRefresh;
+    treeEventScopeId: string;
+    eventId: string;
+};
+
+export type TreeRemovalEvent = {
+    type: DriveEventType.TreeRemove;
+    treeEventScopeId: string;
+    eventId: 'none';
+};
+
+export type SharedWithMeUpdated = {
+    type: DriveEventType.SharedWithMeUpdated;
+    eventId: string;
+    treeEventScopeId: 'core';
+};
+
+export type DriveEvent =
+    | NodeEvent
+    | FastForwardEvent
+    | TreeRefreshEvent
+    | TreeRemovalEvent
+    | FastForwardEvent
+    | SharedWithMeUpdated;
 
 export enum DriveEventType {
     NodeCreated = 'node_created',
     NodeUpdated = 'node_updated',
-    NodeUpdatedMetadata = 'node_updated_metadata',
     NodeDeleted = 'node_deleted',
-    ShareWithMeUpdated = 'share_with_me_updated',
+    SharedWithMeUpdated = 'shared_with_me_updated',
+    TreeRefresh = 'tree_refresh',
+    TreeRemove = 'tree_remove',
+    FastForward = 'fast_forward',
+}
+
+/**
+ * This can happen if all shared nodes in that volume where unshared or if the
+ * volume was deleted.
+ */
+export class UnsubscribeFromEventsSourceError extends Error {}
+
+export interface EventManagerInterface<T> {
+    getLatestEventId(): Promise<string>;
+    getEvents(eventId: string): AsyncIterable<T>;
+    getLogger(): Logger;
 }

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

@@ -0,0 +1,239 @@
+import { getMockLogger } from '../../tests/logger';
+import { NotFoundAPIError } from '../apiService';
+import { EventsAPIService } from './apiService';
+import { VolumeEventManager } from './volumeEventManager';
+import { DriveEventsListWithStatus, DriveEventType } from './interface';
+
+jest.mock('./apiService');
+
+describe('VolumeEventManager', () => {
+    let manager: VolumeEventManager;
+    let mockEventsAPIService: jest.Mocked<EventsAPIService>;
+    const mockLogger = getMockLogger();
+    const volumeId = 'volumeId123';
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mockEventsAPIService = {
+            getVolumeLatestEventId: jest.fn(),
+            getVolumeEvents: jest.fn(),
+            getCoreLatestEventId: jest.fn(),
+            getCoreEvents: jest.fn(),
+        } as any;
+
+        manager = new VolumeEventManager(mockLogger, mockEventsAPIService, volumeId);
+    });
+
+    describe('getLatestEventId', () => {
+        it('should return the latest event ID from API', async () => {
+            const expectedEventId = 'eventId123';
+            mockEventsAPIService.getVolumeLatestEventId.mockResolvedValue(expectedEventId);
+
+            const result = await manager.getLatestEventId();
+
+            expect(result).toBe(expectedEventId);
+            expect(mockEventsAPIService.getVolumeLatestEventId).toHaveBeenCalledWith(volumeId);
+        });
+
+        it('should throw UnsubscribeFromEventsSourceError when API returns NotFoundAPIError', async () => {
+            const notFoundError = new NotFoundAPIError('Event not found', 2501);
+            mockEventsAPIService.getVolumeLatestEventId.mockRejectedValue(notFoundError);
+
+            await expect(manager.getLatestEventId()).rejects.toThrow('Event not found');
+        });
+
+        it('should rethrow other errors', async () => {
+            const networkError = new Error('Network error');
+            mockEventsAPIService.getVolumeLatestEventId.mockRejectedValue(networkError);
+
+            await expect(manager.getLatestEventId()).rejects.toThrow('Network error');
+        });
+    });
+
+    describe('getEvents', () => {
+        it('should yield events from API response', async () => {
+            const mockEventsResponse: DriveEventsListWithStatus = {
+                latestEventId: 'eventId456',
+                more: false,
+                refresh: false,
+                events: [
+                    {
+                        type: DriveEventType.NodeCreated,
+                        nodeUid: 'node1',
+                        parentNodeUid: 'parent1',
+                        isTrashed: false,
+                        isShared: false,
+                        treeEventScopeId: volumeId,
+                        eventId: 'eventId456',
+                    },
+                ],
+            };
+
+            mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
+
+            const events = [];
+            for await (const event of manager.getEvents('startEventId')) {
+                events.push(event);
+            }
+
+            expect(events).toEqual(mockEventsResponse.events);
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenCalledWith(volumeId, 'startEventId');
+        });
+
+        it('should continue fetching when more events are available', async () => {
+            const firstResponse: DriveEventsListWithStatus = {
+                latestEventId: 'eventId2',
+                more: true,
+                refresh: false,
+                events: [
+                    {
+                        type: DriveEventType.NodeCreated,
+                        nodeUid: 'node1',
+                        parentNodeUid: 'parent1',
+                        isTrashed: false,
+                        isShared: false,
+                        treeEventScopeId: volumeId,
+                        eventId: 'eventId2',
+                    },
+                ],
+            };
+
+            const secondResponse: DriveEventsListWithStatus = {
+                latestEventId: 'eventId3',
+                more: false,
+                refresh: false,
+                events: [
+                    {
+                        type: DriveEventType.NodeUpdated,
+                        nodeUid: 'node2',
+                        parentNodeUid: 'parent1',
+                        isTrashed: false,
+                        isShared: false,
+                        treeEventScopeId: volumeId,
+                        eventId: 'eventId3',
+                    },
+                ],
+            };
+
+            mockEventsAPIService.getVolumeEvents
+                .mockResolvedValueOnce(firstResponse)
+                .mockResolvedValueOnce(secondResponse);
+
+            const events = [];
+            for await (const event of manager.getEvents('startEventId')) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(2);
+            expect(events[0]).toEqual(firstResponse.events[0]);
+            expect(events[1]).toEqual(secondResponse.events[0]);
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenCalledTimes(2);
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenNthCalledWith(1, volumeId, 'startEventId');
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenNthCalledWith(2, volumeId, 'eventId2');
+        });
+
+        it('should yield TreeRefresh event when refresh is true', async () => {
+            const mockEventsResponse: DriveEventsListWithStatus = {
+                latestEventId: 'eventId789',
+                more: false,
+                refresh: true,
+                events: [],
+            };
+
+            mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
+
+            const events = [];
+            for await (const event of manager.getEvents('startEventId')) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                type: DriveEventType.TreeRefresh,
+                treeEventScopeId: volumeId,
+                eventId: 'eventId789',
+            });
+        });
+
+        it('should yield FastForward event when no events but eventId changed', async () => {
+            const mockEventsResponse: DriveEventsListWithStatus = {
+                latestEventId: 'newEventId',
+                more: false,
+                refresh: false,
+                events: [],
+            };
+
+            mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
+
+            const events = [];
+            for await (const event of manager.getEvents('oldEventId')) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                type: DriveEventType.FastForward,
+                treeEventScopeId: volumeId,
+                eventId: 'newEventId',
+            });
+        });
+
+        it('should yield TreeRemove event when API returns NotFoundAPIError', async () => {
+            const notFoundError = new NotFoundAPIError('Volume not found', 2501);
+            mockEventsAPIService.getVolumeEvents.mockRejectedValue(notFoundError);
+
+            const events = [];
+            try {
+                for await (const event of manager.getEvents('startEventId')) {
+                    events.push(event);
+                }
+            } catch (error) {
+                // The error should be re-thrown, but first it should yield a TreeRemove event
+                expect(error).toBe(notFoundError);
+            }
+
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                type: DriveEventType.TreeRemove,
+                treeEventScopeId: volumeId,
+                eventId: 'none',
+            });
+        });
+
+        it('should rethrow non-NotFoundAPIError errors', async () => {
+            const networkError = new Error('Network error');
+            mockEventsAPIService.getVolumeEvents.mockRejectedValue(networkError);
+
+            const eventGenerator = manager.getEvents('startEventId');
+            const eventIterator = eventGenerator[Symbol.asyncIterator]();
+            await expect(eventIterator.next()).rejects.toThrow('Network error');
+        });
+
+        it('should not yield events when events array is empty and eventId unchanged', async () => {
+            const mockEventsResponse: DriveEventsListWithStatus = {
+                latestEventId: 'sameEventId',
+                more: false,
+                refresh: false,
+                events: [],
+            };
+
+            mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
+
+            const events = [];
+            for await (const event of manager.getEvents('sameEventId')) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(0);
+        });
+    });
+
+    describe('getLogger', () => {
+        it('should return logger with prefix', () => {
+            const logger = manager.getLogger();
+            expect(logger).toBeDefined();
+            // The logger should be wrapped with LoggerWithPrefix, but we can't easily test the prefix
+        });
+    });
+});