@protontech/drive-sdk 0.4.1 → 0.5.1

package/src/internal/nodes/nodesAccess.ts

@@ -1,7 +1,16 @@
 import { c } from 'ttag';
 
 import { PrivateKey, SessionKey } from '../../crypto';
-import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from '../../interface';
+import {
+    InvalidNameError,
+    Logger,
+    MissingNode,
+    NodeType,
+    ProtonDriveTelemetry,
+    Result,
+    resultError,
+    resultOk,
+} from '../../interface';
 import { DecryptionError, ProtonDriveError } from '../../errors';
 import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
@@ -11,6 +20,7 @@ import { NodeAPIService } from './apiService';
 import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { NodesDebouncer } from './debouncer';
 import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from './extendedAttributes';
 import {
     SharesService,
@@ -40,20 +50,27 @@ const DECRYPTION_CONCURRENCY = 30;
  * nodes metadata.
  */
 export class NodesAccess {
+    private logger: Logger;
+    private debouncer: NodesDebouncer;
+
     constructor(
-        private logger: Logger,
+        private telemetry: ProtonDriveTelemetry,
         private apiService: NodeAPIService,
         private cache: NodesCache,
         private cryptoCache: NodesCryptoCache,
         private cryptoService: NodesCryptoService,
-        private shareService: SharesService,
+        private shareService: Pick<
+            SharesService,
+            'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
+        >,
     ) {
-        this.logger = logger;
+        this.logger = telemetry.getLogger('nodes');
         this.apiService = apiService;
         this.cache = cache;
         this.cryptoCache = cryptoCache;
         this.cryptoService = cryptoService;
         this.shareService = shareService;
+        this.debouncer = new NodesDebouncer(this.telemetry);
     }
 
     async getVolumeRootFolder() {
@@ -65,6 +82,7 @@ export class NodesAccess {
     async getNode(nodeUid: string): Promise<DecryptedNode> {
         let cachedNode;
         try {
+            await this.debouncer.waitForLoadingNode(nodeUid);
             cachedNode = await this.cache.getNode(nodeUid);
         } catch {}
 
@@ -112,6 +130,7 @@ export class NodesAccess {
         for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, onlyFolders, signal)) {
             let node;
             try {
+                await this.debouncer.waitForLoadingNode(nodeUid);
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
@@ -143,6 +162,7 @@ export class NodesAccess {
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
             let node;
             try {
+                await this.debouncer.waitForLoadingNode(nodeUid);
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
@@ -208,9 +228,14 @@ export class NodesAccess {
     }
 
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
-        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
-        const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
-        return this.decryptNode(encryptedNode);
+        this.debouncer.loadingNode(nodeUid);
+        try {
+            const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+            const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
+            return this.decryptNode(encryptedNode);
+        } finally {
+            this.debouncer.finishedLoadingNode(nodeUid);
+        }
     }
 
     private async *loadNodes(
@@ -236,7 +261,14 @@ export class NodesAccess {
 
         const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
 
-        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
+        const apiNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
+
+        const debouncedNodeMapper = async (encryptedNode: EncryptedNode): Promise<EncryptedNode> => {
+            this.debouncer.loadingNode(encryptedNode.uid);
+            return encryptedNode;
+        };
+        const encryptedNodesIterator = asyncIteratorMap(apiNodesIterator, debouncedNodeMapper, 1);
+
         const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {
@@ -250,6 +282,7 @@ export class NodesAccess {
             encryptedNodesIterator,
             decryptNodeMapper,
             DECRYPTION_CONCURRENCY,
+            signal,
         );
         for await (const node of decryptedNodesIterator) {
             if (node.ok) {
@@ -329,11 +362,12 @@ export class NodesAccess {
                 this.logger.error(`Failed to cache node keys ${node.uid}`, error);
             }
         }
+        this.debouncer.finishedLoadingNode(node.uid);
         return { node, keys };
     }
 
     async getParentKeys(
-        node: Pick<DecryptedNode, 'parentUid' | 'shareId'>,
+        node: Pick<DecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
     ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
         if (node.parentUid) {
             try {
@@ -360,6 +394,7 @@ export class NodesAccess {
 
     async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
         try {
+            await this.debouncer.waitForLoadingNode(nodeUid);
             return await this.cryptoCache.getNodeKeys(nodeUid);
         } catch {
             const { keys } = await this.loadNode(nodeUid);

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

@@ -50,7 +50,7 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
-            copyNode: jest.fn(),
+            copyNode: jest.fn().mockResolvedValue('newCopiedNodeUid'),
             trashNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
@@ -251,6 +251,7 @@ describe('NodesManagement', () => {
 
         expect(newNode).toEqual({
             ...nodes.nodeUid,
+            uid: 'newCopiedNodeUid',
             parentUid: 'newParentNodeUid',
             encryptedName: 'copiedArmoredNodeName',
             hash: 'copiedHash',
@@ -307,6 +308,7 @@ describe('NodesManagement', () => {
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
+            uid: 'newCopiedNodeUid',
             parentUid: 'newParentNodeUid',
             encryptedName: 'copiedArmoredNodeName',
             hash: 'copiedHash',

package/src/internal/nodes/nodesManagement.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { MemberRole, NodeType, NodeResult, resultOk } from '../../interface';
+import { MemberRole, NodeType, NodeResult, NodeResultWithNewUid, resultOk } from '../../interface';
 import { AbortError, ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
 import { splitNodeUid } from '../uids';
@@ -182,16 +182,21 @@ export class NodesManagement {
         return newNode;
     }
 
-    // Improvement requested: copy nodes in parallel
-    async *copyNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    // Improvement requested: copy nodes in parallel using copy_multiple endpoint
+    async *copyNodes(
+        nodeUids: string[],
+        newParentNodeUid: string,
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResultWithNewUid> {
         for (const nodeUid of nodeUids) {
             if (signal?.aborted) {
                 throw new AbortError(c('Error').t`Copy operation aborted`);
             }
             try {
-                await this.copyNode(nodeUid, newParentNodeUid);
+                const { uid: newNodeUid } = await this.copyNode(nodeUid, newParentNodeUid);
                 yield {
                     uid: nodeUid,
+                    newUid: newNodeUid,
                     ok: true,
                 };
             } catch (error: unknown) {
@@ -237,7 +242,7 @@ export class NodesManagement {
                   signatureEmail: encryptedCrypto.signatureEmail,
                   armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
               };
-        await this.apiService.copyNode(nodeUid, {
+        const newNodeUid = await this.apiService.copyNode(nodeUid, {
             ...keySignatureProperties,
             parentUid: newParentUid,
             armoredNodePassphrase: encryptedCrypto.armoredNodePassphrase,
@@ -247,6 +252,7 @@ export class NodesManagement {
         });
         const newNode: DecryptedNode = {
             ...node,
+            uid: newNodeUid,
             encryptedName: encryptedCrypto.encryptedName,
             parentUid: newParentUid,
             hash: encryptedCrypto.hash,

package/src/internal/photos/apiService.ts

@@ -1,12 +1,9 @@
-import { c } from 'ttag';
-
-import { DriveAPIService, drivePaths, NotFoundAPIError } from '../apiService';
+import { DriveAPIService, drivePaths } from '../apiService';
 import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
 import { makeNodeUid } from '../uids';
 
-type GetVolumesResponse = drivePaths['/drive/volumes']['get']['responses']['200']['content']['application/json'];
-
-type GetShareResponse = drivePaths['/drive/shares/{shareID}']['get']['responses']['200']['content']['application/json'];
+type GetPhotoShareResponse =
+    drivePaths['/drive/v2/shares/photos']['get']['responses']['200']['content']['application/json'];
 
 type PostCreateVolumeRequest = Extract<
     drivePaths['/drive/photos/volumes']['post']['requestBody'],
@@ -34,33 +31,19 @@ export class PhotosAPIService {
     }
 
     async getPhotoShare(): Promise<EncryptedRootShare> {
-        // TODO: Switch to drive/v2/shares/photos once available.
-
-        const volumesResponse = await this.apiService.get<GetVolumesResponse>('drive/volumes');
-
-        const photoVolume = volumesResponse.Volumes.find((volume) => volume.Type === 2);
-
-        if (!photoVolume) {
-            throw new NotFoundAPIError(c('Error').t`Photo volume not found`);
-        }
-
-        const response = await this.apiService.get<GetShareResponse>(`drive/shares/${photoVolume.Share.ShareID}`);
-
-        if (!response.AddressID) {
-            throw new Error('Photo root share has not address ID set');
-        }
+        const response = await this.apiService.get<GetPhotoShareResponse>('drive/v2/shares/photos');
 
         return {
-            volumeId: response.VolumeID,
-            shareId: response.ShareID,
-            rootNodeId: response.LinkID,
-            creatorEmail: response.Creator,
+            volumeId: response.Volume.VolumeID,
+            shareId: response.Share.ShareID,
+            rootNodeId: response.Link.Link.LinkID,
+            creatorEmail: response.Share.CreatorEmail,
             encryptedCrypto: {
-                armoredKey: response.Key,
-                armoredPassphrase: response.Passphrase,
-                armoredPassphraseSignature: response.PassphraseSignature,
+                armoredKey: response.Share.Key,
+                armoredPassphrase: response.Share.Passphrase,
+                armoredPassphraseSignature: response.Share.PassphraseSignature,
             },
-            addressId: response.AddressID,
+            addressId: response.Share.AddressID,
             type: ShareType.Photo,
         };
     }

package/src/internal/photos/upload.ts

@@ -5,6 +5,7 @@ import { generateFileExtendedAttributes } from '../nodes';
 import { splitNodeRevisionUid } from '../uids';
 import { UploadAPIService } from '../upload/apiService';
 import { BlockVerifier } from '../upload/blockVerifier';
+import { UploadController } from '../upload/controller';
 import { UploadCryptoService } from '../upload/cryptoService';
 import { FileUploader } from '../upload/fileUploader';
 import { NodeRevisionDraft, NodesService } from '../upload/interface';
@@ -62,6 +63,7 @@ export class PhotoFileUploader extends FileUploader {
             revisionDraft,
             this.photoMetadata,
             onFinish,
+            this.controller,
             this.signal,
         );
     }
@@ -80,9 +82,28 @@ export class PhotoStreamUploader extends StreamUploader {
         revisionDraft: NodeRevisionDraft,
         metadata: PhotoUploadMetadata,
         onFinish: (failure: boolean) => Promise<void>,
+        controller: UploadController,
         signal?: AbortSignal,
     ) {
-        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, signal);
+        const abortController = new AbortController();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                abortController.abort();
+            });
+        }
+
+        super(
+            telemetry,
+            apiService,
+            cryptoService,
+            uploadManager,
+            blockVerifier,
+            revisionDraft,
+            metadata,
+            onFinish,
+            controller,
+            abortController,
+        );
         this.photoUploadManager = uploadManager;
         this.photoMetadata = metadata;
     }

package/src/internal/sharing/apiService.ts

@@ -347,8 +347,8 @@ export class SharingAPIService {
         return response.Share.ID;
     }
 
-    async deleteShare(shareId: string): Promise<void> {
-        await this.apiService.delete(`drive/shares/${shareId}?Force=1`);
+    async deleteShare(shareId: string, force: boolean = false): Promise<void> {
+        await this.apiService.delete(`drive/shares/${shareId}?Force=${force ? 1 : 0}`);
     }
 
     async inviteProtonUser(

package/src/internal/sharing/sharingManagement.ts

@@ -286,7 +286,7 @@ export class SharingManagement {
 
         if (!settings) {
             this.logger.info(`Unsharing node ${nodeUid}`);
-            await this.deleteShare(currentSharing.share.shareId, nodeUid);
+            await this.deleteShareWithForce(currentSharing.share.shareId, nodeUid);
             return;
         }
 
@@ -348,7 +348,7 @@ export class SharingManagement {
             // update local state immediately.
             this.logger.info(`Deleting share ${currentSharing.share.shareId} for node ${nodeUid}`);
             try {
-                await this.deleteShare(currentSharing.share.shareId, nodeUid);
+                await this.deleteShareWithForce(currentSharing.share.shareId, nodeUid);
             } catch (error: unknown) {
                 // If deleting the share fails, we don't want to throw an error
                 // as it might be a race condition that other client updated
@@ -433,8 +433,11 @@ export class SharingManagement {
         };
     }
 
-    private async deleteShare(shareId: string, nodeUid: string): Promise<void> {
-        await this.apiService.deleteShare(shareId);
+    /**
+     * Deletes the share even if it is not empty.
+     */
+    private async deleteShareWithForce(shareId: string, nodeUid: string): Promise<void> {
+        await this.apiService.deleteShare(shareId, true);
         await this.nodesService.notifyNodeChanged(nodeUid);
         if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
             await this.cache.removeSharedByMeNodeUid(nodeUid);

package/src/internal/sharingPublic/apiService.ts

@@ -1,175 +1,38 @@
-import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
-import { Logger, MemberRole } from '../../interface';
-import { makeNodeUid, splitNodeUid } from '../uids';
-import { EncryptedShareCrypto, EncryptedNode } from './interface';
+import { DriveAPIService, drivePaths } from '../apiService';
 
-const PAGE_SIZE = 50;
-
-type GetTokenInfoResponse = drivePaths['/drive/urls/{token}']['get']['responses']['200']['content']['application/json'];
-
-type GetTokenFolderChildrenResponse =
-    drivePaths['/drive/urls/{token}/folders/{linkID}/children']['get']['responses']['200']['content']['application/json'];
+type PostTokenInfoRequest = Extract<
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostTokenInfoResponse =
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['responses']['200']['content']['application/json'];
 
 /**
- * Provides API communication for accessing public link data.
+ * Provides API communication for actions on the public link.
  *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
 export class SharingPublicAPIService {
-    constructor(
-        private logger: Logger,
-        private apiService: DriveAPIService,
-    ) {
-        this.logger = logger;
+    constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
     }
 
-    async getPublicLinkRoot(token: string): Promise<{
-        encryptedNode: EncryptedNode;
-        encryptedShare: EncryptedShareCrypto;
-    }> {
-        const response = await this.apiService.get<GetTokenInfoResponse>(`drive/urls/${token}`);
-        const encryptedNode = tokenToEncryptedNode(this.logger, response.Token);
-
-        return {
-            encryptedNode: encryptedNode,
-            encryptedShare: {
-                base64UrlPasswordSalt: response.Token.SharePasswordSalt,
-                armoredKey: response.Token.ShareKey,
-                armoredPassphrase: response.Token.SharePassphrase,
-            },
-        };
-    }
-
-    async *iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
-        const { volumeId: token, nodeId } = splitNodeUid(parentUid);
-
-        let page = 0;
-        while (true) {
-            const response = await this.apiService.get<GetTokenFolderChildrenResponse>(
-                `drive/urls/${token}/folders/${nodeId}/children?Page=${page}&PageSize=${PAGE_SIZE}`,
-                signal,
-            );
-
-            for (const link of response.Links) {
-                yield linkToEncryptedNode(this.logger, token, link);
-            }
-
-            if (response.Links.length < PAGE_SIZE) {
-                break;
-            }
-            page++;
-        }
-    }
-}
-
-function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token']): EncryptedNode {
-    const baseNodeMetadata = {
-        // Internal metadata
-        encryptedName: token.Name,
-
-        // Basic node metadata
-        uid: makeNodeUid(token.Token, token.LinkID),
-        parentUid: undefined,
-        type: nodeTypeNumberToNodeType(logger, token.LinkType),
-        creationTime: new Date(), // TODO
-
-        isShared: false,
-        isSharedPublicly: false,
-        directRole: MemberRole.Viewer, // TODO
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: token.SignatureEmail || undefined,
-        armoredKey: token.NodeKey,
-        armoredNodePassphrase: token.NodePassphrase,
-        armoredNodePassphraseSignature: token.NodePassphraseSignature || undefined,
-    };
-
-    if (token.LinkType === 1 && token.NodeHashKey) {
-        return {
-            ...baseNodeMetadata,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                folder: {
-                    armoredHashKey: token.NodeHashKey as string,
+    async bookmarkPublicLink(bookmark: {
+        token: string;
+        encryptedUrlPassword: string;
+        addressId: string;
+        addressKeyId: string;
+    }): Promise<void> {
+        await this.apiService.post<PostTokenInfoRequest, PostTokenInfoResponse>(
+            `drive/v2/urls/${bookmark.token}/bookmark`,
+            {
+                BookmarkShareURL: {
+                    EncryptedUrlPassword: bookmark.encryptedUrlPassword,
+                    AddressID: bookmark.addressId,
+                    AddressKeyID: bookmark.addressKeyId,
                 },
             },
-        };
+        );
     }
-
-    if (token.LinkType === 2 && token.ContentKeyPacket) {
-        return {
-            ...baseNodeMetadata,
-            totalStorageSize: token.Size || undefined,
-            mediaType: token.MIMEType || undefined,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                file: {
-                    base64ContentKeyPacket: token.ContentKeyPacket,
-                },
-            },
-        };
-    }
-
-    throw new Error(`Unknown node type: ${token.LinkType}`);
-}
-
-function linkToEncryptedNode(
-    logger: Logger,
-    token: string,
-    link: GetTokenFolderChildrenResponse['Links'][0],
-): EncryptedNode {
-    const baseNodeMetadata = {
-        // Internal metadata
-        hash: link.Hash || undefined,
-        encryptedName: link.Name,
-
-        // Basic node metadata
-        uid: makeNodeUid(token, link.LinkID),
-        parentUid: link.ParentLinkID ? makeNodeUid(token, link.ParentLinkID) : undefined,
-        type: nodeTypeNumberToNodeType(logger, link.Type),
-        creationTime: new Date(), // TODO
-        totalStorageSize: link.TotalSize,
-
-        isShared: false,
-        isSharedPublicly: false,
-        directRole: MemberRole.Viewer, // TODO
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: link.SignatureEmail || undefined,
-        armoredKey: link.NodeKey,
-        armoredNodePassphrase: link.NodePassphrase,
-        armoredNodePassphraseSignature: link.NodePassphraseSignature || undefined,
-    };
-
-    if (link.Type === 1 && link.FolderProperties) {
-        return {
-            ...baseNodeMetadata,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                folder: {
-                    armoredHashKey: link.FolderProperties.NodeHashKey as string,
-                },
-            },
-        };
-    }
-
-    if (link.Type === 2 && link.FileProperties?.ContentKeyPacket) {
-        return {
-            ...baseNodeMetadata,
-            totalStorageSize: link.FileProperties.ActiveRevision?.Size || undefined,
-            mediaType: link.MIMEType || undefined,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                file: {
-                    base64ContentKeyPacket: link.FileProperties.ContentKeyPacket,
-                },
-            },
-        };
-    }
-
-    throw new Error(`Unknown node type: ${link.Type}`);
 }

package/src/internal/sharingPublic/{cryptoService.ts → cryptoReporter.ts}

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
+import { VERIFICATION_STATUS } from '../../crypto';
 import { getVerificationMessage } from '../errors';
 import {
     resultOk,
@@ -12,34 +12,9 @@ import {
     MetricVolumeType,
     MetricsDecryptionErrorField,
     Logger,
-    ProtonDriveAccount,
 } from '../../interface';
-import { NodesCryptoService } from '../nodes/cryptoService';
-import { EncryptedShareCrypto } from './interface';
 
-export class SharingPublicCryptoService extends NodesCryptoService {
-    constructor(
-        telemetry: ProtonDriveTelemetry,
-        driveCrypto: DriveCrypto,
-        account: ProtonDriveAccount,
-        private password: string,
-    ) {
-        super(telemetry, driveCrypto, account, new SharingPublicCryptoReporter(telemetry));
-        this.password = password;
-    }
-
-    async decryptPublicLinkShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey> {
-        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
-            this.password,
-            encryptedShare.base64UrlPasswordSalt,
-            encryptedShare.armoredKey,
-            encryptedShare.armoredPassphrase,
-        );
-        return shareKey;
-    }
-}
-
-class SharingPublicCryptoReporter {
+export class SharingPublicCryptoReporter {
     private logger: Logger;
     private telemetry: ProtonDriveTelemetry;