@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/nodes/nodesAccess.ts

@@ -1,19 +1,19 @@
 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 { 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";
-import { NodeAPIService } from "./apiService";
-import { NodesCache } from "./cache"
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
-import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from "./extendedAttributes";
-import { SharesService, EncryptedNode, DecryptedUnparsedNode, DecryptedNode, DecryptedNodeKeys } from "./interface";
-import { validateNodeName } from "./validations";
+import { BatchLoading } from '../batchLoading';
+import { makeNodeUid, splitNodeUid } from '../uids';
+import { NodeAPIService } from './apiService';
+import { NodesCache } from './cache';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
+import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from './extendedAttributes';
+import { SharesService, EncryptedNode, DecryptedUnparsedNode, DecryptedNode, DecryptedNodeKeys } from './interface';
+import { validateNodeName } from './validations';
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
 
 // This is the number of nodes that are loaded in parallel.
@@ -28,7 +28,7 @@ const DECRYPTION_CONCURRENCY = 15;
 
 /**
  * Provides access to node metadata.
- * 
+ *
  * The node access module is responsible for fetching, decrypting and caching
  * nodes metadata.
  */
@@ -59,7 +59,7 @@ export class NodesAccess {
         let cachedNode;
         try {
             cachedNode = await this.cache.getNode(nodeUid);
-        } catch { }
+        } catch {}
 
         if (cachedNode && !cachedNode.isStale) {
             return cachedNode;
@@ -75,7 +75,10 @@ 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), batchSize: BATCH_LOADING_SIZE });
+        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) {
@@ -95,7 +98,7 @@ export class NodesAccess {
             let node;
             try {
                 node = await this.cache.getNode(nodeUid);
-            } catch { }
+            } catch {}
 
             if (node && !node.isStale) {
                 yield node;
@@ -111,12 +114,15 @@ 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), batchSize: BATCH_LOADING_SIZE });
+        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 {
                 node = await this.cache.getNode(nodeUid);
-            } catch { }
+            } catch {}
 
             if (node && !node.isStale) {
                 yield node;
@@ -129,7 +135,10 @@ 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), batchSize: BATCH_LOADING_SIZE });
+        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;
@@ -140,13 +149,49 @@ export class NodesAccess {
         yield* batchLoading.loadRest();
     }
 
-    private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
+    /**
+     * 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 { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
         const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
         return this.decryptNode(encryptedNode);
     }
 
-    private async* loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    private async *loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         for await (const result of this.loadNodesWithMissingReport(nodeUids, signal)) {
             if ('missingUid' in result) {
                 continue;
@@ -155,7 +200,10 @@ export class NodesAccess {
         }
     }
 
-    private async* loadNodesWithMissingReport(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
+    private async *loadNodesWithMissingReport(
+        nodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode | MissingNode> {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
@@ -171,7 +219,11 @@ export class NodesAccess {
                 return resultError(error);
             }
         };
-        const decryptedNodesIterator = asyncIteratorMap(encryptedNodesIterator, decryptNodeMapper, DECRYPTION_CONCURRENCY);
+        const decryptedNodesIterator = asyncIteratorMap(
+            encryptedNodesIterator,
+            decryptNodeMapper,
+            DECRYPTION_CONCURRENCY,
+        );
         for await (const node of decryptedNodesIterator) {
             if (node.ok) {
                 yield node.value;
@@ -196,7 +248,9 @@ export class NodesAccess {
         }
     }
 
-    private async decryptNode(encryptedNode: EncryptedNode): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
+    private async decryptNode(
+        encryptedNode: EncryptedNode,
+    ): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
         let parentKey;
         try {
             const parentKeys = await this.getParentKeys(encryptedNode);
@@ -217,6 +271,7 @@ export class NodesAccess {
                             error: getErrorMessage(error),
                         }),
                         errors: [error],
+                        treeEventScopeId: splitNodeUid(encryptedNode.uid).volumeId,
                     },
                 };
             }
@@ -262,17 +317,20 @@ export class NodesAccess {
             return {
                 ...unparsedNode,
                 isStale: false,
-                activeRevision: !unparsedNode.activeRevision?.ok ? unparsedNode.activeRevision : resultOk({
-                    uid: unparsedNode.activeRevision.value.uid,
-                    state: unparsedNode.activeRevision.value.state,
-                    creationTime: unparsedNode.activeRevision.value.creationTime,
-                    storageSize: unparsedNode.activeRevision.value.storageSize,
-                    contentAuthor: unparsedNode.activeRevision.value.contentAuthor,
-                    thumbnails: unparsedNode.activeRevision.value.thumbnails,
-                    ...extendedAttributes,
-                }),
+                activeRevision: !unparsedNode.activeRevision?.ok
+                    ? unparsedNode.activeRevision
+                    : resultOk({
+                          uid: unparsedNode.activeRevision.value.uid,
+                          state: unparsedNode.activeRevision.value.state,
+                          creationTime: unparsedNode.activeRevision.value.creationTime,
+                          storageSize: unparsedNode.activeRevision.value.storageSize,
+                          contentAuthor: unparsedNode.activeRevision.value.contentAuthor,
+                          thumbnails: unparsedNode.activeRevision.value.thumbnails,
+                          ...extendedAttributes,
+                      }),
                 folder: undefined,
-            }
+                treeEventScopeId: splitNodeUid(unparsedNode.uid).volumeId,
+            };
         }
 
         const extendedAttributes = unparsedNode.folder?.extendedAttributes
@@ -283,13 +341,18 @@ export class NodesAccess {
             name: nodeName,
             isStale: false,
             activeRevision: undefined,
-            folder: extendedAttributes ? {
-                ...extendedAttributes,
-            } : undefined,
-        }
+            folder: extendedAttributes
+                ? {
+                      ...extendedAttributes,
+                  }
+                : undefined,
+            treeEventScopeId: splitNodeUid(unparsedNode.uid).volumeId,
+        };
     }
 
-    async getParentKeys(node: Pick<DecryptedNode, 'parentUid' | 'shareId'>): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+    async getParentKeys(
+        node: Pick<DecryptedNode, 'parentUid' | 'shareId'>,
+    ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
         if (node.parentUid) {
             try {
                 return await this.getNodeKeys(node.parentUid);
@@ -306,7 +369,7 @@ export class NodesAccess {
         if (node.shareId) {
             return {
                 key: await this.shareService.getSharePrivateKey(node.shareId),
-            }
+            };
         }
         // This is bug that should not happen.
         // API cannot provide node without parent or share.
@@ -326,11 +389,11 @@ export class NodesAccess {
     }
 
     async getNodePrivateAndSessionKeys(nodeUid: string): Promise<{
-        key: PrivateKey,
-        passphrase: string,
-        passphraseSessionKey: SessionKey,
-        contentKeyPacketSessionKey?: SessionKey,
-        nameSessionKey: SessionKey,
+        key: PrivateKey;
+        passphrase: string;
+        passphraseSessionKey: SessionKey;
+        contentKeyPacketSessionKey?: SessionKey;
+        nameSessionKey: SessionKey;
     }> {
         const node = await this.getNode(nodeUid);
         const { key: parentKey } = await this.getParentKeys(node);
@@ -346,10 +409,10 @@ export class NodesAccess {
     }
 
     async getRootNodeEmailKey(nodeUid: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
     }> {
         const rootNode = await this.getRootNode(nodeUid);
         if (!rootNode.shareId) {
@@ -379,5 +442,5 @@ export class NodesAccess {
     private async getRootNode(nodeUid: string): Promise<DecryptedNode> {
         const node = await this.getNode(nodeUid);
         return node.parentUid ? this.getRootNode(node.parentUid) : node;
-    };
+    }
 }

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

@@ -1,17 +1,16 @@
-import { NodeAPIService } from "./apiService";
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
+import { NodeAPIService } from './apiService';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
 import { NodesAccess } from './nodesAccess';
-import { NodesEvents } from './events';
 import { DecryptedNode } from './interface';
 import { NodesManagement } from './nodesManagement';
+import { NodeResult } from '../../interface';
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;
     let cryptoCache: NodesCryptoCache;
     let cryptoService: NodesCryptoService;
     let nodesAccess: NodesAccess;
-    let nodesEvents: NodesEvents;
     let management: NodesManagement;
 
     let nodes: { [uid: string]: DecryptedNode };
@@ -50,15 +49,21 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
-            trashNodes: jest.fn(),
-            restoreNodes: jest.fn(),
-            deleteNodes: jest.fn(),
+            trashNodes: jest.fn(async function* (uids) {
+                yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
+            }),
+            restoreNodes: jest.fn(async function* (uids) {
+                yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
+            }),
+            deleteNodes: jest.fn(async function* (uids) {
+                yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
+            }),
             createFolder: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoCache = {
             setNodeKeys: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             encryptNewName: jest.fn().mockResolvedValue({
@@ -68,7 +73,7 @@ describe('NodesManagement', () => {
             }),
             moveNode: jest.fn(),
             createFolder: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         nodesAccess = {
             getNode: jest.fn().mockImplementation((uid: string) => nodes[uid]),
@@ -83,23 +88,21 @@ describe('NodesManagement', () => {
                 hashKey: `${nodes[uid].parentUid}-hashKey`,
             })),
             iterateNodes: jest.fn(),
-            getNodePrivateAndSessionKeys: jest.fn().mockImplementation((uid) => Promise.resolve({
-                key: `${uid}-key`,
-                passphrase: `${uid}-passphrase`,
-                passphraseSessionKey: `${uid}-passphraseSessionKey`,
-                contentKeyPacketSessionKey: `${uid}-contentKeyPacketSessionKey`,
-                nameSessionKey: `${uid}-nameSessionKey`,
-            })),
-            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: "root-email", addressKey: "root-key" }),
-        }
-        // @ts-expect-error No need to implement all methods for mocking
-        nodesEvents = {
-            nodeCreated: jest.fn(),
-            nodeUpdated: jest.fn(),
-            nodesDeleted: jest.fn(),
-        }
+            getNodePrivateAndSessionKeys: jest.fn().mockImplementation((uid) =>
+                Promise.resolve({
+                    key: `${uid}-key`,
+                    passphrase: `${uid}-passphrase`,
+                    passphraseSessionKey: `${uid}-passphraseSessionKey`,
+                    contentKeyPacketSessionKey: `${uid}-contentKeyPacketSessionKey`,
+                    nameSessionKey: `${uid}-nameSessionKey`,
+                }),
+            ),
+            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'root-email', addressKey: 'root-key' }),
+            notifyNodeChanged: jest.fn(),
+            notifyNodeDeleted: jest.fn(),
+        };
 
-        management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess, nodesEvents);
+        management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess);
     });
 
     it('renameNode manages rename and updates cache', async () => {
@@ -108,6 +111,7 @@ describe('NodesManagement', () => {
         expect(newNode).toEqual({
             ...nodes.nodeUid,
             name: { ok: true, value: 'new name' },
+            encryptedName: 'newArmoredNodeName',
             nameAuthor: { ok: true, value: 'newSignatureEmail' },
             hash: 'newHash',
         });
@@ -115,15 +119,15 @@ describe('NodesManagement', () => {
         expect(cryptoService.encryptNewName).toHaveBeenCalledWith(
             { key: 'parentUid-key', hashKey: 'parentUid-hashKey' },
             'nodeUid-nameSessionKey',
-            { email: "root-email", addressKey: "root-key" },
+            { email: 'root-email', addressKey: 'root-key' },
             'new name',
         );
         expect(apiService.renameNode).toHaveBeenCalledWith(
             nodes.nodeUid.uid,
             { hash: nodes.nodeUid.hash },
-            { encryptedName: 'newArmoredNodeName', nameSignatureEmail: 'newSignatureEmail', hash: 'newHash' }
+            { encryptedName: 'newArmoredNodeName', nameSignatureEmail: 'newSignatureEmail', hash: 'newHash' },
         );
-        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
     });
 
     it('moveNode manages move and updates cache', async () => {
@@ -134,7 +138,7 @@ describe('NodesManagement', () => {
             armoredNodePassphraseSignature: 'movedArmoredNodePassphraseSignature',
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
-        }
+        };
         cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('nodeUid', 'newParentNodeUid');
@@ -142,6 +146,7 @@ describe('NodesManagement', () => {
         expect(newNode).toEqual({
             ...nodes.nodeUid,
             parentUid: 'newParentNodeUid',
+            encryptedName: 'movedArmoredNodeName',
             hash: 'movedHash',
             keyAuthor: { ok: true, value: 'movedSignatureEmail' },
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
@@ -154,10 +159,10 @@ describe('NodesManagement', () => {
                 passphrase: 'nodeUid-passphrase',
                 passphraseSessionKey: 'nodeUid-passphraseSessionKey',
                 contentKeyPacketSessionKey: 'nodeUid-contentKeyPacketSessionKey',
-                nameSessionKey: 'nodeUid-nameSessionKey'
+                nameSessionKey: 'nodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: "root-email", addressKey: "root-key" },
+            { email: 'root-email', addressKey: 'root-key' },
         );
         expect(apiService.moveNode).toHaveBeenCalledWith(
             'nodeUid',
@@ -171,7 +176,7 @@ describe('NodesManagement', () => {
                 signatureEmail: undefined,
             },
         );
-        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid', 'newParentNodeUid');
     });
 
     it('moveNode manages move of anonymous node', async () => {
@@ -182,7 +187,7 @@ describe('NodesManagement', () => {
             armoredNodePassphraseSignature: 'movedArmoredNodePassphraseSignature',
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
-        }
+        };
         cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('anonymousNodeUid', 'newParentNodeUid');
@@ -194,14 +199,15 @@ describe('NodesManagement', () => {
                 passphrase: 'anonymousNodeUid-passphrase',
                 passphraseSessionKey: 'anonymousNodeUid-passphraseSessionKey',
                 contentKeyPacketSessionKey: 'anonymousNodeUid-contentKeyPacketSessionKey',
-                nameSessionKey: 'anonymousNodeUid-nameSessionKey'
+                nameSessionKey: 'anonymousNodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: "root-email", addressKey: "root-key" },
+            { email: 'root-email', addressKey: 'root-key' },
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
             parentUid: 'newParentNodeUid',
+            encryptedName: 'movedArmoredNodeName',
             hash: 'movedHash',
             keyAuthor: { ok: true, value: 'movedSignatureEmail' },
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
@@ -213,9 +219,28 @@ describe('NodesManagement', () => {
             },
             {
                 parentUid: 'newParentNodeUid',
-                ...encryptedCrypto
+                ...encryptedCrypto,
             },
         );
-        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+    });
+
+    it('trashes node and updates cache', async () => {
+        const uids = ['v1~n1', 'v1~n2'];
+        const trashed = new Set();
+        for await (const node of management.trashNodes(uids)) {
+            trashed.add(node.uid);
+        }
+        expect(trashed).toEqual(new Set(uids));
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
+    });
+
+    it('restores node and updates cache', async () => {
+        const uids = ['v1~n1', 'v1~n2'];
+        const restored = new Set();
+        for await (const node of management.restoreNodes(uids)) {
+            restored.add(node.uid);
+        }
+        expect(restored).toEqual(new Set(uids));
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
     });
 });