@protontech/drive-sdk 0.1.0 → 0.1.1

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";
+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";
+export type { DriveEvent, DriveListener } from './interface';
+export { DriveEventType } from './interface';
 
 const OWN_VOLUME_POLLING_INTERVAL = 30;
 const OTHER_VOLUME_POLLING_INTERVAL = 60;
@@ -25,7 +25,13 @@ export class DriveEventsService {
     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);
@@ -56,7 +62,9 @@ export class DriveEventsService {
     // 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');
+            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);
@@ -80,7 +88,9 @@ export class DriveEventsService {
 
     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');
+            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);
@@ -96,6 +106,6 @@ export class DriveEventsService {
     }
 
     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;
     }
 }

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>;

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

@@ -1,16 +1,16 @@
-import { getMockLogger } from "../../tests/logger";
-import { NotFoundAPIError } from "../apiService";
-import { EventsAPIService } from "./apiService";
-import { VolumeEventManager } from "./volumeEventManager";
-import { DriveEventsListWithStatus, DriveEventType } from "./interface";
+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");
+jest.mock('./apiService');
 
-describe("VolumeEventManager", () => {
+describe('VolumeEventManager', () => {
     let manager: VolumeEventManager;
     let mockEventsAPIService: jest.Mocked<EventsAPIService>;
     const mockLogger = getMockLogger();
-    const volumeId = "volumeId123";
+    const volumeId = 'volumeId123';
 
     beforeEach(() => {
         jest.clearAllMocks();
@@ -22,16 +22,12 @@ describe("VolumeEventManager", () => {
             getCoreEvents: jest.fn(),
         } as any;
 
-        manager = new VolumeEventManager(
-            mockLogger,
-            mockEventsAPIService,
-            volumeId
-        );
+        manager = new VolumeEventManager(mockLogger, mockEventsAPIService, volumeId);
     });
 
-    describe("getLatestEventId", () => {
-        it("should return the latest event ID from API", async () => {
-            const expectedEventId = "eventId123";
+    describe('getLatestEventId', () => {
+        it('should return the latest event ID from API', async () => {
+            const expectedEventId = 'eventId123';
             mockEventsAPIService.getVolumeLatestEventId.mockResolvedValue(expectedEventId);
 
             const result = await manager.getLatestEventId();
@@ -40,83 +36,83 @@ describe("VolumeEventManager", () => {
             expect(mockEventsAPIService.getVolumeLatestEventId).toHaveBeenCalledWith(volumeId);
         });
 
-        it("should throw UnsubscribeFromEventsSourceError when API returns NotFoundAPIError", async () => {
-            const notFoundError = new NotFoundAPIError("Event not found", 2501);
+        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");
+            await expect(manager.getLatestEventId()).rejects.toThrow('Event not found');
         });
 
-        it("should rethrow other errors", async () => {
-            const networkError = new Error("Network error");
+        it('should rethrow other errors', async () => {
+            const networkError = new Error('Network error');
             mockEventsAPIService.getVolumeLatestEventId.mockRejectedValue(networkError);
 
-            await expect(manager.getLatestEventId()).rejects.toThrow("Network error");
+            await expect(manager.getLatestEventId()).rejects.toThrow('Network error');
         });
     });
 
-    describe("getEvents", () => {
-        it("should yield events from API response", async () => {
+    describe('getEvents', () => {
+        it('should yield events from API response', async () => {
             const mockEventsResponse: DriveEventsListWithStatus = {
-                latestEventId: "eventId456",
+                latestEventId: 'eventId456',
                 more: false,
                 refresh: false,
                 events: [
                     {
                         type: DriveEventType.NodeCreated,
-                        nodeUid: "node1",
-                        parentNodeUid: "parent1",
+                        nodeUid: 'node1',
+                        parentNodeUid: 'parent1',
                         isTrashed: false,
                         isShared: false,
                         treeEventScopeId: volumeId,
-                        eventId: "eventId456",
-                    }
+                        eventId: 'eventId456',
+                    },
                 ],
             };
 
             mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
 
             const events = [];
-            for await (const event of manager.getEvents("startEventId")) {
+            for await (const event of manager.getEvents('startEventId')) {
                 events.push(event);
             }
 
             expect(events).toEqual(mockEventsResponse.events);
-            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenCalledWith(volumeId, "startEventId");
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenCalledWith(volumeId, 'startEventId');
         });
 
-        it("should continue fetching when more events are available", async () => {
+        it('should continue fetching when more events are available', async () => {
             const firstResponse: DriveEventsListWithStatus = {
-                latestEventId: "eventId2",
+                latestEventId: 'eventId2',
                 more: true,
                 refresh: false,
                 events: [
                     {
                         type: DriveEventType.NodeCreated,
-                        nodeUid: "node1",
-                        parentNodeUid: "parent1",
+                        nodeUid: 'node1',
+                        parentNodeUid: 'parent1',
                         isTrashed: false,
                         isShared: false,
                         treeEventScopeId: volumeId,
-                        eventId: "eventId2",
-                    }
+                        eventId: 'eventId2',
+                    },
                 ],
             };
 
             const secondResponse: DriveEventsListWithStatus = {
-                latestEventId: "eventId3",
+                latestEventId: 'eventId3',
                 more: false,
                 refresh: false,
                 events: [
                     {
                         type: DriveEventType.NodeUpdated,
-                        nodeUid: "node2",
-                        parentNodeUid: "parent1",
+                        nodeUid: 'node2',
+                        parentNodeUid: 'parent1',
                         isTrashed: false,
                         isShared: false,
                         treeEventScopeId: volumeId,
-                        eventId: "eventId3",
-                    }
+                        eventId: 'eventId3',
+                    },
                 ],
             };
 
@@ -125,7 +121,7 @@ describe("VolumeEventManager", () => {
                 .mockResolvedValueOnce(secondResponse);
 
             const events = [];
-            for await (const event of manager.getEvents("startEventId")) {
+            for await (const event of manager.getEvents('startEventId')) {
                 events.push(event);
             }
 
@@ -133,13 +129,13 @@ describe("VolumeEventManager", () => {
             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");
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenNthCalledWith(1, volumeId, 'startEventId');
+            expect(mockEventsAPIService.getVolumeEvents).toHaveBeenNthCalledWith(2, volumeId, 'eventId2');
         });
 
-        it("should yield TreeRefresh event when refresh is true", async () => {
+        it('should yield TreeRefresh event when refresh is true', async () => {
             const mockEventsResponse: DriveEventsListWithStatus = {
-                latestEventId: "eventId789",
+                latestEventId: 'eventId789',
                 more: false,
                 refresh: true,
                 events: [],
@@ -148,7 +144,7 @@ describe("VolumeEventManager", () => {
             mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
 
             const events = [];
-            for await (const event of manager.getEvents("startEventId")) {
+            for await (const event of manager.getEvents('startEventId')) {
                 events.push(event);
             }
 
@@ -156,13 +152,13 @@ describe("VolumeEventManager", () => {
             expect(events[0]).toEqual({
                 type: DriveEventType.TreeRefresh,
                 treeEventScopeId: volumeId,
-                eventId: "eventId789",
+                eventId: 'eventId789',
             });
         });
 
-        it("should yield FastForward event when no events but eventId changed", async () => {
+        it('should yield FastForward event when no events but eventId changed', async () => {
             const mockEventsResponse: DriveEventsListWithStatus = {
-                latestEventId: "newEventId",
+                latestEventId: 'newEventId',
                 more: false,
                 refresh: false,
                 events: [],
@@ -171,7 +167,7 @@ describe("VolumeEventManager", () => {
             mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
 
             const events = [];
-            for await (const event of manager.getEvents("oldEventId")) {
+            for await (const event of manager.getEvents('oldEventId')) {
                 events.push(event);
             }
 
@@ -179,17 +175,17 @@ describe("VolumeEventManager", () => {
             expect(events[0]).toEqual({
                 type: DriveEventType.FastForward,
                 treeEventScopeId: volumeId,
-                eventId: "newEventId",
+                eventId: 'newEventId',
             });
         });
 
-        it("should yield TreeRemove event when API returns NotFoundAPIError", async () => {
-            const notFoundError = new NotFoundAPIError("Volume not found", 2501);
+        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")) {
+                for await (const event of manager.getEvents('startEventId')) {
                     events.push(event);
                 }
             } catch (error) {
@@ -205,18 +201,18 @@ describe("VolumeEventManager", () => {
             });
         });
 
-        it("should rethrow non-NotFoundAPIError errors", async () => {
-            const networkError = new Error("Network error");
+        it('should rethrow non-NotFoundAPIError errors', async () => {
+            const networkError = new Error('Network error');
             mockEventsAPIService.getVolumeEvents.mockRejectedValue(networkError);
 
-            const eventGenerator = manager.getEvents("startEventId");
+            const eventGenerator = manager.getEvents('startEventId');
             const eventIterator = eventGenerator[Symbol.asyncIterator]();
-            await expect(eventIterator.next()).rejects.toThrow("Network error");
+            await expect(eventIterator.next()).rejects.toThrow('Network error');
         });
 
-        it("should not yield events when events array is empty and eventId unchanged", async () => {
+        it('should not yield events when events array is empty and eventId unchanged', async () => {
             const mockEventsResponse: DriveEventsListWithStatus = {
-                latestEventId: "sameEventId",
+                latestEventId: 'sameEventId',
                 more: false,
                 refresh: false,
                 events: [],
@@ -225,7 +221,7 @@ describe("VolumeEventManager", () => {
             mockEventsAPIService.getVolumeEvents.mockResolvedValue(mockEventsResponse);
 
             const events = [];
-            for await (const event of manager.getEvents("sameEventId")) {
+            for await (const event of manager.getEvents('sameEventId')) {
                 events.push(event);
             }
 
@@ -233,8 +229,8 @@ describe("VolumeEventManager", () => {
         });
     });
 
-    describe("getLogger", () => {
-        it("should return logger with prefix", () => {
+    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,17 +1,26 @@
-import { Logger } from "../../interface";
-import { LoggerWithPrefix } from "../../telemetry";
-import { EventsAPIService } from "./apiService";
-import { DriveEvent, DriveEventsListWithStatus, DriveEventType, EventManagerInterface, UnsubscribeFromEventsSourceError } from "./interface";
-import { NotFoundAPIError } from "../apiService";
+import { Logger } from '../../interface';
+import { LoggerWithPrefix } from '../../telemetry';
+import { EventsAPIService } from './apiService';
+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 implements EventManagerInterface<DriveEvent>{
-
-    constructor(private logger: Logger, private apiService: EventsAPIService, private volumeId: string) {
+export class VolumeEventManager implements EventManagerInterface<DriveEvent> {
+    constructor(
+        private logger: Logger,
+        private apiService: EventsAPIService,
+        private volumeId: string,
+    ) {
         this.apiService = apiService;
         this.volumeId = volumeId;
         this.logger = new LoggerWithPrefix(logger, `volume ${volumeId}`);
@@ -21,7 +30,7 @@ export class VolumeEventManager implements EventManagerInterface<DriveEvent>{
         return this.logger;
     }
 
-    async * getEvents(eventId: string): AsyncIterable<DriveEvent> {
+    async *getEvents(eventId: string): AsyncIterable<DriveEvent> {
         try {
             let events: DriveEventsListWithStatus;
             let more = true;