@protontech/drive-sdk 0.0.12 → 0.1.0

package/src/internal/nodes/nodesAccess.test.ts

@@ -22,7 +22,7 @@ describe('nodesAccess', () => {
         apiService = {
             getNode: jest.fn(),
             iterateNodes: jest.fn().mockImplementation(async function* (uids: string[]) {
-                yield* uids.map((uid => ({ uid, parentUid: 'parentUid' } as EncryptedNode)));
+                yield* uids.map((uid => ({ uid, parentUid: 'volumeId~parentNodeId' } as EncryptedNode)));
             }),
             iterateChildrenNodeUids: jest.fn(),
         }
@@ -46,6 +46,7 @@ describe('nodesAccess', () => {
         }
         // @ts-expect-error No need to implement all methods for mocking
         shareService = {
+            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             getSharePrivateKey: jest.fn(),
         };
 
@@ -54,49 +55,51 @@ describe('nodesAccess', () => {
 
     describe('getNode', () => {
         it('should get node from cache', async () => {
-            const node = { uid: 'nodeId', isStale: false } as DecryptedNode;
+            const node = { uid: 'volumeId~nodeId', isStale: false } as DecryptedNode;
             cache.getNode = jest.fn(() => Promise.resolve(node));
 
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toBe(node);
             expect(apiService.getNode).not.toHaveBeenCalled();
         });
 
-        it('should get node from API when cahce is stale', async () => {
-            const encryptedNode = { uid: 'nodeId', parentUid: 'parentUid' } as EncryptedNode;
-            const decryptedUnparsedNode = { uid: 'nodeId', parentUid: 'parentUid', name: { ok: true, value: 'name' } } as DecryptedUnparsedNode;
+        it('should get node from API when cache is stale', async () => {
+            const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' } as EncryptedNode;
+            const decryptedUnparsedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid', name: { ok: true, value: 'name' } } as DecryptedUnparsedNode;
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: true, value: 'name' },
                 isStale: false,
                 activeRevision: undefined,
                 folder: undefined,
+                treeEventScopeId: "volumeId",
             } as DecryptedNode;
             const decryptedKeys = { key: 'key' } as any as DecryptedNodeKeys;
 
-            cache.getNode = jest.fn(() => Promise.resolve({ uid: 'nodeId', isStale: true } as DecryptedNode));
+            cache.getNode = jest.fn(() => Promise.resolve({ uid: 'volumeId~nodeId', isStale: true } as DecryptedNode));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
             cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
 
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toEqual(decryptedNode);
-            expect(apiService.getNode).toHaveBeenCalledWith('nodeId');
-            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('parentUid');
+            expect(apiService.getNode).toHaveBeenCalledWith('volumeId~nodeId', 'volumeId');
+            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('volumeId~parentNodeid');
             expect(cryptoService.decryptNode).toHaveBeenCalledWith(encryptedNode, 'parentKey');
             expect(cache.setNode).toHaveBeenCalledWith(decryptedNode);
-            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('nodeId', decryptedKeys);
+            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('volumeId~nodeId', decryptedKeys);
         });
 
         it('should get node from API missing cache', async () => {
-            const encryptedNode = { uid: 'nodeId', parentUid: 'parentUid' } as EncryptedNode;
-            const decryptedUnparsedNode = { uid: 'nodeId', parentUid: 'parentUid', name: { ok: true, value: 'name' } } as DecryptedUnparsedNode;
+            const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' } as EncryptedNode;
+            const decryptedUnparsedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid', name: { ok: true, value: 'name' } } as DecryptedUnparsedNode;
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: true, value: 'name' },
                 isStale: false,
                 activeRevision: undefined,
                 folder: undefined,
+                treeEventScopeId: 'volumeId',
             } as DecryptedNode;
             const decryptedKeys = { key: 'key' } as any as DecryptedNodeKeys;
 
@@ -105,21 +108,22 @@ describe('nodesAccess', () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
             cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
 
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toEqual(decryptedNode);
-            expect(apiService.getNode).toHaveBeenCalledWith('nodeId');
-            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('parentUid');
+            expect(apiService.getNode).toHaveBeenCalledWith('volumeId~nodeId', 'volumeId');
+            expect(cryptoCache.getNodeKeys).toHaveBeenCalledWith('volumeId~parentNodeid');
             expect(cryptoService.decryptNode).toHaveBeenCalledWith(encryptedNode, 'parentKey');
             expect(cache.setNode).toHaveBeenCalledWith(decryptedNode);
-            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('nodeId', decryptedKeys);
+            expect(cryptoCache.setNodeKeys).toHaveBeenCalledWith('volumeId~nodeId', decryptedKeys);
         });
 
         it('should validate node name', async () => {
-            const encryptedNode = { uid: 'nodeId', parentUid: 'parentUid' } as EncryptedNode;
-            const decryptedUnparsedNode = { uid: 'nodeId', parentUid: 'parentUid', name: { ok: true, value: 'foo/bar' } } as DecryptedUnparsedNode;
+            const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' } as EncryptedNode;
+            const decryptedUnparsedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid', name: { ok: true, value: 'foo/bar' } } as DecryptedUnparsedNode;
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: false, error: { name: 'foo/bar', error: "Name must not contain the character '/'" } },
+                treeEventScopeId: 'volumeId',
             } as DecryptedNode;
             const decryptedKeys = { key: 'key' } as any as DecryptedNodeKeys;
 
@@ -128,7 +132,7 @@ describe('nodesAccess', () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
             cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
 
-            const result = await access.getNode('nodeId');
+            const result = await access.getNode('volumeId~nodeId');
             expect(result).toMatchObject(decryptedNode);
         });
     });
@@ -143,11 +147,11 @@ describe('nodesAccess', () => {
         });
 
         describe('iterateChildren', () => {
-            const parentNode = { uid: 'parentUid', isStale: false } as DecryptedNode;
-            const node1 = { uid: 'node1', isStale: false } as DecryptedNode;
-            const node2 = { uid: 'node2', isStale: false } as DecryptedNode;
-            const node3 = { uid: 'node3', isStale: false } as DecryptedNode;
-            const node4 = { uid: 'node4', isStale: false } as DecryptedNode;
+            const parentNode = { uid: 'volumeId~parentNodeid', isStale: false } as DecryptedNode;
+            const node1 = { uid: 'volumeId~node1', isStale: false } as DecryptedNode;
+            const node2 = { uid: 'volumeId~node2', isStale: false } as DecryptedNode;
+            const node3 = { uid: 'volumeId~node3', isStale: false } as DecryptedNode;
+            const node4 = { uid: 'volumeId~node4', isStale: false } as DecryptedNode;
 
             beforeEach(() => {
                 cache.getNode = jest.fn().mockResolvedValue(parentNode);
@@ -162,7 +166,7 @@ describe('nodesAccess', () => {
                     yield { ok: true, node: node4 };
                 });
 
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateChildrenNodeUids).not.toHaveBeenCalled();
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
@@ -177,9 +181,9 @@ describe('nodesAccess', () => {
                     yield { ok: true, uid: node4.uid, node: node4 };
                 });
 
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith([node2.uid, node3.uid], 'volumeId', undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(2);
                 expect(cache.setNode).toHaveBeenCalledTimes(2);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(2);
@@ -187,26 +191,26 @@ describe('nodesAccess', () => {
 
             it('should load children uids and serve nodes from cache', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
-                    yield 'node4';
+                    yield node1.uid;
+                    yield node2.uid;
+                    yield node3.uid;
+                    yield node4.uid;
                 });
                 cache.getNode = jest.fn().mockImplementation((uid: string) => ({ uid, isStale: false }));
 
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('parentUid', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
-                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('parentUid');
+                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('volumeId~parentNodeid');
             });
 
             it('should load from API', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
-                    yield 'node4';
+                    yield node1.uid;
+                    yield node2.uid;
+                    yield node3.uid;
+                    yield node4.uid;
                 });
                 cache.getNode = jest.fn().mockImplementation((uid: string) => {
                     if (uid === parentNode.uid) {
@@ -215,21 +219,21 @@ describe('nodesAccess', () => {
                     throw new Error('Entity not found');
                 });
 
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('parentUid', undefined);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'], 'volumeId', undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
-                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('parentUid');
+                expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('volumeId~parentNodeid');
             });
 
             it('should remove from cache if missing on API', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
+                    yield node1.uid;
+                    yield node2.uid;
+                    yield node3.uid;
                 });
                 cache.getNode = jest.fn().mockImplementation((uid: string) => {
                     if (uid === parentNode.uid) {
@@ -242,16 +246,16 @@ describe('nodesAccess', () => {
                     yield* uids.slice(1).map((uid) => ({ uid, parentUid: parentNode.uid } as EncryptedNode));
                 });
 
-                const result = await Array.fromAsync(access.iterateFolderChildren('parentUid'));
+                const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node2, node3]);
-                expect(cache.removeNodes).toHaveBeenCalledWith(['node1']);
+                expect(cache.removeNodes).toHaveBeenCalledWith([node1.uid]);
             });
 
             it('should yield all decryptable children before throwing error', async () => {
                 apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
-                    yield 'node1';
-                    yield 'node2';
-                    yield 'node3';
+                    yield 'volumeId~node1';
+                    yield 'volumeId~node2';
+                    yield 'volumeId~node3';
                 });
                 cache.getNode = jest.fn().mockImplementation((uid: string) => {
                     if (uid === parentNode.uid) {
@@ -260,7 +264,7 @@ describe('nodesAccess', () => {
                     throw new Error('Entity not found');
                 });
                 cryptoService.decryptNode = jest.fn().mockImplementation((encryptedNode: EncryptedNode) => {
-                    if (encryptedNode.uid === 'node2') {
+                    if (encryptedNode.uid === 'volumeId~node2') {
                         throw new DecryptionError('Decryption failed');
                     }
                     return Promise.resolve({
@@ -269,11 +273,11 @@ describe('nodesAccess', () => {
                     });
                 });
 
-                const generator = access.iterateFolderChildren('parentUid');
+                const generator = access.iterateFolderChildren('volumeId~parentNodeid');
                 const node1 = await generator.next();
-                expect(node1.value).toMatchObject({ uid: 'node1' });
+                expect(node1.value).toMatchObject({ uid: 'volumeId~node1' });
                 const node2 = await generator.next();
-                expect(node2.value).toMatchObject({ uid: 'node3' });
+                expect(node2.value).toMatchObject({ uid: 'volumeId~node3' });
                 const node3 = generator.next();
                 await expect(node3).rejects.toThrow('Failed to decrypt some nodes');
                 try {
@@ -288,10 +292,10 @@ describe('nodesAccess', () => {
 
         describe('iterateTrashedNodes', () => {
             const volumeId = 'volumeId';
-            const node1 = { uid: 'node1', isStale: false } as DecryptedNode;
-            const node2 = { uid: 'node2', isStale: false } as DecryptedNode;
-            const node3 = { uid: 'node3', isStale: false } as DecryptedNode;
-            const node4 = { uid: 'node4', isStale: false } as DecryptedNode;
+            const node1 = { uid: 'volumeId~node1', isStale: false } as DecryptedNode;
+            const node2 = { uid: 'volumeId~node2', isStale: false } as DecryptedNode;
+            const node3 = { uid: 'volumeId~node3', isStale: false } as DecryptedNode;
+            const node4 = { uid: 'volumeId~node4', isStale: false } as DecryptedNode;
 
             beforeEach(() => {
                 shareService.getMyFilesIDs = jest.fn().mockResolvedValue({ volumeId });
@@ -320,7 +324,7 @@ describe('nodesAccess', () => {
                 const result = await Array.fromAsync(access.iterateTrashedNodes());
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateTrashedNodeUids).toHaveBeenCalledWith(volumeId, undefined);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node1', 'node2', 'node3', 'node4'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'], volumeId, undefined);
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
@@ -332,20 +336,20 @@ describe('nodesAccess', () => {
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids: string[]) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'parentUid' } as EncryptedNode));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' } as EncryptedNode));
                 });
 
                 const result = await Array.fromAsync(access.iterateTrashedNodes());
                 expect(result).toMatchObject([node2, node3, node4]);
-                expect(cache.removeNodes).toHaveBeenCalledWith(['node1']);
+                expect(cache.removeNodes).toHaveBeenCalledWith(['volumeId~node1']);
             });
         });
 
         describe('iterateNodes', () => {
-            const node1 = { uid: 'node1', isStale: false } as DecryptedNode;
-            const node2 = { uid: 'node2', isStale: false } as DecryptedNode;
-            const node3 = { uid: 'node3', isStale: false } as DecryptedNode;
-            const node4 = { uid: 'node4', isStale: false } as DecryptedNode;
+            const node1 = { uid: 'volumeId~node1', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
+            const node2 = { uid: 'volumeId~node2', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
+            const node3 = { uid: 'volumeId~node3', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
+            const node4 = { uid: 'volume~node4', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
 
             it('should serve fully from cache', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
@@ -355,7 +359,7 @@ describe('nodesAccess', () => {
                     yield { ok: true, node: node4 };
                 });
 
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3', 'node4']));
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
             });
@@ -363,52 +367,55 @@ describe('nodesAccess', () => {
             it('should load from API', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
                     yield { ok: true, node: node1 };
-                    yield { ok: false, uid: 'node2' };
-                    yield { ok: false, uid: 'node3' };
+                    yield { ok: false, uid: 'volumeId~node2' };
+                    yield { ok: false, uid: 'volumeId~node3' };
                     yield { ok: true, node: node4 };
                 });
 
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3', 'node4']));
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['node2', 'node3'], undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node2', 'volumeId~node3'], 'volumeId', undefined);
             });
 
             it('should remove from cache if missing on API and return back to caller', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
-                    yield { ok: false, uid: 'node1' };
-                    yield { ok: false, uid: 'node2' };
-                    yield { ok: false, uid: 'node3' };
+                    yield { ok: false, uid: 'volumeId~node1' };
+                    yield { ok: false, uid: 'volumeId~node2' };
+                    yield { ok: false, uid: 'volumeId~node3' };
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids: string[]) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'parentUid' } as EncryptedNode));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' } as EncryptedNode));
                 });
 
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3']));
-                expect(result).toMatchObject([node2, node3, {missingUid: 'node1'}]);
-                expect(cache.removeNodes).toHaveBeenCalledWith(['node1']);
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']));
+                expect(result).toMatchObject([node2, node3, {missingUid: 'volumeId~node1'}]);
+                expect(cache.removeNodes).toHaveBeenCalledWith(['volumeId~node1']);
             });
 
             it('should return degraded node if parent cannot be decrypted', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {
-                    yield { ok: false, uid: 'node1' };
-                    yield { ok: false, uid: 'node2' };
-                    yield { ok: false, uid: 'node3' };
+                    yield { ok: false, uid: 'volumeId~node1' };
+                    yield { ok: false, uid: 'volumeId~node2' };
+                    yield { ok: false, uid: 'volumeId~node3' };
                 });
                 const encryptedCrypto = {
                     signatureEmail: 'signatureEmail',
                     nameSignatureEmail: 'nameSignatureEmail',
                 };
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids: string[]) {
-                    yield* uids.map((uid) => ({
+                    yield* uids.map((uid) => {
+                        const parentUid = uid.replace('node', 'parentOfNode');
+                        return {
                         uid,
-                        parentUid: `parentUidFor:${uid}`,
+                        parentUid,
                         encryptedCrypto,
-                    } as EncryptedNode));
+                        } as EncryptedNode
+                    });
                 });
                 const decryptionError = new DecryptionError('Parent cannot be decrypted');
                 jest.spyOn(access, 'getParentKeys').mockImplementation(async ({ parentUid }) => {
-                    if (parentUid === 'parentUidFor:node1') {
+                    if (parentUid === 'volumeId~parentOfNode1') {
                         throw decryptionError;
                     }
                     return {
@@ -416,12 +423,12 @@ describe('nodesAccess', () => {
                     } as any;
                 } );
 
-                const result = await Array.fromAsync(access.iterateNodes(['node1', 'node2', 'node3']));
+                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']));
                 expect(result).toEqual([
                     {
                         ...node1,
                         encryptedCrypto,
-                        parentUid: 'parentUidFor:node1',
+                        parentUid: 'volumeId~parentOfNode1',
                         name: { ok: false, error: decryptionError },
                         keyAuthor: { ok: false, error: { claimedAuthor: 'signatureEmail', error: decryptionError.message } },
                         nameAuthor: { ok: false, error: { claimedAuthor: 'nameSignatureEmail', error: decryptionError.message } },
@@ -456,7 +463,7 @@ describe('nodesAccess', () => {
         it('should get node parent keys', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
 
-            const result = await access.getParentKeys({ shareId: undefined, parentUid: 'parentUid' });
+            const result = await access.getParentKeys({ shareId: undefined, parentUid: 'volumeId~parentNodeid' });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });
@@ -464,7 +471,7 @@ describe('nodesAccess', () => {
         it('should get node parent keys even if share is set', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
 
-            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: 'parentUid' });
+            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: 'volume1~parentNodeid' });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });
@@ -476,7 +483,7 @@ describe('nodesAccess', () => {
             apiService.getNode = jest.fn(() => Promise.reject(new Error('API called')));
 
             try {
-                await access.getNodeKeys('nodeId');
+                await access.getNodeKeys('volumeId~nodeId');
                 throw new Error('Expected error');
             } catch (error: unknown) {
                 expect(`${error}`).toBe('Error: API called');
@@ -489,7 +496,7 @@ describe('nodesAccess', () => {
             const nodeUid = 'nodeUid';
             const node = {
                 uid: nodeUid,
-                parentUid: 'parentUid',
+                parentUid: 'volume1~parentNodeid',
                 encryptedName: 'encryptedName',
             } as DecryptedNode;
 
@@ -552,4 +559,39 @@ describe('nodesAccess', () => {
             expect(result).toBe('https://drive.proton.me/shareId/folder/nodeId');
         });
     });
+
+    describe('notifyNodeChanged', () => {
+        it('should mark node as stale', async () => {
+            const node = { uid: 'volumeId~nodeId', isStale: false } as DecryptedNode;
+            cache.getNode = jest.fn(() => Promise.resolve(node));
+            cache.setNode = jest.fn();
+            await access.notifyNodeChanged(node.uid);
+            expect(cache.getNode).toHaveBeenCalledWith(node.uid);
+            expect(cache.setNode).toHaveBeenCalledWith({...node, isStale: true});
+        });
+        it('should update parent if needed', async () => {
+            const node = { uid: 'volumeId~nodeId', parentUid: 'v1~pn1', isStale: false } as DecryptedNode;
+            cache.getNode = jest.fn(() => Promise.resolve(node));
+            cache.setNode = jest.fn();
+            await access.notifyNodeChanged(node.uid, 'v1~pn2');
+            expect(cache.getNode).toHaveBeenCalledWith(node.uid);
+            expect(cache.setNode).toHaveBeenCalledWith({...node, parentUid: 'v1~pn2', isStale: true});
+        });
+    });
+
+    describe('notifyChildCreated', () => {
+        it('should reset parent listing', async () => {
+            const nodeUid = 'VolumeId1~NodeId1';
+            cache.resetFolderChildrenLoaded = jest.fn();
+            await access.notifyChildCreated(nodeUid);
+            expect(cache.resetFolderChildrenLoaded).toHaveBeenCalledWith(nodeUid);
+        });
+    });
+
+    describe('notifyNodeDeleted', () => {
+        it('should reset parent listing', async () => {
+            await access.notifyNodeDeleted('v1~n1');
+            expect(cache.removeNodes).toHaveBeenCalledWith(['v1~n1']);
+        });
+    });
 });

package/src/internal/nodes/nodesAccess.ts

@@ -3,6 +3,7 @@ import { c } from 'ttag';
 import { PrivateKey, SessionKey } from "../../crypto";
 import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from "../../interface";
 import { DecryptionError, ProtonDriveError } from "../../errors";
+import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
 import { BatchLoading } from "../batchLoading";
 import { makeNodeUid, splitNodeUid } from "../uids";
@@ -15,9 +16,19 @@ import { SharesService, EncryptedNode, DecryptedUnparsedNode, DecryptedNode, Dec
 import { validateNodeName } from "./validations";
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
 
+// This is the number of nodes that are loaded in parallel.
+// It is a trade-off between initial wait time and overhead of API calls.
+const BATCH_LOADING_SIZE = 30;
+
+// This is the number of nodes that are decrypted in parallel.
+// It is a trade-off between performance and memory usage.
+// Higher number means more memory usage, but faster decryption.
+// Lower number means less memory usage, but slower decryption.
+const DECRYPTION_CONCURRENCY = 15;
+
 /**
  * Provides access to node metadata.
- * 
+ *
  * The node access module is responsible for fetching, decrypting and caching
  * nodes metadata.
  */
@@ -64,7 +75,7 @@ export class NodesAccess {
         // Ensure the parent is loaded and up-to-date.
         const parentNode = await this.getNode(parentNodeUid);
 
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
 
         const areChildrenCached = await this.cache.isFolderChildrenLoaded(parentNodeUid);
         if (areChildrenCached) {
@@ -100,7 +111,7 @@ export class NodesAccess {
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         const { volumeId } = await this.shareService.getMyFilesIDs();
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
             let node;
             try {
@@ -118,7 +129,7 @@ export class NodesAccess {
     }
 
     async *iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
-        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({ iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({ iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
         for await (const result of this.cache.iterateNodes(nodeUids)) {
             if (result.ok && !result.node.isStale) {
                 yield result.node;
@@ -129,8 +140,45 @@ export class NodesAccess {
         yield* batchLoading.loadRest();
     }
 
+    /**
+     * Call to invalidate the folder listing cache. This should be refactored into a clean
+     * cache layer once the cache is split off.
+     */
+    async notifyChildCreated(nodeUid: string): Promise<void> {
+        await this.cache.resetFolderChildrenLoaded(nodeUid);
+    }
+
+    /**
+     * Call to invalidate the node cache when a node changes. Parent can be set after a move
+     * to ensure parent listing of new parent is up to date if cached.
+     * This should be refactored into a clean cache layer once the cache is split off.
+     */
+    async notifyNodeChanged(nodeUid: string, newParentUid?: string): Promise<void> {
+        try {
+            const node = await this.cache.getNode(nodeUid);
+            if (node.isStale && newParentUid === null) {
+                return;
+            }
+            node.isStale = true;
+            if (newParentUid) {
+                node.parentUid = newParentUid;
+            }
+            await this.cache.setNode(node);
+        } catch (error: unknown) {
+            this.logger.warn(`Failed to set node ${nodeUid} as stale after sharing: ${error}`);
+        }
+    }
+
+    /**
+     * Call to remove a node from cache. This should be refactored when the cache is split off.
+     */
+    async notifyNodeDeleted(nodeUid: string): Promise<void> {
+        await this.cache.removeNodes([nodeUid]);
+    }
+
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
-        const encryptedNode = await this.apiService.getNode(nodeUid);
+        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+        const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
         return this.decryptNode(encryptedNode);
     }
 
@@ -147,13 +195,24 @@ export class NodesAccess {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
-        for await (const encryptedNode of this.apiService.iterateNodes(nodeUids, signal)) {
+        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+
+        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, signal);
+        const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {
                 const { node } = await this.decryptNode(encryptedNode);
-                yield node;
+                return resultOk(node);
             } catch (error: unknown) {
-                errors.push(error);
+                return resultError(error);
+            }
+        };
+        const decryptedNodesIterator = asyncIteratorMap(encryptedNodesIterator, decryptNodeMapper, DECRYPTION_CONCURRENCY);
+        for await (const node of decryptedNodesIterator) {
+            if (node.ok) {
+                yield node.value;
+            } else {
+                errors.push(node.error);
             }
         }
 
@@ -194,6 +253,7 @@ export class NodesAccess {
                             error: getErrorMessage(error),
                         }),
                         errors: [error],
+                        treeEventScopeId: splitNodeUid(encryptedNode.uid).volumeId,
                     },
                 };
             }
@@ -249,6 +309,7 @@ export class NodesAccess {
                     ...extendedAttributes,
                 }),
                 folder: undefined,
+                treeEventScopeId: splitNodeUid(unparsedNode.uid).volumeId,
             }
         }
 
@@ -263,6 +324,7 @@ export class NodesAccess {
             folder: extendedAttributes ? {
                 ...extendedAttributes,
             } : undefined,
+            treeEventScopeId: splitNodeUid(unparsedNode.uid).volumeId,
         }
     }