@protontech/drive-sdk 0.2.1 → 0.3.0

package/src/internal/nodes/cryptoService.ts

@@ -61,6 +61,8 @@ export class NodesCryptoService {
         node: EncryptedNode,
         parentKey: PrivateKey,
     ): Promise<{ node: DecryptedUnparsedNode; keys?: DecryptedNodeKeys }> {
+        const start = Date.now();
+
         const commonNodeMetadata = {
             ...node,
             encryptedCrypto: undefined,
@@ -89,16 +91,17 @@ export class NodesCryptoService {
                 : nodeParentKeys;
         }
 
-        const { name, author: nameAuthor } = await this.decryptName(node, parentKey, nameVerificationKeys);
-
-        let membership;
-        if (node.membership) {
-            membership = await this.decryptMembership(node);
-        }
+        // Start promises early, but await them only when required to do
+        // as much work as possible in parallel.
+        const [membershipPromise, namePromise, keyPromise] = [
+            node.membership ? this.decryptMembership(node) : undefined,
+            this.decryptName(node, parentKey, nameVerificationKeys),
+            this.decryptKey(node, parentKey, keyVerificationKeys),
+        ];
 
         let passphrase, key, passphraseSessionKey, keyAuthor;
         try {
-            const keyResult = await this.decryptKey(node, parentKey, keyVerificationKeys);
+            const keyResult = await keyPromise;
             passphrase = keyResult.passphrase;
             key = keyResult.key;
             passphraseSessionKey = keyResult.passphraseSessionKey;
@@ -107,12 +110,17 @@ export class NodesCryptoService {
             void this.reportDecryptionError(node, 'nodeKey', error);
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt node key: ${message}`;
+            const { name, author: nameAuthor } = await namePromise;
+            const membership = await membershipPromise;
             return {
                 node: {
                     ...commonNodeMetadata,
                     name,
                     keyAuthor: resultError({
-                        claimedAuthor: node.encryptedCrypto.signatureEmail,
+                        claimedAuthor: getClaimedAuthor(
+                            node.encryptedCrypto.signatureEmail,
+                            keyVerificationKeys.length === 0,
+                        ),
                         error: errorMessage,
                     }),
                     nameAuthor,
@@ -131,8 +139,23 @@ export class NodesCryptoService {
         let folder;
         let folderExtendedAttributesAuthor;
         if ('folder' in node.encryptedCrypto) {
+            const folderExtendedAttributesVerificationKeys = node.encryptedCrypto.signatureEmail
+                ? signatureEmailKeys
+                : [key];
+
+            const [hashKeyPromise, folderExtendedAttributesPromise] = [
+                this.decryptHashKey(node, key, signatureEmailKeys),
+                this.decryptExtendedAttributes(
+                    node,
+                    node.encryptedCrypto.folder.armoredExtendedAttributes,
+                    key,
+                    folderExtendedAttributesVerificationKeys,
+                    node.encryptedCrypto.signatureEmail,
+                ),
+            ];
+
             try {
-                const hashKeyResult = await this.decryptHashKey(node, key, signatureEmailKeys);
+                const hashKeyResult = await hashKeyPromise;
                 hashKey = hashKeyResult.hashKey;
                 hashKeyAuthor = hashKeyResult.author;
             } catch (error: unknown) {
@@ -141,16 +164,7 @@ export class NodesCryptoService {
             }
 
             try {
-                const folderExtendedAttributesVerificationKeys = node.encryptedCrypto.signatureEmail
-                    ? signatureEmailKeys
-                    : [key];
-                const extendedAttributesResult = await this.decryptExtendedAttributes(
-                    node,
-                    node.encryptedCrypto.folder.armoredExtendedAttributes,
-                    key,
-                    folderExtendedAttributesVerificationKeys,
-                    node.encryptedCrypto.signatureEmail,
-                );
+                const extendedAttributesResult = await folderExtendedAttributesPromise;
                 folder = {
                     extendedAttributes: extendedAttributesResult.extendedAttributes,
                 };
@@ -165,10 +179,20 @@ export class NodesCryptoService {
         let contentKeyPacketSessionKey;
         let contentKeyPacketAuthor;
         if ('file' in node.encryptedCrypto) {
+            const [activeRevisionPromise, contentKeyPacketSessionKeyPromise] = [
+                this.decryptRevision(node.uid, node.encryptedCrypto.activeRevision, key),
+                this.driveCrypto.decryptAndVerifySessionKey(
+                    node.encryptedCrypto.file.base64ContentKeyPacket,
+                    node.encryptedCrypto.file.armoredContentKeyPacketSignature,
+                    key,
+                    // Content key packet is signed with the node key, but
+                    // in the past some clients signed with the address key.
+                    [key, ...keyVerificationKeys],
+                ),
+            ];
+
             try {
-                activeRevision = resultOk(
-                    await this.decryptRevision(node.uid, node.encryptedCrypto.activeRevision, key),
-                );
+                activeRevision = resultOk(await activeRevisionPromise);
             } catch (error: unknown) {
                 void this.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 const message = getErrorMessage(error);
@@ -177,18 +201,10 @@ export class NodesCryptoService {
             }
 
             try {
-                const keySessionKeyResult = await this.driveCrypto.decryptAndVerifySessionKey(
-                    node.encryptedCrypto.file.base64ContentKeyPacket,
-                    node.encryptedCrypto.file.armoredContentKeyPacketSignature,
-                    key,
-                    // Content key packet is signed with the node key, but
-                    // in the past some clients signed with the address key.
-                    [key, ...keyVerificationKeys],
-                );
-
+                const keySessionKeyResult = await contentKeyPacketSessionKeyPromise;
                 contentKeyPacketSessionKey = keySessionKeyResult.sessionKey;
                 contentKeyPacketAuthor =
-                    keySessionKeyResult.verified &&
+                    keySessionKeyResult.verified !== undefined &&
                     (await this.handleClaimedAuthor(
                         node,
                         'nodeContentKey',
@@ -230,6 +246,13 @@ export class NodesCryptoService {
             finalKeyAuthor = keyAuthor;
         }
 
+        const { name, author: nameAuthor } = await namePromise;
+        const membership = await membershipPromise;
+
+        const end = Date.now();
+        const duration = end - start;
+        this.logger.debug(`Node ${node.uid} decrypted in ${duration}ms`);
+
         return {
             node: {
                 ...commonNodeMetadata,
@@ -319,7 +342,7 @@ export class NodesCryptoService {
             return {
                 name: resultError(new Error(errorMessage)),
                 author: resultError({
-                    claimedAuthor: nameSignatureEmail,
+                    claimedAuthor: getClaimedAuthor(nameSignatureEmail, verificationKeys.length === 0),
                     error: errorMessage,
                 }),
             };
@@ -635,6 +658,7 @@ export class NodesCryptoService {
         if (this.reportedVerificationErrors.has(node.uid)) {
             return;
         }
+        this.reportedVerificationErrors.add(node.uid);
 
         const fromBefore2024 = node.creationTime < new Date('2024-01-01');
 
@@ -661,7 +685,6 @@ export class NodesCryptoService {
             error: verificationErrors?.map((e) => e.message).join(', '),
             uid: node.uid,
         });
-        this.reportedVerificationErrors.add(node.uid);
     }
 
     private async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
@@ -716,3 +739,14 @@ function handleClaimedAuthor(
         error: getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
     });
 }
+
+function getClaimedAuthor(
+    claimedAuthor?: string,
+    notAvailableVerificationKeys = false,
+): string | AnonymousUser | undefined {
+    if (!claimedAuthor && notAvailableVerificationKeys) {
+        return null as AnonymousUser;
+    }
+
+    return claimedAuthor;
+}

package/src/internal/nodes/nodesAccess.ts

@@ -24,7 +24,7 @@ const BATCH_LOADING_SIZE = 30;
 // 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;
+const DECRYPTION_CONCURRENCY = 30;
 
 /**
  * Provides access to node metadata.
@@ -234,7 +234,7 @@ export class NodesAccess {
 
         if (errors.length > 0) {
             this.logger.error(`Failed to decrypt ${errors.length} nodes`, errors);
-            throw new ProtonDriveError(c('Error').t`Failed to decrypt some nodes`, { cause: errors });
+            throw new DecryptionError(c('Error').t`Failed to decrypt some nodes`, { cause: errors });
         }
 
         const missingNodeUids = nodeUids.filter((nodeUid) => !returnedNodeUids.includes(nodeUid));

package/src/internal/nodes/nodesManagement.ts

@@ -189,11 +189,8 @@ export class NodesManagement {
     }
 
     async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const deletedNodeUids = [];
-
         for await (const result of this.apiService.deleteNodes(nodeUids, signal)) {
             if (result.ok) {
-                deletedNodeUids.push(result.uid);
                 await this.nodesAccess.notifyNodeDeleted(result.uid);
             }
             yield result;

package/src/internal/sharing/interface.ts

@@ -145,10 +145,6 @@ export interface SharesService {
     getMyFilesIDs(): Promise<{ volumeId: string }>;
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getMyFilesShareMemberEmailKey(): Promise<{
-        addressId: string;
-        addressKey: PrivateKey;
-    }>;
-    getContextShareMemberEmailKey(shareId: string): Promise<{
         email: string;
         addressId: string;
         addressKey: PrivateKey;

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

@@ -3,7 +3,7 @@ import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
 import { SharesService, NodesService } from './interface';
-import { SharingAccess } from './sharingAccess';
+import { SharingAccess, BATCH_LOADING_SIZE } from './sharingAccess';
 
 describe('SharingAccess', () => {
     let apiService: SharingAPIService;
@@ -14,7 +14,7 @@ describe('SharingAccess', () => {
 
     let sharingAccess: SharingAccess;
 
-    const nodeUids = Array.from({ length: 15 }, (_, i) => `nodeUid${i}`);
+    const nodeUids = Array.from({ length: BATCH_LOADING_SIZE + 5 }, (_, i) => `nodeUid${i}`);
     const nodes = nodeUids.map((nodeUid) => ({ nodeUid }));
     const nodeUidsIterator = async function* () {
         for (const nodeUid of nodeUids) {
@@ -84,7 +84,7 @@ describe('SharingAccess', () => {
 
             expect(result).toEqual(nodes);
             expect(apiService.iterateSharedNodeUids).toHaveBeenCalledWith('volumeId', undefined);
-            expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // 15 / 10 per batch
+            expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // Mocked is a bit more over one batch
             expect(cache.setSharedByMeNodeUids).toHaveBeenCalledWith(nodeUids);
         });
     });
@@ -107,7 +107,7 @@ describe('SharingAccess', () => {
 
             expect(result).toEqual(nodes);
             expect(apiService.iterateSharedWithMeNodeUids).toHaveBeenCalledWith(undefined);
-            expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // 15 / 10 per batch
+            expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // Mocked is a bit more over one batch
             expect(cache.setSharedWithMeNodeUids).toHaveBeenCalledWith(nodeUids);
         });
     });

package/src/internal/sharing/sharingAccess.ts

@@ -9,6 +9,10 @@ import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
 import { SharesService, NodesService } from './interface';
 
+// 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.
+export const BATCH_LOADING_SIZE = 30;
+
 /**
  * Provides high-level actions for access shared nodes.
  *
@@ -66,6 +70,7 @@ export class SharingAccess {
     ): AsyncGenerator<DecryptedNode> {
         const batchLoading = new BatchLoading<string, DecryptedNode>({
             iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
         });
         for (const nodeUid of nodeUids) {
             yield* batchLoading.load(nodeUid);
@@ -81,6 +86,7 @@ export class SharingAccess {
         const loadedNodeUids = [];
         const batchLoading = new BatchLoading<string, DecryptedNode>({
             iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
         });
         for await (const nodeUid of nodeUidsIterator) {
             loadedNodeUids.push(nodeUid);

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

@@ -58,11 +58,9 @@ describe('SharingManagement', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
-            generateShareKeys: jest
-                .fn()
-                .mockResolvedValue({
-                    shareKey: { encrypted: 'encrypted-key', decrypted: { passphraseSessionKey: 'pass-session-key' } },
-                }),
+            generateShareKeys: jest.fn().mockResolvedValue({
+                shareKey: { encrypted: 'encrypted-key', decrypted: { passphraseSessionKey: 'pass-session-key' } },
+            }),
             decryptShare: jest.fn().mockImplementation((share) => share),
             decryptInvitation: jest.fn().mockImplementation((invitation) => invitation),
             decryptExternalInvitation: jest.fn().mockImplementation((invitation) => invitation),
@@ -70,7 +68,7 @@ describe('SharingManagement', () => {
             encryptInvitation: jest.fn().mockImplementation(() => {}),
             encryptExternalInvitation: jest.fn().mockImplementation((invitation) => ({
                 ...invitation,
-                base64ExternalInvitationSignature: 'extenral-signature',
+                base64ExternalInvitationSignature: 'external-signature',
             })),
             decryptPublicLink: jest.fn().mockImplementation((publicLink) => publicLink),
             generatePublicLinkPassword: jest.fn().mockResolvedValue('generatedPassword'),
@@ -85,17 +83,12 @@ describe('SharingManagement', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            loadEncryptedShare: jest
-                .fn()
-                .mockResolvedValue({
-                    id: 'shareId',
-                    addressId: 'addressId',
-                    creatorEmail: 'address@example.com',
-                    passphraseSessionKey: 'sharePassphraseSessionKey',
-                }),
-            getContextShareMemberEmailKey: jest
-                .fn()
-                .mockResolvedValue({ email: 'volume-email', addressId: 'addressId', addressKey: 'volume-key' }),
+            loadEncryptedShare: jest.fn().mockResolvedValue({
+                id: 'shareId',
+                addressId: 'addressId',
+                creatorEmail: 'address@example.com',
+                passphraseSessionKey: 'sharePassphraseSessionKey',
+            }),
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {
@@ -196,13 +189,11 @@ describe('SharingManagement', () => {
         const nodeUid = 'volumeId~nodeUid';
 
         it('should create share if no exists', async () => {
-            nodesService.getNode = jest
-                .fn()
-                .mockImplementation((nodeUid) => ({
-                    nodeUid,
-                    parentUid: 'parentUid',
-                    name: { ok: true, value: 'name' },
-                }));
+            nodesService.getNode = jest.fn().mockImplementation((nodeUid) => ({
+                nodeUid,
+                parentUid: 'parentUid',
+                name: { ok: true, value: 'name' },
+            }));
             nodesService.notifyNodeChanged = jest.fn();
 
             const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ['email'] });
@@ -347,6 +338,24 @@ describe('SharingManagement', () => {
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
             });
+
+            it('should use address from the root node context share', async () => {
+                nodesService.getRootNodeEmailKey = jest
+                    .fn()
+                    .mockResolvedValue({ email: 'my-volume-email', addressKey: 'my-volume-key' });
+
+                await sharingManagement.shareNode(nodeUid, { users: ['email'] });
+
+                expect(apiService.inviteProtonUser).toHaveBeenCalledWith(
+                    'shareId',
+                    {
+                        addedByEmail: 'my-volume-email',
+                        inviteeEmail: 'email',
+                        role: 'viewer',
+                    },
+                    expect.anything(),
+                );
+            });
         });
 
         describe('external invitations', () => {
@@ -434,6 +443,27 @@ describe('SharingManagement', () => {
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
             });
+
+            it('should use address from the root node context share', async () => {
+                nodesService.getRootNodeEmailKey = jest.fn().mockResolvedValue({
+                    email: 'my-volume-email',
+                    addressId: 'my-volume-addressId',
+                    addressKey: 'my-volume-key',
+                });
+
+                await sharingManagement.shareNode(nodeUid, { users: ['email'] });
+
+                expect(apiService.inviteExternalUser).toHaveBeenCalledWith(
+                    'shareId',
+                    {
+                        inviterAddressId: 'my-volume-addressId',
+                        inviteeEmail: 'email',
+                        role: 'viewer',
+                        base64Signature: 'external-signature',
+                    },
+                    expect.anything(),
+                );
+            });
         });
 
         describe('mix of internal and external invitations', () => {

package/src/internal/sharing/sharingManagement.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { SessionKey } from '../../crypto';
+import { PrivateKey, SessionKey } from '../../crypto';
 import { ValidationError } from '../../errors';
 import {
     Logger,
@@ -33,6 +33,12 @@ interface Share {
     passphraseSessionKey: SessionKey;
 }
 
+interface ContextShareAddress {
+    addressId: string;
+    addressKey: PrivateKey;
+    email: string;
+}
+
 interface EmailOptions {
     message?: string;
     nodeName?: string;
@@ -138,18 +144,22 @@ export class SharingManagement {
             throw new ValidationError(c('Error').t`Expiration date cannot be in the past`);
         }
 
+        let contextShareAddress: ContextShareAddress;
         let currentSharing = await this.getInternalSharingInfo(nodeUid);
-        if (!currentSharing) {
+        if (currentSharing) {
+            contextShareAddress = await this.nodesService.getRootNodeEmailKey(nodeUid);
+        } else {
             const node = await this.nodesService.getNode(nodeUid);
-            const share = await this.createShare(nodeUid);
+            const result = await this.createShare(nodeUid);
             currentSharing = {
-                share,
+                share: result.share,
                 nodeName: node.name.ok ? node.name.value : node.name.error.name,
                 protonInvitations: [],
                 nonProtonInvitations: [],
                 members: [],
                 publicLink: undefined,
             };
+            contextShareAddress = result.contextShareAddress;
         }
 
         const emailOptions: EmailOptions = {
@@ -187,7 +197,13 @@ export class SharingManagement {
             }
 
             this.logger.info(`Inviting user ${email} with role ${role} to node ${nodeUid}`);
-            const invitation = await this.inviteProtonUser(currentSharing.share, email, role, emailOptions);
+            const invitation = await this.inviteProtonUser(
+                contextShareAddress,
+                currentSharing.share,
+                email,
+                role,
+                emailOptions,
+            );
             currentSharing.protonInvitations.push(invitation);
         }
 
@@ -225,7 +241,13 @@ export class SharingManagement {
             }
 
             this.logger.info(`Inviting external user ${email} with role ${role} to node ${nodeUid}`);
-            const invitation = await this.inviteExternalUser(currentSharing.share, email, role, emailOptions);
+            const invitation = await this.inviteExternalUser(
+                contextShareAddress,
+                currentSharing.share,
+                email,
+                role,
+                emailOptions,
+            );
             currentSharing.nonProtonInvitations.push(invitation);
         }
 
@@ -241,7 +263,7 @@ export class SharingManagement {
                 );
             } else {
                 this.logger.info(`Sharing via public link with role ${options.role} to node ${nodeUid}`);
-                currentSharing.publicLink = await this.shareViaLink(currentSharing.share, options);
+                currentSharing.publicLink = await this.shareViaLink(contextShareAddress, currentSharing.share, options);
             }
         }
 
@@ -371,7 +393,7 @@ export class SharingManagement {
         };
     }
 
-    private async createShare(nodeUid: string): Promise<Share> {
+    private async createShare(nodeUid: string): Promise<{ share: Share; contextShareAddress: ContextShareAddress }> {
         const node = await this.nodesService.getNode(nodeUid);
         if (!node.parentUid) {
             throw new ValidationError(c('Error').t`Cannot share root folder`);
@@ -387,12 +409,22 @@ export class SharingManagement {
             base64NameKeyPacket: keys.base64NameKeyPacket,
         });
         await this.nodesService.notifyNodeChanged(nodeUid);
-        return {
+
+        const share = {
             volumeId,
             shareId,
             creatorEmail: email,
             passphraseSessionKey: keys.shareKey.decrypted.passphraseSessionKey,
         };
+        const contextShareAddress = {
+            email,
+            addressId,
+            addressKey,
+        };
+        return {
+            share,
+            contextShareAddress,
+        };
     }
 
     private async deleteShare(shareId: string, nodeUid: string): Promise<void> {
@@ -401,12 +433,12 @@ export class SharingManagement {
     }
 
     private async inviteProtonUser(
+        inviter: ContextShareAddress,
         share: Share,
         inviteeEmail: string,
         role: MemberRole,
         emailOptions: EmailOptions,
     ): Promise<ProtonInvitation> {
-        const inviter = await this.sharesService.getContextShareMemberEmailKey(share.shareId);
         const invitationCrypto = await this.cryptoService.encryptInvitation(
             share.passphraseSessionKey,
             inviter.addressKey,
@@ -461,12 +493,12 @@ export class SharingManagement {
     }
 
     private async inviteExternalUser(
+        inviter: ContextShareAddress,
         share: Share,
         inviteeEmail: string,
         role: MemberRole,
         emailOptions: EmailOptions,
     ): Promise<NonProtonInvitation> {
-        const inviter = await this.sharesService.getContextShareMemberEmailKey(share.shareId);
         const invitationCrypto = await this.cryptoService.encryptExternalInvitation(
             share.passphraseSessionKey,
             inviter.addressKey,
@@ -515,21 +547,20 @@ export class SharingManagement {
     }
 
     private async shareViaLink(
+        inviter: ContextShareAddress,
         share: Share,
         options: SharePublicLinkSettingsObject,
     ): Promise<PublicLinkWithCreatorEmail> {
-        const { email: creatorEmail } = await this.sharesService.getContextShareMemberEmailKey(share.shareId);
-
         const generatedPassword = await this.cryptoService.generatePublicLinkPassword();
         const password = options.customPassword ? `${generatedPassword}${options.customPassword}` : generatedPassword;
 
         const { crypto, srp } = await this.cryptoService.encryptPublicLink(
-            creatorEmail,
+            inviter.email,
             share.passphraseSessionKey,
             password,
         );
         const publicLink = await this.apiService.createPublicLink(share.shareId, {
-            creatorEmail,
+            creatorEmail: inviter.email,
             role: options.role,
             includesCustomPassword: !!options.customPassword,
             expirationTime: options.expiration ? Math.floor(options.expiration.getTime() / 1000) : undefined,
@@ -545,7 +576,7 @@ export class SharingManagement {
             customPassword: options.customPassword,
             expirationTime: options.expiration,
             numberOfInitializedDownloads: 0,
-            creatorEmail,
+            creatorEmail: inviter.email,
         };
     }
 

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

@@ -206,7 +206,7 @@ describe('UploadManager', () => {
                 await promise;
             } catch (error: any) {
                 expect(error.message).toBe('Draft already exists');
-                expect(error.ongoingUploadByOtherClient).toBe(true);
+                expect(error.isUnfinishedUpload).toBe(true);
             }
             expect(apiService.deleteDraft).not.toHaveBeenCalled();
         });
@@ -237,7 +237,7 @@ describe('UploadManager', () => {
                 await promise;
             } catch (error: any) {
                 expect(error.message).toBe('Draft already exists');
-                expect(error.ongoingUploadByOtherClient).toBe(true);
+                expect(error.isUnfinishedUpload).toBe(true);
             }
             expect(apiService.deleteDraft).not.toHaveBeenCalled();
         });

package/src/internal/upload/manager.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
 import { Logger, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
-import { ValidationError, NodeAlreadyExistsValidationError } from '../../errors';
+import { ValidationError, NodeWithSameNameExistsValidationError } from '../../errors';
 import { ErrorCode } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';
 import { UploadAPIService } from './apiService';
@@ -158,9 +158,7 @@ export class UploadManager {
                         ? makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID)
                         : undefined;
 
-                    // If there is existing node, return special error
-                    // that includes the available name the client can use.
-                    throw new NodeAlreadyExistsValidationError(
+                    throw new NodeWithSameNameExistsValidationError(
                         error.message,
                         error.code,
                         existingNodeUid,