@protontech/drive-sdk 0.1.1 → 0.1.2

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

@@ -21,6 +21,7 @@ describe('handleSharedByMeNodes', () => {
             removeSharedByMeNodeUid: jest.fn(),
             setSharedWithMeNodeUids: jest.fn(),
             getSharedByMeNodeUids: jest.fn().mockResolvedValue(['cachedNodeUid']),
+            hasSharedByMeNodeUidsLoaded: jest.fn().mockResolvedValue(true),
         };
         sharesManager = {
             isOwnVolume: jest.fn(async (volumeId: string) => volumeId === 'MyVolume1'),
@@ -28,94 +29,108 @@ describe('handleSharedByMeNodes', () => {
         sharingEventHandler = new SharingEventHandler(getMockLogger(), cache, sharesManager);
     });
 
-    describe('node events trigger cache update', () => {
-        it('should add if new own shared node is created', async () => {
-            const event: DriveEvent = {
-                eventId: '1',
-                type: DriveEventType.NodeCreated,
-                nodeUid: 'newNodeUid',
-                parentNodeUid: 'parentUid',
-                isTrashed: false,
-                isShared: true,
-                treeEventScopeId: 'MyVolume1',
-            };
-            await sharingEventHandler.handleDriveEvent(event);
-            expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith('newNodeUid');
-            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-        });
-
-        test('should not add if new shared node is not own', async () => {
-            const event: DriveEvent = {
-                eventId: '1',
-                type: DriveEventType.NodeCreated,
-                nodeUid: 'newNodeUid',
-                parentNodeUid: 'parentUid',
-                isTrashed: false,
-                isShared: true,
-                treeEventScopeId: 'NotOwnVolume',
-            };
-            await sharingEventHandler.handleDriveEvent(event);
-            expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
-            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-        });
-
-        it('should not add if new own node is not shared', async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeCreated,
-                nodeUid: 'newNodeUid',
-                parentNodeUid: 'parentUid',
-                isTrashed: false,
-                isShared: false,
-                eventId: '1',
-                treeEventScopeId: 'MyVolume1',
-            };
-            await sharingEventHandler.handleDriveEvent(event);
-            expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
-            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-        });
-
-        it('should add if own node is updated and shared', async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: 'cachedNodeUid',
-                parentNodeUid: 'parentUid',
-                isTrashed: false,
-                isShared: true,
-                eventId: '1',
-                treeEventScopeId: 'MyVolume1',
-            };
-            await sharingEventHandler.handleDriveEvent(event);
-            expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith('cachedNodeUid');
-            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-        });
-
-        it('should remove if shared node is un-shared', async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: 'cachedNodeUid',
-                parentNodeUid: 'parentUid',
-                isTrashed: false,
-                isShared: false,
-                eventId: '1',
-                treeEventScopeId: 'MyVolume1',
-            };
-            await sharingEventHandler.handleDriveEvent(event);
-            expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith('cachedNodeUid');
-            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-        });
-
-        it('should remove if shared node is deleted', async () => {
-            const event: DriveEvent = {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: 'cachedNodeUid',
-                parentNodeUid: 'parentUid',
-                eventId: '1',
-                treeEventScopeId: 'MyVolume1',
-            };
-            await sharingEventHandler.handleDriveEvent(event);
-            expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith('cachedNodeUid');
-            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-        });
+    it('should add if new own shared node is created', async () => {
+        const event: DriveEvent = {
+            eventId: '1',
+            type: DriveEventType.NodeCreated,
+            nodeUid: 'newNodeUid',
+            parentNodeUid: 'parentUid',
+            isTrashed: false,
+            isShared: true,
+            treeEventScopeId: 'MyVolume1',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith('newNodeUid');
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+    });
+
+    test('should not add if new shared node is not own', async () => {
+        const event: DriveEvent = {
+            eventId: '1',
+            type: DriveEventType.NodeCreated,
+            nodeUid: 'newNodeUid',
+            parentNodeUid: 'parentUid',
+            isTrashed: false,
+            isShared: true,
+            treeEventScopeId: 'NotOwnVolume',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+    });
+
+    it('should not add if new own node is not shared', async () => {
+        const event: DriveEvent = {
+            type: DriveEventType.NodeCreated,
+            nodeUid: 'newNodeUid',
+            parentNodeUid: 'parentUid',
+            isTrashed: false,
+            isShared: false,
+            eventId: '1',
+            treeEventScopeId: 'MyVolume1',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+    });
+
+    it('should add if own node is updated and shared', async () => {
+        const event: DriveEvent = {
+            type: DriveEventType.NodeUpdated,
+            nodeUid: 'cachedNodeUid',
+            parentNodeUid: 'parentUid',
+            isTrashed: false,
+            isShared: true,
+            eventId: '1',
+            treeEventScopeId: 'MyVolume1',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith('cachedNodeUid');
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+    });
+
+    it('should remove if shared node is un-shared', async () => {
+        const event: DriveEvent = {
+            type: DriveEventType.NodeUpdated,
+            nodeUid: 'cachedNodeUid',
+            parentNodeUid: 'parentUid',
+            isTrashed: false,
+            isShared: false,
+            eventId: '1',
+            treeEventScopeId: 'MyVolume1',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith('cachedNodeUid');
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+    });
+
+    it('should remove if shared node is deleted', async () => {
+        const event: DriveEvent = {
+            type: DriveEventType.NodeDeleted,
+            nodeUid: 'cachedNodeUid',
+            parentNodeUid: 'parentUid',
+            eventId: '1',
+            treeEventScopeId: 'MyVolume1',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith('cachedNodeUid');
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+    });
+
+    it('should not update cache if shared by me is not loaded', async () => {
+        cache.hasSharedByMeNodeUidsLoaded = jest.fn().mockResolvedValue(false);
+        const event: DriveEvent = {
+            eventId: '1',
+            type: DriveEventType.NodeCreated,
+            nodeUid: 'newNodeUid',
+            parentNodeUid: 'parentUid',
+            isTrashed: false,
+            isShared: true,
+            treeEventScopeId: 'MyVolume1',
+        };
+        await sharingEventHandler.handleDriveEvent(event);
+        expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
+        expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
     });
 });
 
@@ -141,7 +156,7 @@ describe('handleSharedWithMeNodes', () => {
         } as any;
     });
 
-    it('should only update cache', async () => {
+    it('should update cache', async () => {
         const event: DriveEvent = {
             type: DriveEventType.SharedWithMeUpdated,
             eventId: 'event1',

package/src/internal/sharing/events.ts

@@ -30,26 +30,41 @@ export class SharingEventHandler {
                 await this.cache.setSharedWithMeNodeUids(undefined);
                 return;
             }
-            if (!(await this.shares.isOwnVolume(event.treeEventScopeId))) {
-                return;
-            }
-            if (event.type === DriveEventType.NodeCreated || event.type == DriveEventType.NodeUpdated) {
-                if (event.isShared && !event.isTrashed) {
-                    await this.cache.addSharedByMeNodeUid(event.nodeUid);
-                } else {
-                    await this.cache.removeSharedByMeNodeUid(event.nodeUid);
-                }
-                return;
-            }
-            if (event.type === DriveEventType.NodeDeleted) {
-                await this.cache.removeSharedByMeNodeUid(event.nodeUid);
-                return;
-            }
-            if (event.type === DriveEventType.TreeRefresh || event.type === DriveEventType.TreeRemove) {
-                await this.cache.setSharedWithMeNodeUids(undefined);
-            }
+            await this.handleSharedByMeNodeUidsLoaded(event);
         } catch (error: unknown) {
             this.logger.error(`Skipping shared by me node cache update`, error);
         }
     }
+
+    private async handleSharedByMeNodeUidsLoaded(event: DriveEvent) {
+        if (event.type === DriveEventType.TreeRefresh || event.type === DriveEventType.TreeRemove) {
+            await this.cache.setSharedWithMeNodeUids(undefined);
+            return;
+        }
+
+        if (![DriveEventType.NodeCreated, DriveEventType.NodeUpdated, DriveEventType.NodeDeleted].includes(event.type)) {
+            return;
+        }
+
+        const hasSharedByMeLoaded = await this.cache.hasSharedByMeNodeUidsLoaded();
+        if (!hasSharedByMeLoaded) {
+            return;
+        }
+
+        const isOwnVolume = await this.shares.isOwnVolume(event.treeEventScopeId);
+        if (!isOwnVolume) {
+            return;
+        }
+
+        if (event.type === DriveEventType.NodeCreated || event.type == DriveEventType.NodeUpdated) {
+            if (event.isShared && !event.isTrashed) {
+                await this.cache.addSharedByMeNodeUid(event.nodeUid);
+            } else {
+                await this.cache.removeSharedByMeNodeUid(event.nodeUid);
+            }
+        }
+        if (event.type === DriveEventType.NodeDeleted) {
+            await this.cache.removeSharedByMeNodeUid(event.nodeUid);
+        }
+    }
 }

package/src/internal/upload/interface.ts

@@ -106,6 +106,7 @@ export interface NodesService {
         addressKeyId: string;
     }>;
     notifyChildCreated(nodeUid: string): Promise<void>;
+    notifyNodeChanged(nodeUid: string): Promise<void>;
 }
 
 /**

package/src/internal/upload/manager.test.ts

@@ -91,9 +91,8 @@ describe('UploadManager', () => {
                 email: 'signatureEmail',
                 addressId: 'addressId',
             }),
-            notifyChildCreated: jest.fn(async (nodeUid: string) => {
-                return;
-            }),
+            notifyChildCreated: jest.fn(),
+            notifyNodeChanged: jest.fn(),
         };
 
         manager = new UploadManager(telemetry, apiService, cryptoService, nodesService, clientUid);
@@ -337,10 +336,6 @@ describe('UploadManager', () => {
             },
         };
         const manifest = new Uint8Array([1, 2, 3]);
-        const metadata = {
-            mediaType: 'myMimeType',
-            expectedSize: 123456,
-        };
         const extendedAttributes = {
             modificationTime: new Date(),
             digests: {
@@ -349,7 +344,7 @@ describe('UploadManager', () => {
         };
 
         it('should commit revision draft', async () => {
-            await manager.commitDraft(nodeRevisionDraft as any, manifest, metadata, extendedAttributes);
+            await manager.commitDraft(nodeRevisionDraft as any, manifest, extendedAttributes);
 
             expect(cryptoService.commitFile).toHaveBeenCalledWith(
                 nodeRevisionDraft.nodeKeys,
@@ -360,7 +355,8 @@ describe('UploadManager', () => {
                 nodeRevisionDraft.nodeRevisionUid,
                 expect.anything(),
             );
-            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('parentUid');
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('newNode:nodeUid');
+            expect(nodesService.notifyChildCreated).not.toHaveBeenCalled();
         });
 
         it('should commit node draft', async () => {
@@ -373,7 +369,7 @@ describe('UploadManager', () => {
                     hash: 'newNode:hash',
                 },
             };
-            await manager.commitDraft(nodeRevisionDraftWithNewNodeInfo as any, manifest, metadata, extendedAttributes);
+            await manager.commitDraft(nodeRevisionDraftWithNewNodeInfo as any, manifest, extendedAttributes);
 
             expect(cryptoService.commitFile).toHaveBeenCalledWith(
                 nodeRevisionDraft.nodeKeys,
@@ -385,6 +381,7 @@ describe('UploadManager', () => {
                 expect.anything(),
             );
             expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('parentUid');
+            expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
         });
     });
 });

package/src/internal/upload/manager.ts

@@ -260,7 +260,6 @@ export class UploadManager {
     async commitDraft(
         nodeRevisionDraft: NodeRevisionDraft,
         manifest: Uint8Array,
-        _metadata: UploadMetadata,
         extendedAttributes: {
             modificationTime?: Date;
             size?: number;
@@ -277,9 +276,13 @@ export class UploadManager {
             generatedExtendedAttributes,
         );
         await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
-        const node = await this.nodesService.getNode(nodeRevisionDraft.nodeUid);
-        if (node.parentUid) {
-            await this.nodesService.notifyChildCreated(node.parentUid);
+
+        // If new revision to existing node was created, invalidate the node.
+        // Otherwise notify about the new child in the parent.
+        if (nodeRevisionDraft.newNodeInfo) {
+            await this.nodesService.notifyChildCreated(nodeRevisionDraft.newNodeInfo.parentUid);
+        } else {
+            await this.nodesService.notifyNodeChanged(nodeRevisionDraft.nodeUid);
         }
     }
 }

package/src/internal/upload/streamUploader.test.ts

@@ -147,7 +147,7 @@ describe('StreamUploader', () => {
 
             const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
             expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
-            expect(uploadManager.commitDraft).toHaveBeenCalledWith(revisionDraft, expect.anything(), metadata, {
+            expect(uploadManager.commitDraft).toHaveBeenCalledWith(revisionDraft, expect.anything(), {
                 size: metadata.expectedSize,
                 blockSizes: metadata.expectedSize
                     ? [

package/src/internal/upload/streamUploader.ts

@@ -217,7 +217,7 @@ export class StreamUploader {
             blockSizes: uploadedBlocks.map((block) => block.originalSize),
             digests: this.digests.digests(),
         };
-        await this.uploadManager.commitDraft(this.revisionDraft, this.manifest, this.metadata, extendedAttributes);
+        await this.uploadManager.commitDraft(this.revisionDraft, this.manifest, extendedAttributes);
     }
 
     private async encryptThumbnails(thumbnails: Thumbnail[]) {

package/src/protonDriveClient.ts

@@ -155,8 +155,8 @@ export class ProtonDriveClient {
         );
         // These are used to keep the internal cache up to date
         const cacheEventListeners: DriveListener[] = [
-            this.nodes.eventHandler.updateNodesCacheOnEvent,
-            this.sharing.eventHandler.handleDriveEvent,
+            this.nodes.eventHandler.updateNodesCacheOnEvent.bind(this.nodes.eventHandler),
+            this.sharing.eventHandler.handleDriveEvent.bind(this.sharing.eventHandler),
         ];
         this.events = new DriveEventsService(
             telemetry,

package/src/transformers.ts

@@ -29,6 +29,7 @@ type InternalPartialNode = Pick<
     | 'totalStorageSize'
     | 'errors'
     | 'shareId'
+    | 'treeEventScopeId'
 >;
 
 type NodeUid = string | { uid: string } | Result<{ uid: string }, { uid: string }>;
@@ -92,6 +93,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         totalStorageSize: node.totalStorageSize,
         folder: node.folder,
         deprecatedShareId: node.shareId,
+        treeEventScopeId: node.treeEventScopeId,
     };
 
     const name = node.name;