@protontech/drive-sdk 0.2.0 → 0.3.0

package/src/internal/sharing/cryptoService.ts

@@ -411,10 +411,7 @@ export class SharingCryptoService {
                 };
             case PublicLinkFlags.GeneratedPasswordIncluded:
             case PublicLinkFlags.GeneratedPasswordWithCustomPassword:
-                return {
-                    password: password.substring(0, PUBLIC_LINK_GENERATED_PASSWORD_LENGTH),
-                    customPassword: password.substring(PUBLIC_LINK_GENERATED_PASSWORD_LENGTH) || undefined,
-                };
+                return splitGeneratedAndCustomPassword(password);
             default:
                 throw new Error(`Unsupported public link with flags: ${encryptedPublicLink.flags}`);
         }
@@ -422,18 +419,24 @@ export class SharingCryptoService {
 
     async decryptBookmark(encryptedBookmark: EncryptedBookmark): Promise<{
         url: Result<string, Error>;
+        customPassword: Result<string | undefined, Error>;
         nodeName: Result<string, Error | InvalidNameError>;
     }> {
         // TODO: Signatures are not checked and not specified in the interface.
         // In the future, we will need to add authorship verification.
 
         let urlPassword: string;
+        let customPassword: Result<string | undefined, Error>;
         try {
-            urlPassword = await this.decryptBookmarkUrlPassword(encryptedBookmark);
+            const password = await this.decryptBookmarkUrlPassword(encryptedBookmark);
+            const result = splitGeneratedAndCustomPassword(password);
+            urlPassword = result.password;
+            customPassword = resultOk(result.customPassword);
         } catch (originalError: unknown) {
             const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
             return {
                 url: resultError(error),
+                customPassword: resultError(error),
                 nodeName: resultError(error),
             };
         }
@@ -448,6 +451,7 @@ export class SharingCryptoService {
             const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
             return {
                 url,
+                customPassword,
                 nodeName: resultError(error),
             };
         }
@@ -456,6 +460,7 @@ export class SharingCryptoService {
 
         return {
             url,
+            customPassword,
             nodeName,
         };
     }
@@ -551,3 +556,12 @@ export class SharingCryptoService {
         }
     }
 }
+
+function splitGeneratedAndCustomPassword(concatenatedPassword: string): {
+    password: string;
+    customPassword?: string;
+} {
+    const password = concatenatedPassword.substring(0, PUBLIC_LINK_GENERATED_PASSWORD_LENGTH);
+    const customPassword = concatenatedPassword.substring(PUBLIC_LINK_GENERATED_PASSWORD_LENGTH) || undefined;
+    return { password, customPassword };
+}

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);
         });
     });
@@ -116,6 +116,7 @@ describe('SharingAccess', () => {
         it('should return decrypted bookmark', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
                 url: resultOk('url'),
+                customPassword: resultOk('customPassword'),
                 nodeName: resultOk('nodeName'),
             });
 
@@ -126,6 +127,7 @@ describe('SharingAccess', () => {
                     uid: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     url: 'url',
+                    customPassword: 'customPassword',
                     node: {
                         name: 'nodeName',
                         type: NodeType.File,
@@ -138,6 +140,7 @@ describe('SharingAccess', () => {
         it('should return degraded bookmark if URL password cannot be decrypted', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
                 url: resultError('url cannot be decrypted'),
+                customPassword: resultOk('url cannot be decrypted'),
                 nodeName: resultError('url cannot be decrypted'),
             });
 
@@ -148,6 +151,7 @@ describe('SharingAccess', () => {
                     uid: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     url: resultError('url cannot be decrypted'),
+                    customPassword: resultOk('url cannot be decrypted'),
                     node: {
                         name: resultError('url cannot be decrypted'),
                         type: NodeType.File,
@@ -160,6 +164,7 @@ describe('SharingAccess', () => {
         it('should return degraded bookmark if node name cannot be decrypted', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
                 url: resultOk('url'),
+                customPassword: resultOk(undefined),
                 nodeName: resultError('node name cannot be decrypted'),
             });
 
@@ -170,6 +175,7 @@ describe('SharingAccess', () => {
                     uid: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     url: resultOk('url'),
+                    customPassword: resultOk(undefined),
                     node: {
                         name: resultError('node name cannot be decrypted'),
                         type: NodeType.File,

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);
@@ -140,13 +146,14 @@ export class SharingAccess {
 
     async *iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
         for await (const bookmark of this.apiService.iterateBookmarks(signal)) {
-            const { url, nodeName } = await this.cryptoService.decryptBookmark(bookmark);
+            const { url, customPassword, nodeName } = await this.cryptoService.decryptBookmark(bookmark);
 
-            if (!url.ok || !nodeName.ok) {
+            if (!url.ok || !customPassword.ok || !nodeName.ok) {
                 yield resultError({
                     uid: bookmark.tokenId,
                     creationTime: bookmark.creationTime,
                     url: url,
+                    customPassword,
                     node: {
                         name: nodeName,
                         type: bookmark.node.type,
@@ -158,6 +165,7 @@ export class SharingAccess {
                     uid: bookmark.tokenId,
                     creationTime: bookmark.creationTime,
                     url: url.value,
+                    customPassword: customPassword.value,
                     node: {
                         name: nodeName.value,
                         type: bookmark.node.type,

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,

package/src/protonDriveClient.ts

@@ -6,6 +6,7 @@ import {
     MaybeMissingNode,
     NodeResult,
     Revision,
+    RevisionOrUid,
     ShareNodeSettings,
     UnshareNodeSettings,
     ProtonInvitationOrUid,
@@ -311,7 +312,7 @@ export class ProtonDriveClient {
      * @param nodeUid - Node entity or its UID string.
      * @returns The updated node entity.
      * @throws {@link ValidationError} If the name is empty, too long, or contains a slash.
-     * @throws {@link Error} If another node with the same name already exists.
+     * @throws {@link ValidationError} If another node with the same name already exists.
      */
     async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
         this.logger.info(`Renaming node ${getUid(nodeUid)}`);
@@ -342,7 +343,7 @@ export class ProtonDriveClient {
         newParentNodeUid: NodeOrUid,
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResult> {
-        this.logger.info(`Moving ${nodeUids.length} nodes to ${newParentNodeUid}`);
+        this.logger.info(`Moving ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
         yield* this.nodes.management.moveNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
     }
 
@@ -453,9 +454,9 @@ export class ProtonDriveClient {
      *
      * @param revisionUid - UID of the revision to restore.
      */
-    async restoreRevision(revisionUid: string): Promise<void> {
-        this.logger.info(`Restoring revision ${revisionUid}`);
-        await this.nodes.revisions.restoreRevision(revisionUid);
+    async restoreRevision(revisionUid: RevisionOrUid): Promise<void> {
+        this.logger.info(`Restoring revision ${getUid(revisionUid)}`);
+        await this.nodes.revisions.restoreRevision(getUid(revisionUid));
     }
 
     /**
@@ -463,9 +464,9 @@ export class ProtonDriveClient {
      *
      * @param revisionUid - UID of the revision to delete.
      */
-    async deleteRevision(revisionUid: string): Promise<void> {
-        this.logger.info(`Deleting revision ${revisionUid}`);
-        await this.nodes.revisions.deleteRevision(revisionUid);
+    async deleteRevision(revisionUid: RevisionOrUid): Promise<void> {
+        this.logger.info(`Deleting revision ${getUid(revisionUid)}`);
+        await this.nodes.revisions.deleteRevision(getUid(revisionUid));
     }
 
     /**
@@ -527,21 +528,21 @@ export class ProtonDriveClient {
     /**
      * Accept the invitation to the shared node.
      *
-     * @param invitationId - Invitation entity or its UID string.
+     * @param invitationUid - Invitation entity or its UID string.
      */
-    async acceptInvitation(invitationId: string): Promise<void> {
-        this.logger.info(`Accepting invitation ${invitationId}`);
-        await this.sharing.access.acceptInvitation(invitationId);
+    async acceptInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Accepting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.acceptInvitation(getUid(invitationUid));
     }
 
     /**
      * Reject the invitation to the shared node.
      *
-     * @param invitationId - Invitation entity or its UID string.
+     * @param invitationOrUid - Invitation entity or its UID string.
      */
-    async rejectInvitation(invitationId: string): Promise<void> {
-        this.logger.info(`Rejecting invitation ${invitationId}`);
-        await this.sharing.access.rejectInvitation(invitationId);
+    async rejectInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Rejecting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.rejectInvitation(getUid(invitationUid));
     }
 
     /**