@protontech/drive-sdk 0.0.13 → 0.1.0

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

package/src/internal/nodes/cache.ts

@@ -6,6 +6,7 @@ import { DecryptedNode, DecryptedRevision } from "./interface";
 export enum CACHE_TAG_KEYS {
     ParentUid = 'nodeParentUid',
     Trashed = 'nodeTrashed',
+    Roots = 'nodeRoot',
 }
 
 type DecryptedNodeResult = (
@@ -15,10 +16,10 @@ type DecryptedNodeResult = (
 
 /**
  * Provides caching for nodes metadata.
- * 
+ *
  * The cache is responsible for serialising and deserialising node metadata,
  * recording parent-child relationships, and recursively removing nodes.
- * 
+ *
  * The cache of node metadata should not contain any crypto material.
  */
 export class NodesCache {
@@ -35,6 +36,8 @@ export class NodesCache {
         const tags = [`volume:${volumeId}`];
         if (node.parentUid) {
             tags.push(`${CACHE_TAG_KEYS.ParentUid}:${node.parentUid}`)
+        } else {
+            tags.push(`${CACHE_TAG_KEYS.Roots}:${volumeId}`)
         }
         if (node.trashTime) {
             tags.push(`${CACHE_TAG_KEYS.Trashed}`)
@@ -74,6 +77,17 @@ export class NodesCache {
         }
     }
 
+    /**
+     * Remove all entries associated with a volume.
+     *
+     * This is needed when a user looses access to a volume.
+     */
+    async removeVolume(volumeId: string): Promise<void> {
+        for await (const result of this.iterateRootNodeUids(volumeId)) {
+            await this.removeNodes([result.key]);
+        }
+    }
+
     /**
      * Remove corrupted node never throws, but it logs so we can know
      * about issues and fix them. It is crucial to remove corrupted
@@ -142,6 +156,10 @@ export class NodesCache {
         }
     }
 
+    async *iterateRootNodeUids(volumeId: string): AsyncGenerator<EntityResult<string>> {
+        yield* this.driveCache.iterateEntitiesByTag(`${CACHE_TAG_KEYS.Roots}:${volumeId}`);
+    }
+
     async *iterateTrashedNodes(): AsyncGenerator<DecryptedNodeResult> {
         for await (const result of this.driveCache.iterateEntitiesByTag(CACHE_TAG_KEYS.Trashed)) {
             const node = await this.convertCacheResult(result);

package/src/internal/nodes/cryptoService.ts

@@ -422,7 +422,7 @@ export class NodesCryptoService {
     };
 
     async moveNode(
-        node: DecryptedNode,
+        node: Pick<DecryptedNode, 'name'>,
         keys: { passphrase: string, passphraseSessionKey: SessionKey, nameSessionKey: SessionKey },
         parentKeys: { key: PrivateKey, hashKey: Uint8Array },
         address: { email: string, addressKey: PrivateKey },