@protontech/drive-sdk 0.1.0 → 0.1.2

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

@@ -1,32 +1,24 @@
-import { getMockLogger } from "../../tests/logger";
-import { EventManager } from "./eventManager";
-import { DriveEvent, DriveEventType, EventSubscription, UnsubscribeFromEventsSourceError } from "./interface";
+import { getMockLogger } from '../../tests/logger';
+import { EventManager } from './eventManager';
+import { DriveEvent, DriveEventType, EventSubscription, UnsubscribeFromEventsSourceError } from './interface';
 
 jest.useFakeTimers();
 
 const POLLING_INTERVAL = 1;
 
-describe("EventManager", () => {
+describe('EventManager', () => {
     let manager: EventManager<DriveEvent>;
 
-    const getLatestEventIdMock = jest.fn();
-    const getEventsMock = jest.fn();
     const listenerMock = jest.fn();
-    const mockLogger = getMockLogger();
     const subscriptions: EventSubscription[] = [];
+    const mockEventManager = {
+        getLogger: () => getMockLogger(),
+        getLatestEventId: jest.fn(),
+        getEvents: jest.fn(),
+    };
 
     beforeEach(() => {
-        const mockEventManager = {
-            getLogger: () => mockLogger,
-            getLatestEventId: getLatestEventIdMock,
-            getEvents: getEventsMock,
-        };
-
-        manager = new EventManager(
-            mockEventManager as any,
-            POLLING_INTERVAL,
-            null,
-        );
+        manager = new EventManager(mockEventManager, POLLING_INTERVAL, null);
         const subscription = manager.addListener(listenerMock);
         subscriptions.push(subscription);
     });
@@ -40,45 +32,52 @@ describe("EventManager", () => {
         jest.clearAllMocks();
     });
 
-    it("should start polling when started", async () => {
-        getLatestEventIdMock.mockResolvedValue('EventId1');
+    it('should start polling when started', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('EventId1');
 
         const mockEvents: DriveEvent[][] = [
-            [{
-                type: DriveEventType.FastForward,
-                treeEventScopeId: 'volume1',
-                eventId: 'EventId2',
-            }],
-            [{
-                type: DriveEventType.FastForward,
-                treeEventScopeId: 'volume1',
-                eventId: 'EventId3',
-            }],
+            [
+                {
+                    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* () {
-        });
+        mockEventManager.getEvents
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents[0];
+            })
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents[1];
+            })
+            .mockImplementationOnce(async function* () {});
 
-        expect(getLatestEventIdMock).toHaveBeenCalledTimes(0);
-        expect(getEventsMock).toHaveBeenCalledTimes(0);
+        expect(mockEventManager.getLatestEventId).toHaveBeenCalledTimes(0);
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(0);
 
         expect(await manager.start()).toBeUndefined();
+        await jest.runOnlyPendingTimersAsync();
 
-        expect(getLatestEventIdMock).toHaveBeenCalledTimes(1);
-        expect(getEventsMock).toHaveBeenCalledWith('EventId1');
+        expect(mockEventManager.getLatestEventId).toHaveBeenCalledTimes(1);
+        expect(mockEventManager.getEvents).toHaveBeenCalledWith('EventId1');
 
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(2);
-        expect(getEventsMock).toHaveBeenCalledWith('EventId2');
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(2);
+        expect(mockEventManager.getEvents).toHaveBeenCalledWith('EventId2');
     });
 
-    it("should stop polling when stopped", async () => {
-        getLatestEventIdMock.mockResolvedValue('eventId1');
-        getEventsMock.mockImplementation(async function* () {
+    it('should stop polling when stopped', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('eventId1');
+        mockEventManager.getEvents.mockImplementation(async function* () {
             yield {
                 type: DriveEventType.FastForward,
                 treeEventScopeId: 'volume1',
@@ -89,16 +88,16 @@ describe("EventManager", () => {
         await manager.start();
         await jest.runOnlyPendingTimersAsync();
 
-        const callsBeforeStop = getEventsMock.mock.calls.length;
+        const callsBeforeStop = mockEventManager.getEvents.mock.calls.length;
         await manager.stop();
         await jest.runOnlyPendingTimersAsync();
 
         // Should not have made additional calls after stopping
-        expect(getEventsMock).toHaveBeenCalledTimes(callsBeforeStop);
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(callsBeforeStop);
     });
 
-    it("should notify all listeners when getting events", async () => {
-        getLatestEventIdMock.mockResolvedValue('eventId1');
+    it('should notify all listeners when getting events', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('eventId1');
 
         const mockEvents: DriveEvent[] = [
             {
@@ -112,10 +111,11 @@ describe("EventManager", () => {
             },
         ];
 
-        getEventsMock.mockImplementationOnce(async function* () {
-            yield* mockEvents;
-        }).mockImplementation(async function* () {
-        });
+        mockEventManager.getEvents
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents;
+            })
+            .mockImplementation(async function* () {});
 
         expect(await manager.start()).toBeUndefined();
         await jest.runOnlyPendingTimersAsync();
@@ -123,20 +123,20 @@ describe("EventManager", () => {
         expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
     });
 
-    it("should propagate unsubscription errors", async () => {
-        getLatestEventIdMock.mockImplementation(() => {
-            throw new UnsubscribeFromEventsSourceError("Not found");
+    it('should propagate unsubscription errors', async () => {
+        mockEventManager.getLatestEventId.mockImplementation(() => {
+            throw new UnsubscribeFromEventsSourceError('Not found');
         });
 
         await expect(manager.start()).rejects.toThrow(UnsubscribeFromEventsSourceError);
 
-        expect(getLatestEventIdMock).toHaveBeenCalledTimes(1);
+        expect(mockEventManager.getLatestEventId).toHaveBeenCalledTimes(1);
         expect(listenerMock).toHaveBeenCalledTimes(0);
-        expect(getEventsMock).toHaveBeenCalledTimes(0);
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(0);
     });
 
-    it("should continue processing multiple events", async () => {
-        getLatestEventIdMock.mockResolvedValue('eventId1');
+    it('should continue processing multiple events', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('eventId1');
 
         const mockEvents: DriveEvent[] = [
             {
@@ -156,14 +156,16 @@ describe("EventManager", () => {
                 isShared: false,
                 treeEventScopeId: 'volume1',
                 eventId: 'eventId3',
-            }
+            },
         ];
 
-        getEventsMock.mockImplementationOnce(async function* () {
-            yield* mockEvents;
-        }).mockImplementation(async function* () {
-            // Empty generator for subsequent calls
-        });
+        mockEventManager.getEvents
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents;
+            })
+            .mockImplementation(async function* () {
+                // Empty generator for subsequent calls
+            });
 
         await manager.start();
         await jest.runOnlyPendingTimersAsync();
@@ -172,23 +174,23 @@ describe("EventManager", () => {
         expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
         expect(listenerMock).toHaveBeenNthCalledWith(2, mockEvents[1]);
 
-        getEventsMock.mockImplementationOnce(async function* () {
+        mockEventManager.getEvents.mockImplementationOnce(async function* () {
             yield* mockEvents;
-        })
+        });
         await jest.runOnlyPendingTimersAsync();
         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');
+    it('should retry on error with exponential backoff', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('eventId1');
 
         let callCount = 0;
-        getEventsMock.mockImplementation(async function* () {
+        mockEventManager.getEvents.mockImplementation(async function* () {
             callCount++;
             if (callCount <= 3) {
-                throw new Error("Network error");
+                throw new Error('Network error');
             }
             yield {
                 type: DriveEventType.FastForward,
@@ -200,11 +202,12 @@ describe("EventManager", () => {
         expect(manager['retryIndex']).toEqual(0);
 
         expect(await manager.start()).toBeUndefined();
-        expect(getEventsMock).toHaveBeenCalledTimes(1);
+        await jest.runOnlyPendingTimersAsync();
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(1);
         expect(manager['retryIndex']).toEqual(1);
 
         await jest.runOnlyPendingTimersAsync();
-        expect(getEventsMock).toHaveBeenCalledTimes(2);
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(2);
         expect(manager['retryIndex']).toEqual(2);
 
         await jest.runOnlyPendingTimersAsync();
@@ -218,9 +221,9 @@ describe("EventManager", () => {
         expect(manager['retryIndex']).toEqual(0);
     });
 
-    it("should stop polling when stopped immediately", async () => {
-        getLatestEventIdMock.mockResolvedValue('eventId1');
-        getEventsMock.mockImplementation(async function* () {
+    it('should stop polling when stopped immediately', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('eventId1');
+        mockEventManager.getEvents.mockImplementation(async function* () {
             yield {
                 type: DriveEventType.FastForward,
                 treeEventScopeId: 'volume1',
@@ -229,18 +232,19 @@ describe("EventManager", () => {
         });
 
         expect(await manager.start()).toBeUndefined();
-        expect(getEventsMock).toHaveBeenCalledTimes(1);
+        await jest.runOnlyPendingTimersAsync();
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(1);
         await manager.stop();
         await jest.runOnlyPendingTimersAsync();
 
         // getEvents should have been called once during start, but not again after stop
-        expect(getEventsMock).toHaveBeenCalledTimes(1);
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(1);
     });
 
-    it("should handle empty event streams", async () => {
-        getLatestEventIdMock.mockResolvedValue('eventId1');
+    it('should handle empty event streams', async () => {
+        mockEventManager.getLatestEventId.mockResolvedValue('eventId1');
 
-        getEventsMock.mockImplementation(async function* () {
+        mockEventManager.getEvents.mockImplementation(async function* () {
             // Empty generator - no events
         });
 
@@ -249,4 +253,26 @@ describe("EventManager", () => {
 
         expect(listenerMock).toHaveBeenCalledTimes(0);
     });
+
+    it('should poll right away after start if latestEventId is passed', async () => {
+        manager = new EventManager(mockEventManager, POLLING_INTERVAL, 'eventId1');
+
+        await manager.start();
+
+        // Right after the start it is called.
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not poll right away after start if latestEventId is not passed', async () => {
+        manager = new EventManager(mockEventManager, POLLING_INTERVAL, null);
+
+        await manager.start();
+
+        // Right after the start it is not called.
+        expect(mockEventManager.getEvents).not.toHaveBeenCalled();
+
+        // But it is scheduled to be called after the polling interval.
+        await jest.runOnlyPendingTimersAsync();
+        expect(mockEventManager.getEvents).toHaveBeenCalledTimes(1);
+    });
 });

package/src/internal/events/eventManager.ts

@@ -1,11 +1,10 @@
-import { Logger } from "../../interface";
-import { EventManagerInterface, Event, EventSubscription } from "./interface";
+import { Logger } from '../../interface';
+import { EventManagerInterface, Event, EventSubscription } from './interface';
 
 const FIBONACCI_LIST = [1, 1, 2, 3, 5, 8, 13];
 
 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.
@@ -39,8 +38,11 @@ export class EventManager<T extends Event> {
     }
 
     async start(): Promise<void> {
+        this.logger.info(`Starting event manager with latestEventId: ${this.latestEventId}`);
         if (this.latestEventId === undefined) {
             this.latestEventId = await this.specializedEventManager.getLatestEventId();
+            this.scheduleNextPoll();
+            return;
         }
         this.processPromise = this.processEvents();
     }
@@ -99,17 +101,26 @@ export class EventManager<T extends Event> {
             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.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.scheduleNextPoll();
+    }
+
+    private scheduleNextPoll() {
+        if (this.timeoutHandle) {
+            clearTimeout(this.timeoutHandle);
+        }
         this.timeoutHandle = setTimeout(() => {
             this.processPromise = this.processEvents();
         }, this.nextPollTimeout);
-    };
+    }
 
     /**
      * Polling timeout is using exponential backoff with Fibonacci sequence.

package/src/internal/events/index.ts

@@ -1,14 +1,14 @@
-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";
+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;
@@ -21,81 +21,109 @@ const CORE_POLLING_INTERVAL = 30;
  */
 export class DriveEventsService {
     private apiService: EventsAPIService;
-    private coreEvents?: EventManager<DriveEvent>;
+    private coreEventManager?: EventManager<DriveEvent>;
     private volumeEventManagers: { [volumeId: string]: EventManager<DriveEvent> };
     private logger: Logger;
 
-    constructor(private telemetry: ProtonDriveTelemetry, apiService: DriveAPIService, private shareManagement: SharesManager, private cacheEventListeners: DriveListener[] = [], private latestEventIdProvider?: LatestEventIdProvider) {
+    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.volumeEventManagers = {};
     }
 
+    // FIXME: Allow to pass own core events manager from the public interface.
+    async subscribeToCoreEvents(callback: DriveListener): Promise<EventSubscription> {
+        let manager = this.coreEventManager;
+        const started = !!manager;
+
+        if (manager === undefined) {
+            manager = await this.createCoreEventManager();
+            this.coreEventManager = manager;
+        }
+
+        const eventSubscription = manager.addListener(callback);
+        if (!started) {
+            await manager.start();
+        }
+        return eventSubscription;
+    }
+
+    private async createCoreEventManager() {
+        if (!this.latestEventIdProvider) {
+            throw new Error(
+                'Cannot subscribe to events without passing a latestEventIdProvider in ProtonDriveClient initialization',
+            );
+        }
+
+        const coreEventManager = new CoreEventManager(this.logger, this.apiService);
+        const latestEventId = this.latestEventIdProvider.getLatestEventId('core') ?? null;
+        const eventManager = new EventManager(coreEventManager, CORE_POLLING_INTERVAL, latestEventId);
+
+        for (const listener of this.cacheEventListeners) {
+            eventManager.addListener(listener);
+        }
+
+        return eventManager;
+    }
+
     /**
      * Subscribe to drive events. The treeEventScopeId can be obtained from a node.
      */
     async subscribeToTreeEvents(treeEventScopeId: string, callback: DriveListener): Promise<EventSubscription> {
         const volumeId = treeEventScopeId;
-        this.logger.debug(`Creating volume event manager for volume ${volumeId}`);
         let manager = this.volumeEventManagers[volumeId];
-        let started = true;
+        const started = !!manager;
+
         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();
+            this.sendNumberOfVolumeSubscriptionsToTelemetry();
         }
         return eventSubscription;
     }
 
-    // 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);
-            }
+    private async createVolumeEventManager(volumeId: string): Promise<EventManager<DriveEvent>> {
+        if (!this.latestEventIdProvider) {
+            throw new Error(
+                'Cannot subscribe to events without passing a latestEventIdProvider in ProtonDriveClient initialization',
+            );
         }
-        const eventSubscription = this.coreEvents.addListener(callback);
-        await this.coreEvents.start();
-        return eventSubscription;
-    }
 
-    private sendNumberOfVolumeSubscriptionsToTelemetry() {
-        this.telemetry.logEvent({
-            eventName: 'volumeEventsSubscriptionsChanged',
-            numberOfVolumeSubscriptions: Object.keys(this.volumeEventManagers).length,
-        });
-    }
+        this.logger.debug(`Creating volume event manager for volume ${volumeId}`);
+        const volumeEventManager = new VolumeEventManager(this.logger, this.apiService, volumeId);
 
-    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);
         }
-        await eventManager.start();
-        this.volumeEventManagers[volumeId] = eventManager;
+
         return eventManager;
     }
 
     private getDefaultVolumePollingInterval(isOwnVolume: boolean): number {
-        return isOwnVolume ? OWN_VOLUME_POLLING_INTERVAL : OTHER_VOLUME_POLLING_INTERVAL
+        return isOwnVolume ? OWN_VOLUME_POLLING_INTERVAL : OTHER_VOLUME_POLLING_INTERVAL;
+    }
+
+    private sendNumberOfVolumeSubscriptionsToTelemetry() {
+        this.telemetry.logEvent({
+            eventName: 'volumeEventsSubscriptionsChanged',
+            numberOfVolumeSubscriptions: Object.keys(this.volumeEventManagers).length,
+        });
     }
 }

package/src/internal/events/interface.ts

@@ -1,4 +1,4 @@
-import { Logger } from "../../interface";
+import { Logger } from '../../interface';
 
 /**
  * Callback that accepts list of Drive events and flag whether no
@@ -27,11 +27,11 @@ export interface LatestEventIdProvider {
  * events to fetch, or whether the listener should refresh its state.
  */
 export type EventsListWithStatus<T> = {
-    latestEventId: string,
-    more: boolean,
-    refresh: boolean,
-    events: T[],
-}
+    latestEventId: string;
+    more: boolean;
+    refresh: boolean;
+    events: T[];
+};
 
 /**
  * Internal event interface representing a list of specific Drive events.
@@ -41,47 +41,55 @@ 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 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,
-}
+    type: DriveEventType.FastForward;
+    treeEventScopeId: string;
+    eventId: string;
+};
 
 export type TreeRefreshEvent = {
-    type: DriveEventType.TreeRefresh,
-    treeEventScopeId: string,
-    eventId: string,
-}
+    type: DriveEventType.TreeRefresh;
+    treeEventScopeId: string;
+    eventId: string;
+};
 
 export type TreeRemovalEvent = {
-    type: DriveEventType.TreeRemove,
-    treeEventScopeId: string,
-    eventId: 'none',
-}
+    type: DriveEventType.TreeRemove;
+    treeEventScopeId: string;
+    eventId: 'none';
+};
 
 export type SharedWithMeUpdated = {
-    type: DriveEventType.SharedWithMeUpdated,
-    eventId: string,
-    treeEventScopeId: 'core',
-}
+    type: DriveEventType.SharedWithMeUpdated;
+    eventId: string;
+    treeEventScopeId: 'core';
+};
 
-export type DriveEvent = NodeEvent | FastForwardEvent | TreeRefreshEvent | TreeRemovalEvent | FastForwardEvent | SharedWithMeUpdated;
+export type DriveEvent =
+    | NodeEvent
+    | FastForwardEvent
+    | TreeRefreshEvent
+    | TreeRemovalEvent
+    | FastForwardEvent
+    | SharedWithMeUpdated;
 
 export enum DriveEventType {
     NodeCreated = 'node_created',
@@ -97,7 +105,7 @@ export enum DriveEventType {
  * This can happen if all shared nodes in that volume where unshared or if the
  * volume was deleted.
  */
-export class UnsubscribeFromEventsSourceError extends Error {};
+export class UnsubscribeFromEventsSourceError extends Error {}
 
 export interface EventManagerInterface<T> {
     getLatestEventId(): Promise<string>;