@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/internal/download/thumbnailDownloader.ts

@@ -1,11 +1,11 @@
 import { c } from 'ttag';
 
-import { NodeType, ThumbnailType, ProtonDriveTelemetry, Logger, ThumbnailResult } from "../../interface";
+import { NodeType, ThumbnailType, ProtonDriveTelemetry, Logger, ThumbnailResult } from '../../interface';
 import { ValidationError } from '../../errors';
 import { LoggerWithPrefix } from '../../telemetry';
-import { DownloadAPIService } from "./apiService";
-import { DownloadCryptoService } from "./cryptoService";
-import { NodesService } from "./interface";
+import { DownloadAPIService } from './apiService';
+import { DownloadCryptoService } from './cryptoService';
+import { NodesService } from './interface';
 import { getErrorMessage } from '../errors';
 
 /**
@@ -24,8 +24,8 @@ export class ThumbnailDownloader {
     private batchThumbnailToNodeUids = new Map<string, string>();
     private ongoingDownloads = new Map<string, Promise<void>>();
     private bufferedThumbnails: (
-        { nodeUid: string, ok: true, thumbnail: Uint8Array } |
-        { nodeUid: string, ok: false, error: string }
+        | { nodeUid: string; ok: true; thumbnail: Uint8Array }
+        | { nodeUid: string; ok: false; error: string }
     )[] = [];
 
     constructor(
@@ -34,7 +34,7 @@ export class ThumbnailDownloader {
         private apiService: DownloadAPIService,
         private cryptoService: DownloadCryptoService,
     ) {
-        this.logger = telemetry.getLogger("download");
+        this.logger = telemetry.getLogger('download');
         this.nodesService = nodesService;
         this.apiService = apiService;
         this.cryptoService = cryptoService;
@@ -79,40 +79,41 @@ export class ThumbnailDownloader {
         this.bufferedThumbnails = [];
     }
 
-    private async *iterateThumbnailUids(nodeUids: string[], thumbnailType: ThumbnailType, signal?: AbortSignal): AsyncGenerator<
-        { nodeUid: string, ok: true, thumbnailUid: string } |
-        { nodeUid: string, ok: false, error: string }
+    private async *iterateThumbnailUids(
+        nodeUids: string[],
+        thumbnailType: ThumbnailType,
+        signal?: AbortSignal,
+    ): AsyncGenerator<
+        { nodeUid: string; ok: true; thumbnailUid: string } | { nodeUid: string; ok: false; error: string }
     > {
         for await (const node of this.nodesService.iterateNodes(nodeUids, signal)) {
             if ('missingUid' in node) {
                 yield {
                     nodeUid: node.missingUid,
                     ok: false,
-                    error: c("Error").t`Node not found`,
-                }
+                    error: c('Error').t`Node not found`,
+                };
                 continue;
             }
             if (node.type !== NodeType.File) {
                 yield {
                     nodeUid: node.uid,
                     ok: false,
-                    error: c("Error").t`Node is not a file`,
-                }
+                    error: c('Error').t`Node is not a file`,
+                };
                 continue;
             }
 
             let thumbnail;
             if (node.activeRevision?.ok) {
-                thumbnail = node.activeRevision.value.thumbnails?.find(
-                    (t) => t.type === thumbnailType,
-                );
+                thumbnail = node.activeRevision.value.thumbnails?.find((t) => t.type === thumbnailType);
             }
             if (!thumbnail) {
                 yield {
                     nodeUid: node.uid,
                     ok: false,
-                    error: c("Error").t`Node has no thumbnail`,
-                }
+                    error: c('Error').t`Node has no thumbnail`,
+                };
                 continue;
             }
 
@@ -120,7 +121,7 @@ export class ThumbnailDownloader {
                 nodeUid: node.uid,
                 ok: true,
                 thumbnailUid: thumbnail.uid,
-            }
+            };
         }
     }
 
@@ -163,13 +164,15 @@ export class ThumbnailDownloader {
                     }),
             );
         }
-        
+
         this.batchThumbnailToNodeUids.clear();
     }
 
-    private async *iterateThumbnailDownloads(signal?: AbortSignal): AsyncGenerator<
-        { nodeUid: string, ok: true, downloadPromise: Promise<Uint8Array> } |
-        { nodeUid: string, ok: false, error: string }
+    private async *iterateThumbnailDownloads(
+        signal?: AbortSignal,
+    ): AsyncGenerator<
+        | { nodeUid: string; ok: true; downloadPromise: Promise<Uint8Array> }
+        | { nodeUid: string; ok: false; error: string }
     > {
         const missingThumbnailUids = new Set(this.batchThumbnailToNodeUids.keys());
 
@@ -190,7 +193,7 @@ export class ThumbnailDownloader {
                     nodeUid,
                     ok: false,
                     error: result.error,
-                }
+                };
                 continue;
             }
 
@@ -198,7 +201,7 @@ export class ThumbnailDownloader {
                 nodeUid,
                 ok: true,
                 downloadPromise: this.downloadThumbnail(nodeUid, result.bareUrl, result.token, signal),
-            }
+            };
         }
 
         for (const uid of missingThumbnailUids) {
@@ -207,14 +210,19 @@ export class ThumbnailDownloader {
             yield {
                 nodeUid,
                 ok: false,
-                error: c("Error").t`Thumbnail not found`,
-            }
+                error: c('Error').t`Thumbnail not found`,
+            };
         }
     }
 
-    private async downloadThumbnail(nodeUid: string, bareUrl: string, token: string, signal?: AbortSignal): Promise<Uint8Array> {
+    private async downloadThumbnail(
+        nodeUid: string,
+        bareUrl: string,
+        token: string,
+        signal?: AbortSignal,
+    ): Promise<Uint8Array> {
         const logger = new LoggerWithPrefix(this.logger, `thumbnail ${token}`);
-        
+
         let decryptedBlock: Uint8Array | null = null;
         let attempt = 0;
 
@@ -229,11 +237,14 @@ export class ThumbnailDownloader {
                 ]);
 
                 if (!nodeKeys.contentKeyPacketSessionKey) {
-                    throw new ValidationError(c("Error").t`File has no content key`);
+                    throw new ValidationError(c('Error').t`File has no content key`);
                 }
 
                 logger.debug(`Decrypting`);
-                decryptedBlock = await this.cryptoService.decryptThumbnail(encryptedBlock, nodeKeys.contentKeyPacketSessionKey);
+                decryptedBlock = await this.cryptoService.decryptThumbnail(
+                    encryptedBlock,
+                    nodeKeys.contentKeyPacketSessionKey,
+                );
             } catch (error: unknown) {
                 if (attempt <= MAX_THUMBNAIL_DOWNLOAD_ATTEMPTS) {
                     logger.warn(`Thumbnail download failed #${attempt}, retrying: ${getErrorMessage(error)}`);

package/src/internal/errors.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { VERIFICATION_STATUS } from "../crypto";
+import { VERIFICATION_STATUS } from '../crypto';
 
 export function getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : c('Error').t`Unknown error`;
@@ -9,11 +9,13 @@ export function getErrorMessage(error: unknown): string {
 /**
  * @param signatureType - Must be translated before calling this function.
  */
-export function getVerificationMessage(verified: VERIFICATION_STATUS, signatureType?: string, notAvailableVerificationKeys = false): string {
+export function getVerificationMessage(
+    verified: VERIFICATION_STATUS,
+    signatureType?: string,
+    notAvailableVerificationKeys = false,
+): string {
     if (verified === VERIFICATION_STATUS.NOT_SIGNED) {
-        return signatureType
-            ? c('Error').t`Missing signature for ${signatureType}`
-            : c('Error').t`Missing signature`;
+        return signatureType ? c('Error').t`Missing signature for ${signatureType}` : c('Error').t`Missing signature`;
     }
 
     if (notAvailableVerificationKeys) {

package/src/internal/events/apiService.ts

@@ -1,22 +1,26 @@
-import { DriveAPIService, drivePaths, corePaths } from "../apiService";
-import { makeNodeUid } from "../uids";
-import { DriveEventsListWithStatus, DriveEvent, DriveEventType, NodeEvent, NodeEventType } from "./interface";
+import { DriveAPIService, drivePaths, corePaths } from '../apiService';
+import { makeNodeUid } from '../uids';
+import { DriveEventsListWithStatus, DriveEvent, DriveEventType, NodeEvent, NodeEventType } from './interface';
 
-type GetCoreLatestEventResponse = corePaths['/core/{_version}/events/latest']['get']['responses']['200']['content']['application/json'];
-type GetCoreEventResponse = corePaths['/core/{_version}/events/{id}']['get']['responses']['200']['content']['application/json'];
+type GetCoreLatestEventResponse =
+    corePaths['/core/{_version}/events/latest']['get']['responses']['200']['content']['application/json'];
+type GetCoreEventResponse =
+    corePaths['/core/{_version}/events/{id}']['get']['responses']['200']['content']['application/json'];
 
-type GetVolumeLatestEventResponse = drivePaths['/drive/volumes/{volumeID}/events/latest']['get']['responses']['200']['content']['application/json'];
-type GetVolumeEventResponse = drivePaths['/drive/v2/volumes/{volumeID}/events/{eventID}']['get']['responses']['200']['content']['application/json'];
+type GetVolumeLatestEventResponse =
+    drivePaths['/drive/volumes/{volumeID}/events/latest']['get']['responses']['200']['content']['application/json'];
+type GetVolumeEventResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/events/{eventID}']['get']['responses']['200']['content']['application/json'];
 
 interface VolumeEventTypeMap {
-    [key: number]: NodeEventType,
+    [key: number]: NodeEventType;
 }
 const VOLUME_EVENT_TYPE_MAP: VolumeEventTypeMap = {
     0: DriveEventType.NodeDeleted,
     1: DriveEventType.NodeCreated,
     2: DriveEventType.NodeUpdated,
     3: DriveEventType.NodeUpdated,
-}
+};
 
 /**
  * Provides API communication for fetching events.
@@ -39,11 +43,16 @@ export class EventsAPIService {
         const result = await this.apiService.get<GetCoreEventResponse>(`core/v5/events/${eventId}`);
         // in core/v5/events, refresh is always all apps, value 255
         const refresh = result.Refresh > 0;
-        const events: DriveEvent[] = (refresh || result.DriveShareRefresh?.Action === 2) ? [{
-            type: DriveEventType.SharedWithMeUpdated,
-            eventId: result.EventID,
-            treeEventScopeId: 'core',
-        }] : [];
+        const events: DriveEvent[] =
+            refresh || result.DriveShareRefresh?.Action === 2
+                ? [
+                      {
+                          type: DriveEventType.SharedWithMeUpdated,
+                          eventId: result.EventID,
+                          treeEventScopeId: 'core',
+                      },
+                  ]
+                : [];
 
         return {
             latestEventId: result.EventID,
@@ -54,12 +63,16 @@ export class EventsAPIService {
     }
 
     async getVolumeLatestEventId(volumeId: string): Promise<string> {
-        const result = await this.apiService.get<GetVolumeLatestEventResponse>(`drive/volumes/${volumeId}/events/latest`);
+        const result = await this.apiService.get<GetVolumeLatestEventResponse>(
+            `drive/volumes/${volumeId}/events/latest`,
+        );
         return result.EventID;
     }
 
     async getVolumeEvents(volumeId: string, eventId: string): Promise<DriveEventsListWithStatus> {
-        const result = await this.apiService.get<GetVolumeEventResponse>(`drive/v2/volumes/${volumeId}/events/${eventId}`);
+        const result = await this.apiService.get<GetVolumeEventResponse>(
+            `drive/v2/volumes/${volumeId}/events/${eventId}`,
+        );
         return {
             latestEventId: result.EventID,
             more: result.More,
@@ -69,7 +82,7 @@ export class EventsAPIService {
                 const uids = {
                     nodeUid: makeNodeUid(volumeId, event.Link.LinkID),
                     parentNodeUid: makeNodeUid(volumeId, event.Link.ParentLinkID as string),
-                }
+                };
                 return {
                     type,
                     ...uids,

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

@@ -1,9 +1,9 @@
-import { getMockLogger } from "../../tests/logger";
-import { EventsAPIService } from "./apiService";
-import { DriveEvent, DriveEventsListWithStatus, DriveEventType } from "./interface";
-import { CoreEventManager } from "./coreEventManager";
+import { getMockLogger } from '../../tests/logger';
+import { EventsAPIService } from './apiService';
+import { DriveEvent, DriveEventsListWithStatus, DriveEventType } from './interface';
+import { CoreEventManager } from './coreEventManager';
 
-describe("CoreEventManager", () => {
+describe('CoreEventManager', () => {
     let mockApiService: jest.Mocked<EventsAPIService>;
     let coreEventManager: CoreEventManager;
     const mockLogger = getMockLogger();
@@ -22,9 +22,9 @@ describe("CoreEventManager", () => {
         coreEventManager = new CoreEventManager(mockLogger, mockApiService);
     });
 
-    describe("getLatestEventId", () => {
-        it("should return the latest event ID from API service", async () => {
-            const expectedEventId = "event-123";
+    describe('getLatestEventId', () => {
+        it('should return the latest event ID from API service', async () => {
+            const expectedEventId = 'event-123';
             mockApiService.getCoreLatestEventId.mockResolvedValue(expectedEventId);
 
             const result = await coreEventManager.getLatestEventId();
@@ -33,20 +33,20 @@ describe("CoreEventManager", () => {
             expect(mockApiService.getCoreLatestEventId).toHaveBeenCalledTimes(1);
         });
 
-        it("should handle API service errors", async () => {
-            const error = new Error("API error");
+        it('should handle API service errors', async () => {
+            const error = new Error('API error');
             mockApiService.getCoreLatestEventId.mockRejectedValue(error);
 
-            await expect(coreEventManager.getLatestEventId()).rejects.toThrow("API error");
+            await expect(coreEventManager.getLatestEventId()).rejects.toThrow('API error');
             expect(mockApiService.getCoreLatestEventId).toHaveBeenCalledTimes(1);
         });
     });
 
-    describe("getEvents", () => {
-        const eventId = "event1";
-        const latestEventId = "event2";
+    describe('getEvents', () => {
+        const eventId = 'event1';
+        const latestEventId = 'event2';
 
-        it("should yield ShareWithMeUpdated event when refresh is true", async () => {
+        it('should yield ShareWithMeUpdated event when refresh is true', async () => {
             const mockEvents: DriveEventsListWithStatus = {
                 latestEventId,
                 more: false,
@@ -69,15 +69,15 @@ describe("CoreEventManager", () => {
             expect(mockApiService.getCoreEvents).toHaveBeenCalledWith(eventId);
         });
 
-        it("should yield all events when there are actual events", async () => {
+        it('should yield all events when there are actual events', async () => {
             const mockEvent1: DriveEvent = {
                 type: DriveEventType.SharedWithMeUpdated,
-                eventId: "event-1",
+                eventId: 'event-1',
                 treeEventScopeId: 'core',
             };
             const mockEvent2: DriveEvent = {
                 type: DriveEventType.SharedWithMeUpdated,
-                eventId: "event-2",
+                eventId: 'event-2',
                 treeEventScopeId: 'core',
             };
             const mockEvents: DriveEventsListWithStatus = {

package/src/internal/events/coreEventManager.ts

@@ -1,7 +1,7 @@
-import { Logger } from "../../interface";
-import { LoggerWithPrefix } from "../../telemetry";
-import { EventsAPIService } from "./apiService";
-import { DriveEvent, DriveEventType, EventManagerInterface } from "./interface";
+import { Logger } from '../../interface';
+import { LoggerWithPrefix } from '../../telemetry';
+import { EventsAPIService } from './apiService';
+import { DriveEvent, DriveEventType, EventManagerInterface } from './interface';
 
 /**
  * Combines API and event manager to provide a service for listening to
@@ -15,7 +15,10 @@ import { DriveEvent, DriveEventType, EventManagerInterface } from "./interface";
  * with own implementation.
  */
 export class CoreEventManager implements EventManagerInterface<DriveEvent> {
-    constructor(private logger: Logger, private apiService: EventsAPIService) {
+    constructor(
+        private logger: Logger,
+        private apiService: EventsAPIService,
+    ) {
         this.apiService = apiService;
 
         this.logger = new LoggerWithPrefix(logger, `core`);
@@ -25,7 +28,7 @@ export class CoreEventManager implements EventManagerInterface<DriveEvent> {
         return await this.apiService.getCoreLatestEventId();
     }
 
-    async * getEvents(eventId: string): AsyncIterable<DriveEvent> {
+    async *getEvents(eventId: string): AsyncIterable<DriveEvent> {
         const events = await this.apiService.getCoreEvents(eventId);
         if (events.events.length === 0 && events.latestEventId !== eventId) {
             yield {

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

@@ -1,12 +1,12 @@
-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();
@@ -22,11 +22,7 @@ describe("EventManager", () => {
             getEvents: getEventsMock,
         };
 
-        manager = new EventManager(
-            mockEventManager as any,
-            POLLING_INTERVAL,
-            null,
-        );
+        manager = new EventManager(mockEventManager as any, POLLING_INTERVAL, null);
         const subscription = manager.addListener(listenerMock);
         subscriptions.push(subscription);
     });
@@ -40,28 +36,34 @@ describe("EventManager", () => {
         jest.clearAllMocks();
     });
 
-    it("should start polling when started", async () => {
+    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',
-            }],
+            [
+                {
+                    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* () {
-        });
+        getEventsMock
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents[0];
+            })
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents[1];
+            })
+            .mockImplementationOnce(async function* () {});
 
         expect(getLatestEventIdMock).toHaveBeenCalledTimes(0);
         expect(getEventsMock).toHaveBeenCalledTimes(0);
@@ -76,7 +78,7 @@ describe("EventManager", () => {
         expect(getEventsMock).toHaveBeenCalledWith('EventId2');
     });
 
-    it("should stop polling when stopped", async () => {
+    it('should stop polling when stopped', async () => {
         getLatestEventIdMock.mockResolvedValue('eventId1');
         getEventsMock.mockImplementation(async function* () {
             yield {
@@ -97,7 +99,7 @@ describe("EventManager", () => {
         expect(getEventsMock).toHaveBeenCalledTimes(callsBeforeStop);
     });
 
-    it("should notify all listeners when getting events", async () => {
+    it('should notify all listeners when getting events', async () => {
         getLatestEventIdMock.mockResolvedValue('eventId1');
 
         const mockEvents: DriveEvent[] = [
@@ -112,10 +114,11 @@ describe("EventManager", () => {
             },
         ];
 
-        getEventsMock.mockImplementationOnce(async function* () {
-            yield* mockEvents;
-        }).mockImplementation(async function* () {
-        });
+        getEventsMock
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents;
+            })
+            .mockImplementation(async function* () {});
 
         expect(await manager.start()).toBeUndefined();
         await jest.runOnlyPendingTimersAsync();
@@ -123,9 +126,9 @@ describe("EventManager", () => {
         expect(listenerMock).toHaveBeenNthCalledWith(1, mockEvents[0]);
     });
 
-    it("should propagate unsubscription errors", async () => {
+    it('should propagate unsubscription errors', async () => {
         getLatestEventIdMock.mockImplementation(() => {
-            throw new UnsubscribeFromEventsSourceError("Not found");
+            throw new UnsubscribeFromEventsSourceError('Not found');
         });
 
         await expect(manager.start()).rejects.toThrow(UnsubscribeFromEventsSourceError);
@@ -135,7 +138,7 @@ describe("EventManager", () => {
         expect(getEventsMock).toHaveBeenCalledTimes(0);
     });
 
-    it("should continue processing multiple events", async () => {
+    it('should continue processing multiple events', async () => {
         getLatestEventIdMock.mockResolvedValue('eventId1');
 
         const mockEvents: DriveEvent[] = [
@@ -156,14 +159,16 @@ describe("EventManager", () => {
                 isShared: false,
                 treeEventScopeId: 'volume1',
                 eventId: 'eventId3',
-            }
+            },
         ];
 
-        getEventsMock.mockImplementationOnce(async function* () {
-            yield* mockEvents;
-        }).mockImplementation(async function* () {
-            // Empty generator for subsequent calls
-        });
+        getEventsMock
+            .mockImplementationOnce(async function* () {
+                yield* mockEvents;
+            })
+            .mockImplementation(async function* () {
+                // Empty generator for subsequent calls
+            });
 
         await manager.start();
         await jest.runOnlyPendingTimersAsync();
@@ -174,21 +179,21 @@ describe("EventManager", () => {
 
         getEventsMock.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 () => {
+    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");
+                throw new Error('Network error');
             }
             yield {
                 type: DriveEventType.FastForward,
@@ -218,7 +223,7 @@ describe("EventManager", () => {
         expect(manager['retryIndex']).toEqual(0);
     });
 
-    it("should stop polling when stopped immediately", async () => {
+    it('should stop polling when stopped immediately', async () => {
         getLatestEventIdMock.mockResolvedValue('eventId1');
         getEventsMock.mockImplementation(async function* () {
             yield {
@@ -237,7 +242,7 @@ describe("EventManager", () => {
         expect(getEventsMock).toHaveBeenCalledTimes(1);
     });
 
-    it("should handle empty event streams", async () => {
+    it('should handle empty event streams', async () => {
         getLatestEventIdMock.mockResolvedValue('eventId1');
 
         getEventsMock.mockImplementation(async function* () {

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.
@@ -99,7 +98,9 @@ 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) {
@@ -109,7 +110,7 @@ export class EventManager<T extends Event> {
         this.timeoutHandle = setTimeout(() => {
             this.processPromise = this.processEvents();
         }, this.nextPollTimeout);
-    };
+    }
 
     /**
      * Polling timeout is using exponential backoff with Fibonacci sequence.