@protontech/drive-sdk 0.0.12 → 0.1.0

package/src/internal/events/index.ts

@@ -1,16 +1,18 @@
-import { ProtonDriveEntitiesCache, Logger, ProtonDriveTelemetry } from "../../interface";
+import { Logger, ProtonDriveTelemetry } from "../../interface";
 import { DriveAPIService } from "../apiService";
-import { DriveListener } from "./interface";
+import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider } from "./interface";
 import { EventsAPIService } from "./apiService";
-import { EventsCache } from "./cache";
 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,81 @@ 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 = {};
+        this.volumeEventManagers = {};
     }
 
     /**
-     * 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.
+     * Subscribe to drive events. The treeEventScopeId can be obtained from a node.
      */
-    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())
-        );
-    }
-
-    /**
-     * 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.
-     */
-    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,19 +1,33 @@
+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,
+export type EventsListWithStatus<T> = {
+    latestEventId: string,
     more: boolean,
     refresh: boolean,
     events: T[],
@@ -22,30 +36,71 @@ export type Events<T> = {
 /**
  * Internal event interface representing a list of specific Drive events.
  */
-export type DriveEvents = Events<DriveEvent>;
+export type DriveEventsListWithStatus = EventsListWithStatus<DriveEvent>;
+
+type NodeCruEventType = DriveEventType.NodeCreated | DriveEventType.NodeUpdated;
+export type NodeEventType = NodeCruEventType | DriveEventType.NodeDeleted;
 
-export type DriveEvent = {
-    type: DriveEventType.NodeCreated | DriveEventType.NodeUpdated | DriveEventType.NodeUpdatedMetadata,
+export type NodeEvent = {
+    type: NodeCruEventType,
     nodeUid: string,
     parentNodeUid?: string,
     isTrashed: boolean,
     isShared: boolean,
-    isOwnVolume: boolean,
+    treeEventScopeId: string,
+    eventId: string,
 } | {
     type: DriveEventType.NodeDeleted,
     nodeUid: string,
     parentNodeUid?: string,
-    isTrashed?: boolean,
-    isShared?: boolean,
-    isOwnVolume: boolean,
-} | {
-    type: DriveEventType.ShareWithMeUpdated,
+    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,243 @@
+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
+        });
+    });
+});

package/src/internal/events/volumeEventManager.ts

@@ -1,74 +1,76 @@
 import { Logger } from "../../interface";
 import { LoggerWithPrefix } from "../../telemetry";
 import { EventsAPIService } from "./apiService";
-import { EventsCache } from "./cache";
-import { DriveEvent, DriveListener } from "./interface";
-import { EventManager } from "./eventManager";
+import { DriveEvent, DriveEventsListWithStatus, DriveEventType, EventManagerInterface, UnsubscribeFromEventsSourceError } from "./interface";
+import { NotFoundAPIError } from "../apiService";
 
 /**
  * Combines API and event manager to provide a service for listening to
  * volume events. Volume events are all about nodes updates. Whenever
  * there is update to the node metadata or content, the event is emitted.
  */
-export class VolumeEventManager {
-    private manager: EventManager<DriveEvent>;
+export class VolumeEventManager implements EventManagerInterface<DriveEvent>{
 
-    constructor(logger: Logger, private apiService: EventsAPIService, private cache: EventsCache, private volumeId: string, isOwnVolume: boolean) {
+    constructor(private logger: Logger, private apiService: EventsAPIService, private volumeId: string) {
         this.apiService = apiService;
         this.volumeId = volumeId;
-
-        this.manager = new EventManager(
-            new LoggerWithPrefix(logger, `volume ${volumeId}`),
-            () => this.getLastEventId(),
-            (eventId) => this.apiService.getVolumeEvents(volumeId, eventId, isOwnVolume),
-            (lastEventId) => this.cache.setLastEventId(volumeId, {
-                lastEventId,
-                pollingIntervalInSeconds: this.manager.pollingIntervalInSeconds,
-                isOwnVolume
-            }),
-        );
-        this.cache.getPollingIntervalInSeconds(volumeId)
-            .then((pollingIntervalInSeconds) => {
-                if (pollingIntervalInSeconds) {
-                    this.manager.pollingIntervalInSeconds = pollingIntervalInSeconds;
-                }
-            })
-            .catch(() => {});
-    }
-
-    private async getLastEventId(): Promise<string> {
-        const lastEventId = await this.cache.getLastEventId(this.volumeId);
-        if (lastEventId) {
-            return lastEventId;
-        }
-        return this.apiService.getVolumeLatestEventId(this.volumeId);
-    }
-
-    /**
-     * There is a limit how many volume subscribtions can be active at
-     * the same time. The manager of all volume managers should set the
-     * intervals for each volume accordingly depending on the volume
-     * type or the total number of subscriptions.
-     */
-    setPollingInterval(pollingIntervalInSeconds: number): void {
-        this.manager.pollingIntervalInSeconds = pollingIntervalInSeconds;
+        this.logger = new LoggerWithPrefix(logger, `volume ${volumeId}`);
     }
 
-    async startSubscription(): Promise<void> {
-        await this.manager.start();
+    getLogger(): Logger {
+        return this.logger;
     }
 
-    async stopSubscription(): Promise<void> {
-        await this.manager.stop();
+    async * getEvents(eventId: string): AsyncIterable<DriveEvent> {
+        try {
+            let events: DriveEventsListWithStatus;
+            let more = true;
+            while (more) {
+                events = await this.apiService.getVolumeEvents(this.volumeId, eventId);
+                more = events.more;
+                if (events.refresh) {
+                    yield {
+                        type: DriveEventType.TreeRefresh,
+                        treeEventScopeId: this.volumeId,
+                        eventId: events.latestEventId,
+                    };
+                    break;
+                }
+                // Update to the latest eventId to avoid inactive volumes from getting out of sync
+                if (events.events.length === 0 && events.latestEventId !== eventId) {
+                    yield {
+                        type: DriveEventType.FastForward,
+                        treeEventScopeId: this.volumeId,
+                        eventId: events.latestEventId,
+                    };
+                    break;
+                }
+                yield* events.events;
+                eventId = events.latestEventId;
+            }
+        } catch (error: unknown) {
+            if (error instanceof NotFoundAPIError) {
+                this.logger.info(`Volume events no longer accessible`);
+                yield {
+                    type: DriveEventType.TreeRemove,
+                    treeEventScopeId: this.volumeId,
+                    // After a TreeRemoval event, polling should stop.
+                    eventId: 'none',
+                };
+            }
+            throw error;
+        }
     }
 
-    addListener(callback: DriveListener): void {
-        this.manager.addListener(async (events, fullRefresh) => {
-            if (fullRefresh) {
-                await callback([], this.volumeId);
-            } else {
-                await callback(events);
+    async getLatestEventId(): Promise<string> {
+        try {
+            return await this.apiService.getVolumeLatestEventId(this.volumeId);
+        } catch (error: unknown) {
+            if (error instanceof NotFoundAPIError) {
+                this.logger.info(`Volume events no longer accessible`);
+                throw new UnsubscribeFromEventsSourceError(error.message);
             }
-        });
+            throw error;
+        }
     }
 }