@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/events/volumeEventManager.ts

@@ -1,74 +1,85 @@
-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 { 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 {
-    private manager: EventManager<DriveEvent>;
-
-    constructor(logger: Logger, private apiService: EventsAPIService, private cache: EventsCache, private volumeId: string, isOwnVolume: boolean) {
+export class VolumeEventManager implements EventManagerInterface<DriveEvent> {
+    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/apiService.test.ts

@@ -1,6 +1,6 @@
-import { MemberRole, NodeType } from "../../interface";
-import { getMockLogger } from "../../tests/logger";
-import { DriveAPIService, ErrorCode } from "../apiService";
+import { MemberRole, NodeType } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { DriveAPIService, ErrorCode } from '../apiService';
 import { NodeAPIService } from './apiService';
 
 function generateAPIFileNode(linkOverrides = {}, overrides = {}) {
@@ -81,26 +81,26 @@ function generateFileNode(overrides = {}) {
     return {
         ...node,
         type: NodeType.File,
-        mediaType: "text",
+        mediaType: 'text',
         totalStorageSize: 42,
         encryptedCrypto: {
             ...node.encryptedCrypto,
             file: {
-                base64ContentKeyPacket: "contentKeyPacket",
-                armoredContentKeyPacketSignature: "contentKeyPacketSig",
+                base64ContentKeyPacket: 'contentKeyPacket',
+                armoredContentKeyPacketSignature: 'contentKeyPacketSig',
             },
             activeRevision: {
-                uid: "volumeId~linkId~revisionId",
-                state: "active",
+                uid: 'volumeId~linkId~revisionId',
+                state: 'active',
                 creationTime: new Date(1234567890000),
                 storageSize: 12,
-                signatureEmail: "revSigEmail",
-                armoredExtendedAttributes: "{file}",
+                signatureEmail: 'revSigEmail',
+                armoredExtendedAttributes: '{file}',
                 thumbnails: [],
             },
         },
-        ...overrides
-    }
+        ...overrides,
+    };
 }
 
 function generateFolderNode(overrides = {}) {
@@ -111,12 +111,12 @@ function generateFolderNode(overrides = {}) {
         encryptedCrypto: {
             ...node.encryptedCrypto,
             folder: {
-                armoredHashKey: "nodeHashKey",
-                armoredExtendedAttributes: "{folder}",
+                armoredHashKey: 'nodeHashKey',
+                armoredExtendedAttributes: '{folder}',
             },
         },
-        ...overrides
-    }
+        ...overrides,
+    };
 }
 
 function generateAlbumNode(overrides = {}) {
@@ -124,17 +124,17 @@ function generateAlbumNode(overrides = {}) {
     return {
         ...node,
         type: NodeType.Album,
-        ...overrides
-    }
+        ...overrides,
+    };
 }
 
 function generateNode() {
     return {
-        hash: "nameHash",
-        encryptedName: "encName",
+        hash: 'nameHash',
+        encryptedName: 'encName',
 
-        uid: "volumeId~linkId",
-        parentUid: "volumeId~parentLinkId",
+        uid: 'volumeId~linkId',
+        parentUid: 'volumeId~parentLinkId',
         creationTime: new Date(123456789000),
         trashTime: undefined,
 
@@ -143,16 +143,16 @@ function generateNode() {
         directMemberRole: MemberRole.Admin,
 
         encryptedCrypto: {
-            armoredKey: "nodeKey",
-            armoredNodePassphrase: "nodePass",
-            armoredNodePassphraseSignature: "nodePassSig",
-            nameSignatureEmail: "nameSigEmail",
-            signatureEmail: "sigEmail",
+            armoredKey: 'nodeKey',
+            armoredNodePassphrase: 'nodePass',
+            armoredNodePassphraseSignature: 'nodePassSig',
+            nameSignatureEmail: 'nameSigEmail',
+            signatureEmail: 'sigEmail',
         },
-    }
+    };
 }
 
-describe("nodeAPIService", () => {
+describe('nodeAPIService', () => {
     let apiMock: DriveAPIService;
     let api: NodeAPIService;
 
@@ -172,19 +172,18 @@ describe("nodeAPIService", () => {
     describe('iterateNodes', () => {
         async function testIterateNodes(mockedLink: any, expectedNode: any, ownVolumeId = 'volumeId') {
             // @ts-expect-error Mocking for testing purposes
-            apiMock.post = jest.fn(async () => Promise.resolve({
-                Links: [mockedLink],
-            }));
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Links: [mockedLink],
+                }),
+            );
 
             const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], ownVolumeId));
             expect(nodes).toStrictEqual([expectedNode]);
         }
-    
+
         it('should get folder node', async () => {
-            await testIterateNodes(
-                generateAPIFolderNode(),
-                generateFolderNode(),
-            );
+            await testIterateNodes(generateAPIFolderNode(), generateFolderNode());
         });
 
         it('should get root folder node', async () => {
@@ -193,31 +192,28 @@ describe("nodeAPIService", () => {
                 generateFolderNode({ parentUid: undefined }),
             );
         });
-    
+
         it('should get file node', async () => {
-            await testIterateNodes(
-                generateAPIFileNode(),
-                generateFileNode(),
-            );
+            await testIterateNodes(generateAPIFileNode(), generateFileNode());
         });
 
         it('should get album node', async () => {
-            await testIterateNodes(
-                generateAPIAlbumNode(),
-                generateAlbumNode(),
-            );
+            await testIterateNodes(generateAPIAlbumNode(), generateAlbumNode());
         });
 
         it('should get shared node', async () => {
             await testIterateNodes(
-                generateAPIFolderNode({}, {
-                    Sharing: {
-                        ShareID: 'shareId',
-                    },
-                    Membership: {
-                        Permissions: 22,
+                generateAPIFolderNode(
+                    {},
+                    {
+                        Sharing: {
+                            ShareID: 'shareId',
+                        },
+                        Membership: {
+                            Permissions: 22,
+                        },
                     },
-                }),
+                ),
                 generateFolderNode({
                     isShared: true,
                     shareId: 'shareId',
@@ -228,14 +224,17 @@ describe("nodeAPIService", () => {
 
         it('should get shared node with unknown permissions', async () => {
             await testIterateNodes(
-                generateAPIFolderNode({}, {
-                    Sharing: {
-                        ShareID: 'shareId',
-                    },
-                    Membership: {
-                        Permissions: 42,
+                generateAPIFolderNode(
+                    {},
+                    {
+                        Sharing: {
+                            ShareID: 'shareId',
+                        },
+                        Membership: {
+                            Permissions: 42,
+                        },
                     },
-                }),
+                ),
                 generateFolderNode({
                     isShared: true,
                     shareId: 'shareId',
@@ -251,23 +250,25 @@ describe("nodeAPIService", () => {
                     TrashTime: 123456,
                 }),
                 generateFileNode({
-                    trashTime: new Date(123456000)
+                    trashTime: new Date(123456000),
                 }),
             );
         });
 
         it('should get all recognised nodes before throwing error', async () => {
             // @ts-expect-error Mocking for testing purposes
-            apiMock.post = jest.fn(async () => Promise.resolve({
-                Links: [
-                    generateAPIFolderNode(),
-                    // Type 42 is not recognised - should throw error.
-                    generateAPIFolderNode({ Type: 42 }),
-                    // Type 43 is not recognised - should throw error.
-                    generateAPIFileNode({ Type: 43 }),
-                    generateAPIFileNode(),
-                ],
-            }));
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Links: [
+                        generateAPIFolderNode(),
+                        // Type 42 is not recognised - should throw error.
+                        generateAPIFolderNode({ Type: 42 }),
+                        // Type 43 is not recognised - should throw error.
+                        generateAPIFileNode({ Type: 43 }),
+                        generateAPIFileNode(),
+                    ],
+                }),
+            );
 
             const generator = api.iterateNodes(['volumeId~nodeId'], 'volumeId');
 
@@ -283,52 +284,95 @@ describe("nodeAPIService", () => {
             try {
                 await node3;
             } catch (error: any) {
-                expect(error.cause).toEqual([
-                    new Error('Unknown node type: 42'),
-                    new Error('Unknown node type: 43'),
-                ]);
+                expect(error.cause).toEqual([new Error('Unknown node type: 42'), new Error('Unknown node type: 43')]);
             }
         });
 
         it('should get nodes across various volumes', async () => {
             // @ts-expect-error Mocking for testing purposes
-            apiMock.post = jest.fn(async (url) => Promise.resolve({
-                Links: [
-                    generateAPIFolderNode({
-                        LinkID: url.includes('volumeId1') ? 'nodeId1' : 'nodeId2',
-                        ParentLinkID: url.includes('volumeId1') ? 'parentNodeId1' : 'parentNodeId2',
-                    }),
-                ],
-            }));
-
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2'], 'volumeId1'));
+            apiMock.post = jest.fn(async (url) =>
+                Promise.resolve({
+                    Links: [
+                        generateAPIFolderNode({
+                            LinkID: url.includes('volumeId1') ? 'nodeId1' : 'nodeId2',
+                            ParentLinkID: url.includes('volumeId1') ? 'parentNodeId1' : 'parentNodeId2',
+                        }),
+                    ],
+                }),
+            );
+
+            const nodes = await Array.fromAsync(
+                api.iterateNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2'], 'volumeId1'),
+            );
             expect(nodes).toStrictEqual([
-                generateFolderNode({ uid: 'volumeId1~nodeId1', parentUid: 'volumeId1~parentNodeId1', directMemberRole: MemberRole.Admin }),
-                generateFolderNode({ uid: 'volumeId2~nodeId2', parentUid: 'volumeId2~parentNodeId2', directMemberRole: MemberRole.Inherited }),
+                generateFolderNode({
+                    uid: 'volumeId1~nodeId1',
+                    parentUid: 'volumeId1~parentNodeId1',
+                    directMemberRole: MemberRole.Admin,
+                }),
+                generateFolderNode({
+                    uid: 'volumeId2~nodeId2',
+                    parentUid: 'volumeId2~parentNodeId2',
+                    directMemberRole: MemberRole.Inherited,
+                }),
             ]);
         });
+
+        it('should get nodes in batches', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async (_, { LinkIDs }) =>
+                Promise.resolve({
+                    Links: LinkIDs.map((linkId: string) => generateAPIFolderNode({ LinkID: linkId })),
+                }),
+            );
+
+            const nodeUids = Array.from({ length: 250 }, (_, i) => `volumeId1~nodeId${i}`);
+            const nodeIds = nodeUids.map((uid) => uid.split('~')[1]);
+
+            const nodes = await Array.fromAsync(api.iterateNodes(nodeUids, 'volumeId1'));
+            expect(nodes).toHaveLength(nodeUids.length);
+
+            expect(apiMock.post).toHaveBeenCalledTimes(3);
+            expect(apiMock.post).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId1/links',
+                { LinkIDs: nodeIds.slice(0, 100) },
+                undefined,
+            );
+            expect(apiMock.post).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId1/links',
+                { LinkIDs: nodeIds.slice(100, 200) },
+                undefined,
+            );
+            expect(apiMock.post).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId1/links',
+                { LinkIDs: nodeIds.slice(200, 250) },
+                undefined,
+            );
+        });
     });
 
     describe('trashNodes', () => {
         it('should trash nodes', async () => {
             // @ts-expect-error Mocking for testing purposes
-            apiMock.post = jest.fn(async () => Promise.resolve({
-                Responses: [
-                    {
-                        LinkID: 'nodeId1',
-                        Response: {
-                            Code: ErrorCode.OK,
-                        }
-                    },
-                    {
-                        LinkID: 'nodeId2',
-                        Response: {
-                            Code: 2027,
-                            Error: 'INSUFFICIENT_SCOPE'
-                        }
-                    }
-                ],
-            }));
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Responses: [
+                        {
+                            LinkID: 'nodeId1',
+                            Response: {
+                                Code: ErrorCode.OK,
+                            },
+                        },
+                        {
+                            LinkID: 'nodeId2',
+                            Response: {
+                                Code: 2027,
+                                Error: 'INSUFFICIENT_SCOPE',
+                            },
+                        },
+                    ],
+                }),
+            );
 
             const result = await Array.fromAsync(api.trashNodes(['volumeId~nodeId1', 'volumeId~nodeId2']));
             expect(result).toEqual([
@@ -341,31 +385,35 @@ describe("nodeAPIService", () => {
     describe('restoreNodes', () => {
         it('should restore nodes', async () => {
             // @ts-expect-error Mocking for testing purposes
-            apiMock.put = jest.fn(async () => Promise.resolve({
-                Responses: [
-                    {
-                        LinkID: 'nodeId1',
-                        Response: {
-                            Code: ErrorCode.OK,
-                        }
-                    },
-                    {
-                        LinkID: 'nodeId2',
-                        Response: {
-                            Code: 2027,
-                            Error: 'INSUFFICIENT_SCOPE'
-                        }
-                    },
-                    {
-                        LinkID: 'nodeId3',
-                        Response: {
-                            Code: 2000,
-                        }
-                    },
-                ],
-            }));
+            apiMock.put = jest.fn(async () =>
+                Promise.resolve({
+                    Responses: [
+                        {
+                            LinkID: 'nodeId1',
+                            Response: {
+                                Code: ErrorCode.OK,
+                            },
+                        },
+                        {
+                            LinkID: 'nodeId2',
+                            Response: {
+                                Code: 2027,
+                                Error: 'INSUFFICIENT_SCOPE',
+                            },
+                        },
+                        {
+                            LinkID: 'nodeId3',
+                            Response: {
+                                Code: 2000,
+                            },
+                        },
+                    ],
+                }),
+            );
 
-            const result = await Array.fromAsync(api.restoreNodes(['volumeId~nodeId1', 'volumeId~nodeId2', 'volumeId~nodeId3']));
+            const result = await Array.fromAsync(
+                api.restoreNodes(['volumeId~nodeId1', 'volumeId~nodeId2', 'volumeId~nodeId3']),
+            );
             expect(result).toEqual([
                 { uid: 'volumeId~nodeId1', ok: true },
                 { uid: 'volumeId~nodeId2', ok: false, error: 'INSUFFICIENT_SCOPE' },
@@ -373,7 +421,7 @@ describe("nodeAPIService", () => {
             ]);
         });
 
-        it('should fail restoring from multiple volumes', async () => {  
+        it('should fail restoring from multiple volumes', async () => {
             try {
                 await Array.fromAsync(api.restoreNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
                 throw new Error('Should have thrown');
@@ -386,23 +434,25 @@ describe("nodeAPIService", () => {
     describe('deleteNOdes', () => {
         it('should delete nodes', async () => {
             // @ts-expect-error Mocking for testing purposes
-            apiMock.post = jest.fn(async () => Promise.resolve({
-                Responses: [
-                    {
-                        LinkID: 'nodeId1',
-                        Response: {
-                            Code: ErrorCode.OK,
-                        }
-                    },
-                    {
-                        LinkID: 'nodeId2',
-                        Response: {
-                            Code: 2027,
-                            Error: 'INSUFFICIENT_SCOPE'
-                        }
-                    }
-                ],
-            }));
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Responses: [
+                        {
+                            LinkID: 'nodeId1',
+                            Response: {
+                                Code: ErrorCode.OK,
+                            },
+                        },
+                        {
+                            LinkID: 'nodeId2',
+                            Response: {
+                                Code: 2027,
+                                Error: 'INSUFFICIENT_SCOPE',
+                            },
+                        },
+                    ],
+                }),
+            );
 
             const result = await Array.fromAsync(api.deleteNodes(['volumeId~nodeId1', 'volumeId~nodeId2']));
             expect(result).toEqual([
@@ -411,7 +461,7 @@ describe("nodeAPIService", () => {
             ]);
         });
 
-        it('should fail deleting nodes from multiple volumes', async () => {  
+        it('should fail deleting nodes from multiple volumes', async () => {
             try {
                 await Array.fromAsync(api.deleteNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
                 throw new Error('Should have thrown');