@protontech/drive-sdk 0.3.2 → 0.4.1

package/src/internal/nodes/nodesAccess.ts

@@ -12,7 +12,14 @@ 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 {
+    SharesService,
+    EncryptedNode,
+    DecryptedUnparsedNode,
+    DecryptedNode,
+    DecryptedNodeKeys,
+    FilterOptions,
+} from './interface';
 import { validateNodeName } from './validations';
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
 
@@ -49,8 +56,8 @@ export class NodesAccess {
         this.shareService = shareService;
     }
 
-    async getMyFilesRootFolder() {
-        const { volumeId, rootNodeId } = await this.shareService.getMyFilesIDs();
+    async getVolumeRootFolder() {
+        const { volumeId, rootNodeId } = await this.shareService.getOwnVolumeIDs();
         const nodeUid = makeNodeUid(volumeId, rootNodeId);
         return this.getNode(nodeUid);
     }
@@ -71,12 +78,16 @@ export class NodesAccess {
         return node;
     }
 
-    async *iterateFolderChildren(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    async *iterateFolderChildren(
+        parentNodeUid: string,
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
         // 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),
+            iterateItems: (nodeUids) => this.loadNodes(nodeUids, filterOptions, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
 
@@ -84,6 +95,9 @@ export class NodesAccess {
         if (areChildrenCached) {
             for await (const node of this.cache.iterateChildren(parentNodeUid)) {
                 if (node.ok && !node.node.isStale) {
+                    if (filterOptions?.type && node.node.type !== filterOptions.type) {
+                        continue;
+                    }
                     yield node.node;
                 } else {
                     yield* batchLoading.load(node.uid);
@@ -94,13 +108,17 @@ export class NodesAccess {
         }
 
         this.logger.debug(`Folder ${parentNodeUid} children are not cached`);
-        for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, signal)) {
+        const onlyFolders = filterOptions?.type === NodeType.Folder;
+        for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, onlyFolders, signal)) {
             let node;
             try {
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
             if (node && !node.isStale) {
+                if (filterOptions?.type && node.type !== filterOptions.type) {
+                    continue;
+                }
                 yield node;
             } else {
                 this.logger.debug(`Node ${nodeUid} from ${parentNodeUid} is ${node?.isStale ? 'stale' : 'not cached'}`);
@@ -108,14 +126,18 @@ export class NodesAccess {
             }
         }
         yield* batchLoading.loadRest();
-        await this.cache.setFolderChildrenLoaded(parentNodeUid);
+
+        // If some nodes were filtered out, we don't have the folder fully loaded.
+        if (!filterOptions) {
+            await this.cache.setFolderChildrenLoaded(parentNodeUid);
+        }
     }
 
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const { volumeId } = await this.shareService.getMyFilesIDs();
+        const { volumeId } = await this.shareService.getOwnVolumeIDs();
         const batchLoading = new BatchLoading<string, DecryptedNode>({
-            iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal),
+            iterateItems: (nodeUids) => this.loadNodes(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
@@ -136,7 +158,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),
+            iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
         for await (const result of this.cache.iterateNodes(nodeUids)) {
@@ -186,13 +208,17 @@ export class NodesAccess {
     }
 
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
-        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
         const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
         return this.decryptNode(encryptedNode);
     }
 
-    private async *loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        for await (const result of this.loadNodesWithMissingReport(nodeUids, signal)) {
+    private async *loadNodes(
+        nodeUids: string[],
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
+        for await (const result of this.loadNodesWithMissingReport(nodeUids, filterOptions, signal)) {
             if ('missingUid' in result) {
                 continue;
             }
@@ -202,14 +228,15 @@ export class NodesAccess {
 
     private async *loadNodesWithMissingReport(
         nodeUids: string[],
+        filterOptions?: FilterOptions,
         signal?: AbortSignal,
     ): AsyncGenerator<DecryptedNode | MissingNode> {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
-        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
 
-        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, signal);
+        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
         const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {

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

@@ -5,6 +5,7 @@ import { NodesAccess } from './nodesAccess';
 import { DecryptedNode } from './interface';
 import { NodesManagement } from './nodesManagement';
 import { NodeResult } from '../../interface';
+import { NodeOutOfSyncError } from './errors';
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;
@@ -49,6 +50,7 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
+            copyNode: jest.fn(),
             trashNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
@@ -71,7 +73,7 @@ describe('NodesManagement', () => {
                 armoredNodeName: 'newArmoredNodeName',
                 hash: 'newHash',
             }),
-            moveNode: jest.fn(),
+            encryptNodeWithNewParent: jest.fn(),
             createFolder: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
@@ -100,6 +102,7 @@ describe('NodesManagement', () => {
             getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'root-email', addressKey: 'root-key' }),
             notifyNodeChanged: jest.fn(),
             notifyNodeDeleted: jest.fn(),
+            notifyChildCreated: jest.fn(),
         };
 
         management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess);
@@ -130,6 +133,15 @@ describe('NodesManagement', () => {
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
     });
 
+    it('renameNode refreshes cache if node is out of sync', async () => {
+        const error = new NodeOutOfSyncError('Node is out of sync');
+        apiService.renameNode = jest.fn().mockRejectedValue(error);
+
+        await expect(management.renameNode('nodeUid', 'new name')).rejects.toThrow(error);
+
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
+    });
+
     it('moveNode manages move and updates cache', async () => {
         const encryptedCrypto = {
             encryptedName: 'movedArmoredNodeName',
@@ -139,7 +151,7 @@ describe('NodesManagement', () => {
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
         };
-        cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('nodeUid', 'newParentNodeUid');
 
@@ -152,7 +164,7 @@ describe('NodesManagement', () => {
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
         });
         expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
-        expect(cryptoService.moveNode).toHaveBeenCalledWith(
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
             nodes.nodeUid,
             expect.objectContaining({
                 key: 'nodeUid-key',
@@ -188,11 +200,11 @@ describe('NodesManagement', () => {
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
         };
-        cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('anonymousNodeUid', 'newParentNodeUid');
 
-        expect(cryptoService.moveNode).toHaveBeenCalledWith(
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
             nodes.anonymousNodeUid,
             expect.objectContaining({
                 key: 'anonymousNodeUid-key',
@@ -224,6 +236,89 @@ describe('NodesManagement', () => {
         );
     });
 
+    it('copyNode manages copy and updates cache', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            armoredNodePassphrase: 'copiedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'copiedArmoredNodePassphraseSignature',
+            signatureEmail: 'copiedSignatureEmail',
+            nameSignatureEmail: 'copiedNameSignatureEmail',
+        };
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newNode = await management.copyNode('nodeUid', 'newParentNodeUid');
+
+        expect(newNode).toEqual({
+            ...nodes.nodeUid,
+            parentUid: 'newParentNodeUid',
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            keyAuthor: { ok: true, value: 'copiedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'copiedNameSignatureEmail' },
+        });
+        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
+            nodes.nodeUid,
+            expect.objectContaining({
+                key: 'nodeUid-key',
+                passphrase: 'nodeUid-passphrase',
+                passphraseSessionKey: 'nodeUid-passphraseSessionKey',
+                contentKeyPacketSessionKey: 'nodeUid-contentKeyPacketSessionKey',
+                nameSessionKey: 'nodeUid-nameSessionKey',
+            }),
+            expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
+            { email: 'root-email', addressKey: 'root-key' },
+        );
+        expect(apiService.copyNode).toHaveBeenCalledWith('nodeUid', {
+            parentUid: 'newParentNodeUid',
+            ...encryptedCrypto,
+            armoredNodePassphraseSignature: undefined,
+            signatureEmail: undefined,
+        });
+        expect(nodesAccess.notifyNodeChanged).not.toHaveBeenCalledWith();
+        expect(nodesAccess.notifyChildCreated).toHaveBeenCalledWith('newParentNodeUid');
+    });
+
+    it('copyNode manages copy of anonymous node', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            armoredNodePassphrase: 'copiedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'copiedArmoredNodePassphraseSignature',
+            signatureEmail: 'copiedSignatureEmail',
+            nameSignatureEmail: 'copiedNameSignatureEmail',
+        };
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newNode = await management.copyNode('anonymousNodeUid', 'newParentNodeUid');
+
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
+            nodes.anonymousNodeUid,
+            expect.objectContaining({
+                key: 'anonymousNodeUid-key',
+                passphrase: 'anonymousNodeUid-passphrase',
+                passphraseSessionKey: 'anonymousNodeUid-passphraseSessionKey',
+                contentKeyPacketSessionKey: 'anonymousNodeUid-contentKeyPacketSessionKey',
+                nameSessionKey: 'anonymousNodeUid-nameSessionKey',
+            }),
+            expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
+            { email: 'root-email', addressKey: 'root-key' },
+        );
+        expect(newNode).toEqual({
+            ...nodes.anonymousNodeUid,
+            parentUid: 'newParentNodeUid',
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            keyAuthor: { ok: true, value: 'copiedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'copiedNameSignatureEmail' },
+        });
+        expect(apiService.copyNode).toHaveBeenCalledWith('anonymousNodeUid', {
+            parentUid: 'newParentNodeUid',
+            ...encryptedCrypto,
+        });
+    });
+
     it('trashes node and updates cache', async () => {
         const uids = ['v1~n1', 'v1~n2'];
         const trashed = new Set();

package/src/internal/nodes/nodesManagement.ts

@@ -3,14 +3,15 @@ import { c } from 'ttag';
 import { MemberRole, NodeType, NodeResult, resultOk } from '../../interface';
 import { AbortError, ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
+import { splitNodeUid } from '../uids';
 import { NodeAPIService } from './apiService';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { NodeOutOfSyncError } from './errors';
 import { DecryptedNode } from './interface';
 import { NodesAccess } from './nodesAccess';
 import { validateNodeName } from './validations';
 import { generateFolderExtendedAttributes } from './extendedAttributes';
-import { splitNodeUid } from '../uids';
 
 /**
  * Provides high-level actions for managing nodes.
@@ -63,17 +64,28 @@ export class NodesManagement {
             throw new Error('Node hash not generated');
         }
 
-        await this.apiService.renameNode(
-            nodeUid,
-            {
-                hash: node.hash,
-            },
-            {
-                encryptedName: armoredNodeName,
-                nameSignatureEmail: signatureEmail,
-                hash: hash,
-            },
-        );
+        try {
+            await this.apiService.renameNode(
+                nodeUid,
+                {
+                    hash: node.hash,
+                },
+                {
+                    encryptedName: armoredNodeName,
+                    nameSignatureEmail: signatureEmail,
+                    hash: hash,
+                },
+            );
+        } catch (error: unknown) {
+            // If node is out of sync, we notify cache to refresh it before next usage.
+            // We let the code still throw the error as it must bubble to the user
+            // so user can re-open the node to ensure they still want to rename it.
+            if (error instanceof NodeOutOfSyncError) {
+                await this.nodesAccess.notifyNodeChanged(nodeUid);
+            }
+            throw error;
+        }
+
         await this.nodesAccess.notifyNodeChanged(nodeUid);
         const newNode: DecryptedNode = {
             ...node,
@@ -125,7 +137,7 @@ export class NodesManagement {
             throw new ValidationError(c('Error').t`Moving item to a non-folder is not allowed`);
         }
 
-        const encryptedCrypto = await this.cryptoService.moveNode(
+        const encryptedCrypto = await this.cryptoService.encryptNodeWithNewParent(
             node,
             keys,
             { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
@@ -170,6 +182,81 @@ export class NodesManagement {
         return newNode;
     }
 
+    // Improvement requested: copy nodes in parallel
+    async *copyNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        for (const nodeUid of nodeUids) {
+            if (signal?.aborted) {
+                throw new AbortError(c('Error').t`Copy operation aborted`);
+            }
+            try {
+                await this.copyNode(nodeUid, newParentNodeUid);
+                yield {
+                    uid: nodeUid,
+                    ok: true,
+                };
+            } catch (error: unknown) {
+                yield {
+                    uid: nodeUid,
+                    ok: false,
+                    error: getErrorMessage(error),
+                };
+            }
+        }
+    }
+
+    async copyNode(nodeUid: string, newParentUid: string): Promise<DecryptedNode> {
+        const [node, address] = await Promise.all([
+            this.nodesAccess.getNode(nodeUid),
+            this.nodesAccess.getRootNodeEmailKey(newParentUid),
+        ]);
+
+        const [keys, newParentKeys] = await Promise.all([
+            this.nodesAccess.getNodePrivateAndSessionKeys(nodeUid),
+            this.nodesAccess.getNodeKeys(newParentUid),
+        ]);
+
+        if (!newParentKeys.hashKey) {
+            throw new ValidationError(c('Error').t`Copying item to a non-folder is not allowed`);
+        }
+
+        const encryptedCrypto = await this.cryptoService.encryptNodeWithNewParent(
+            node,
+            keys,
+            { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
+            address,
+        );
+
+        // Node could be uploaded or renamed by anonymous user and thus have
+        // missing signatures that must be added to the copy request.
+        // Node passphrase and signature email must be passed if and only if
+        // the the signatures are missing (key author is null).
+        const anonymousKey = node.keyAuthor.ok && node.keyAuthor.value === null;
+        const keySignatureProperties = !anonymousKey
+            ? {}
+            : {
+                  signatureEmail: encryptedCrypto.signatureEmail,
+                  armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
+              };
+        await this.apiService.copyNode(nodeUid, {
+            ...keySignatureProperties,
+            parentUid: newParentUid,
+            armoredNodePassphrase: encryptedCrypto.armoredNodePassphrase,
+            encryptedName: encryptedCrypto.encryptedName,
+            nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
+            hash: encryptedCrypto.hash,
+        });
+        const newNode: DecryptedNode = {
+            ...node,
+            encryptedName: encryptedCrypto.encryptedName,
+            parentUid: newParentUid,
+            hash: encryptedCrypto.hash,
+            keyAuthor: resultOk(encryptedCrypto.signatureEmail),
+            nameAuthor: resultOk(encryptedCrypto.nameSignatureEmail),
+        };
+        await this.nodesAccess.notifyChildCreated(newParentUid);
+        return newNode;
+    }
+
     async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for await (const result of this.apiService.trashNodes(nodeUids, signal)) {
             if (result.ok) {
@@ -242,6 +329,7 @@ export class NodesManagement {
 
             // Share node metadata
             isShared: false,
+            isSharedPublicly: false,
             directRole: MemberRole.Inherited,
 
             // Decrypted metadata

package/src/internal/photos/albums.ts

@@ -1,29 +1,48 @@
+import { BatchLoading } from '../batchLoading';
+import { DecryptedNode } from '../nodes';
 import { PhotosAPIService } from './apiService';
-import { PhotosCache } from './cache';
 import { NodesService } from './interface';
+import { PhotoSharesManager } from './shares';
 
+const BATCH_LOADING_SIZE = 10;
+
+/**
+ * Provides access and high-level actions for managing albums.
+ */
 export class Albums {
     constructor(
         private apiService: PhotosAPIService,
-        private cache: PhotosCache,
+        private photoShares: PhotoSharesManager,
         private nodesService: NodesService,
     ) {
         this.apiService = apiService;
-        this.cache = cache;
+        this.photoShares = photoShares;
         this.nodesService = nodesService;
     }
 
-    async *iterateAlbums() {
-        for await (const album of this.apiService.iterateAlbums()) {
-            const node = await this.nodesService.getNode(album.uid);
-            yield {
-                node,
-            };
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+
+        const batchLoading = new BatchLoading<string, DecryptedNode>({
+            iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
+        });
+        for await (const album of this.apiService.iterateAlbums(volumeId, signal)) {
+            yield* batchLoading.load(album.albumUid);
         }
+        yield* batchLoading.loadRest();
     }
 
-    async createAlbum(albumName: string) {
-        const albumdUid = this.apiService.createAlbum(albumName);
-        await this.cache.setAlbum(albumdUid);
+    private async *iterateNodesAndIgnoreMissingOnes(
+        nodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
+        const nodeGenerator = this.nodesService.iterateNodes(nodeUids, signal);
+        for await (const node of nodeGenerator) {
+            if ('missingUid' in node) {
+                continue;
+            }
+            yield node;
+        }
     }
 }