@protontech/drive-sdk 0.1.0 → 0.1.2

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;