@protontech/drive-sdk 0.5.1 → 0.6.0

package/src/internal/sharing/apiService.ts

@@ -7,6 +7,7 @@ import {
     permissionsToMemberRole,
     memberRoleToPermission,
 } from '../apiService';
+import { ShareTargetType } from '../shares';
 import {
     makeNodeUid,
     splitNodeUid,
@@ -119,14 +120,6 @@ type PutShareUrlRequest = Extract<
 type PutShareUrlResponse =
     drivePaths['/drive/shares/{shareID}/urls/{urlID}']['put']['responses']['200']['content']['application/json'];
 
-// We do not support photos and albums yet.
-const SUPPORTED_SHARE_TARGET_TYPES = [
-    0, // Root
-    1, // Folder
-    2, // File
-    5, // Proton vendor (documents and sheets)
-];
-
 /**
  * Provides API communication for fetching and managing sharing.
  *
@@ -137,9 +130,11 @@ export class SharingAPIService {
     constructor(
         private logger: Logger,
         private apiService: DriveAPIService,
+        private shareTargetTypes: ShareTargetType[],
     ) {
         this.logger = logger;
         this.apiService = apiService;
+        this.shareTargetTypes = shareTargetTypes;
     }
 
     async *iterateSharedNodeUids(volumeId: string, signal?: AbortSignal): AsyncGenerator<string> {
@@ -163,6 +158,7 @@ export class SharingAPIService {
     async *iterateSharedWithMeNodeUids(signal?: AbortSignal): AsyncGenerator<string> {
         let anchor = '';
         while (true) {
+            // TODO: Use ShareTargetTypes filter when it is supported by the API.
             const response = await this.apiService.get<GetSharedWithMeNodesResponse>(
                 `drive/v2/sharedwithme?${anchor ? `AnchorID=${anchor}` : ''}`,
                 signal,
@@ -170,8 +166,8 @@ export class SharingAPIService {
             for (const link of response.Links) {
                 const nodeUid = makeNodeUid(link.VolumeID, link.LinkID);
 
-                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(link.ShareTargetType)) {
-                    this.logger.warn(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
+                if (!this.shareTargetTypes.includes(link.ShareTargetType)) {
+                    this.logger.debug(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
                     continue;
                 }
 
@@ -188,14 +184,21 @@ export class SharingAPIService {
     async *iterateInvitationUids(signal?: AbortSignal): AsyncGenerator<string> {
         let anchor = '';
         while (true) {
+            const params = new URLSearchParams();
+            this.shareTargetTypes.forEach((type) => {
+                params.append('ShareTargetTypes[]', type.toString());
+            });
+            if (anchor) {
+                params.append('AnchorID', anchor);
+            }
             const response = await this.apiService.get<GetInvitationsResponse>(
-                `drive/v2/shares/invitations?${anchor ? `AnchorID=${anchor}` : ''}`,
+                `drive/v2/shares/invitations?${params.toString()}`,
                 signal,
             );
             for (const invitation of response.Invitations) {
                 const invitationUid = makeInvitationUid(invitation.ShareID, invitation.InvitationID);
 
-                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(invitation.ShareTargetType)) {
+                if (!this.shareTargetTypes.includes(invitation.ShareTargetType)) {
                     this.logger.warn(
                         `Unsupported share target type ${invitation.ShareTargetType} for invitation ${invitationUid}`,
                     );

package/src/internal/sharing/index.ts

@@ -1,6 +1,7 @@
 import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from '../../interface';
 import { DriveCrypto } from '../../crypto';
 import { DriveAPIService } from '../apiService';
+import { ShareTargetType } from '../shares';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
@@ -9,6 +10,10 @@ import { SharingManagement } from './sharingManagement';
 import { SharesService, NodesService } from './interface';
 import { SharingEventHandler } from './events';
 
+// Root shares are not allowed to be shared.
+// Photos and Albums are not supported in main volume (core Drive).
+const DEFAULT_SHARE_TARGET_TYPES = [ShareTargetType.Folder, ShareTargetType.File, ShareTargetType.ProtonVendor];
+
 /**
  * Provides facade for the whole sharing module.
  *
@@ -24,8 +29,9 @@ export function initSharingModule(
     crypto: DriveCrypto,
     sharesService: SharesService,
     nodesService: NodesService,
+    shareTargetTypes: ShareTargetType[] = DEFAULT_SHARE_TARGET_TYPES,
 ) {
-    const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService);
+    const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService, shareTargetTypes);
     const cache = new SharingCache(driveEntitiesCache);
     const cryptoService = new SharingCryptoService(telemetry, crypto, account, sharesService);
     const sharingAccess = new SharingAccess(api, cache, cryptoService, sharesService, nodesService);

package/src/internal/sharingPublic/index.ts

@@ -78,7 +78,8 @@ export function initSharingPublicNodesModule(
     publicShareKey: PrivateKey,
     publicRootNodeUid: string,
 ) {
-    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    const clientUid = undefined; // No client UID for public context yet.
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService, clientUid);
     const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
     const cryptoReporter = new SharingPublicCryptoReporter(telemetry);

package/src/internal/upload/apiService.ts

@@ -6,13 +6,6 @@ import { splitNodeUid, makeNodeUid, splitNodeRevisionUid, makeNodeRevisionUid }
 import { UploadTokens } from './interface';
 import { ThumbnailType } from '../../interface';
 
-type PostCheckAvailableHashesRequest = Extract<
-    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['requestBody'],
-    { content: object }
->['content']['application/json'];
-type PostCheckAvailableHashesResponse =
-    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['responses']['200']['content']['application/json'];
-
 type PostCreateDraftRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['requestBody'],
     { content: object }
@@ -60,38 +53,6 @@ export class UploadAPIService {
         this.clientUid = clientUid;
     }
 
-    async checkAvailableHashes(
-        parentNodeUid: string,
-        hashes: string[],
-    ): Promise<{
-        availalbleHashes: string[];
-        pendingHashes: {
-            hash: string;
-            nodeUid: string;
-            revisionUid: string;
-            clientUid?: string;
-        }[];
-    }> {
-        const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
-        const result = await this.apiService.post<PostCheckAvailableHashesRequest, PostCheckAvailableHashesResponse>(
-            `drive/v2/volumes/${volumeId}/links/${parentNodeId}/checkAvailableHashes`,
-            {
-                Hashes: hashes,
-                ClientUID: this.clientUid ? [this.clientUid] : null,
-            },
-        );
-
-        return {
-            availalbleHashes: result.AvailableHashes,
-            pendingHashes: result.PendingHashes.map((hash) => ({
-                hash: hash.Hash,
-                nodeUid: makeNodeUid(volumeId, hash.LinkID),
-                revisionUid: makeNodeRevisionUid(volumeId, hash.LinkID, hash.RevisionID),
-                clientUid: hash.ClientUID || undefined,
-            })),
-        };
-    }
-
     async createDraft(
         parentNodeUid: string,
         node: {

package/src/internal/upload/cryptoService.ts

@@ -40,15 +40,6 @@ export class UploadCryptoService {
         };
     }
 
-    async generateNameHashes(parentHashKey: Uint8Array, names: string[]): Promise<{ name: string; hash: string }[]> {
-        return Promise.all(
-            names.map(async (name) => ({
-                name,
-                hash: await this.driveCrypto.generateLookupHash(name, parentHashKey),
-            })),
-        );
-    }
-
     async encryptThumbnail(
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
         thumbnail: Thumbnail,

package/src/internal/upload/fileUploader.ts

@@ -176,11 +176,6 @@ export class FileUploader extends Uploader {
             blockVerifier,
         };
     }
-
-    async getAvailableName(): Promise<string> {
-        const availableName = await this.manager.findAvailableName(this.parentFolderUid, this.name);
-        return availableName;
-    }
 }
 
 /**

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

@@ -26,10 +26,6 @@ describe('UploadManager', () => {
                 nodeRevisionUid: 'newNode:nodeRevisionUid',
             }),
             deleteDraft: jest.fn(),
-            checkAvailableHashes: jest.fn().mockResolvedValue({
-                availalbleHashes: ['name1Hash'],
-                pendingHashes: [],
-            }),
             commitDraftRevision: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
@@ -58,20 +54,6 @@ describe('UploadManager', () => {
                     email: 'signatureEmail',
                 },
             }),
-            generateNameHashes: jest.fn().mockResolvedValue([
-                {
-                    name: 'name1',
-                    hash: 'name1Hash',
-                },
-                {
-                    name: 'name2',
-                    hash: 'name2Hash',
-                },
-                {
-                    name: 'name3',
-                    hash: 'name3Hash',
-                },
-            ]),
             commitFile: jest.fn().mockResolvedValue({
                 armoredManifestSignature: 'newNode:armoredManifestSignature',
                 signatureEmail: 'signatureEmail',
@@ -280,53 +262,6 @@ describe('UploadManager', () => {
         });
     });
 
-    describe('findAvailableName', () => {
-        it('should find available name', async () => {
-            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                return {
-                    availalbleHashes: ['name3Hash'],
-                    pendingHashes: [],
-                };
-            });
-
-            const result = await manager.findAvailableName('parentUid', 'name');
-            expect(result).toBe('name3');
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
-                'name1Hash',
-                'name2Hash',
-                'name3Hash',
-            ]);
-        });
-
-        it('should find available name with multiple pages', async () => {
-            let firstCall = false;
-            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                if (!firstCall) {
-                    firstCall = true;
-                    return {
-                        // First page has no available hashes
-                        availalbleHashes: [],
-                        pendingHashes: [],
-                    };
-                }
-                return {
-                    availalbleHashes: ['name3Hash'],
-                    pendingHashes: [],
-                };
-            });
-
-            const result = await manager.findAvailableName('parentUid', 'name');
-            expect(result).toBe('name3');
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(2);
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
-                'name1Hash',
-                'name2Hash',
-                'name3Hash',
-            ]);
-        });
-    });
-
     describe('commit draft', () => {
         const nodeRevisionDraft = {
             nodeUid: 'newNode:nodeUid',

package/src/internal/upload/manager.ts

@@ -173,43 +173,6 @@ export class UploadManager {
         }
     }
 
-    async findAvailableName(parentFolderUid: string, name: string): Promise<string> {
-        const { hashKey: parentHashKey } = await this.nodesService.getNodeKeys(parentFolderUid);
-        if (!parentHashKey) {
-            throw new ValidationError(c('Error').t`Creating files in non-folders is not allowed`);
-        }
-
-        const [namePart, extension] = splitExtension(name);
-
-        const batchSize = 10;
-        let startIndex = 1;
-        while (true) {
-            const namesToCheck = [];
-            for (let i = startIndex; i < startIndex + batchSize; i++) {
-                namesToCheck.push(joinNameAndExtension(namePart, i, extension));
-            }
-
-            const hashesToCheck = await this.cryptoService.generateNameHashes(parentHashKey, namesToCheck);
-
-            const { availalbleHashes } = await this.apiService.checkAvailableHashes(
-                parentFolderUid,
-                hashesToCheck.map(({ hash }) => hash),
-            );
-
-            if (!availalbleHashes.length) {
-                startIndex += batchSize;
-                continue;
-            }
-
-            const availableHash = hashesToCheck.find(({ hash }) => hash === availalbleHashes[0]);
-            if (!availableHash) {
-                throw Error('Backend returned unexpected hash');
-            }
-
-            return availableHash.name;
-        }
-    }
-
     async deleteDraftNode(nodeUid: string): Promise<void> {
         try {
             await this.apiService.deleteDraft(nodeUid);
@@ -294,30 +257,3 @@ export class UploadManager {
         }
     }
 }
-
-/**
- * Split a filename into `[name, extension]`
- */
-function splitExtension(filename = ''): [string, string] {
-    const endIdx = filename.lastIndexOf('.');
-    if (endIdx === -1 || endIdx === filename.length - 1) {
-        return [filename, ''];
-    }
-    return [filename.slice(0, endIdx), filename.slice(endIdx + 1)];
-}
-
-/**
- * Join a filename into `name (index).extension`
- */
-function joinNameAndExtension(name: string, index: number, extension: string): string {
-    if (!name && !extension) {
-        return `(${index})`;
-    }
-    if (!name) {
-        return `(${index}).${extension}`;
-    }
-    if (!extension) {
-        return `${name} (${index})`;
-    }
-    return `${name} (${index}).${extension}`;
-}

package/src/protonDriveClient.ts

@@ -24,7 +24,6 @@ import {
     UploadMetadata,
     FileDownloader,
     FileUploader,
-    FileRevisionUploader,
     ThumbnailType,
     ThumbnailResult,
     SDKEvent,
@@ -144,6 +143,7 @@ export class ProtonDriveClient {
             account,
             cryptoModule,
             this.shares,
+            fullConfig.clientUid,
         );
         this.sharing = initSharingModule(
             telemetry,
@@ -703,6 +703,12 @@ export class ProtonDriveClient {
         return this.sharing.management.unshareNode(getUid(nodeUid), settings);
     }
 
+    /**
+     * Resend the invitation email to shared node.
+     *
+     * @param nodeUid - Node entity or its UID string.
+     * @param invitationUid - Invitation entity or its UID string.
+     */
     async resendInvitation(
         nodeUid: NodeOrUid,
         invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid,
@@ -829,11 +835,24 @@ export class ProtonDriveClient {
         nodeUid: NodeOrUid,
         metadata: UploadMetadata,
         signal?: AbortSignal,
-    ): Promise<FileRevisionUploader> {
+    ): Promise<FileUploader> {
         this.logger.info(`Getting file revision uploader for ${getUid(nodeUid)}`);
         return this.upload.getFileRevisionUploader(getUid(nodeUid), metadata, signal);
     }
 
+    /**
+     * Returns the available name for the file in the given parent folder.
+     *
+     * The function will return a name that includes the original name with the
+     * available index. The name is guaranteed to be unique in the parent folder.
+     *
+     * Example new name: `file (2).txt`.
+     */
+    async getAvailableName(parentFolderUid: NodeOrUid, name: string): Promise<string> {
+        this.logger.info(`Getting available name in folder ${getUid(parentFolderUid)}`);
+        return this.nodes.management.findAvailableName(getUid(parentFolderUid), name);
+    }
+
     /**
      * Iterates the devices of the user.
      *

package/src/protonDrivePhotosClient.ts

@@ -10,12 +10,20 @@ import {
     MaybeNode,
     ThumbnailType,
     ThumbnailResult,
+    ShareNodeSettings,
+    ShareResult,
+    UnshareNodeSettings,
+    ProtonInvitationOrUid,
+    NonProtonInvitationOrUid,
+    ProtonInvitationWithNode,
+    NodeResult,
 } from './interface';
 import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { Telemetry } from './telemetry';
 import {
     convertInternalMissingNodeIterator,
+    convertInternalNode,
     convertInternalNodeIterator,
     convertInternalNodePromise,
     getUid,
@@ -25,7 +33,12 @@ import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import { initNodesModule } from './internal/nodes';
-import { initPhotosModule, initPhotoSharesModule, initPhotoUploadModule } from './internal/photos';
+import {
+    PHOTOS_SHARE_TARGET_TYPES,
+    initPhotosModule,
+    initPhotoSharesModule,
+    initPhotoUploadModule,
+} from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
 import { initSharingModule } from './internal/sharing';
@@ -72,7 +85,7 @@ export class ProtonDrivePhotosClient {
         if (!telemetry) {
             telemetry = new Telemetry();
         }
-        this.logger = telemetry.getLogger('interface');
+        this.logger = telemetry.getLogger('photos-interface');
 
         const fullConfig = getConfig(config);
         this.sdkEvents = new SDKEvents(telemetry);
@@ -102,6 +115,7 @@ export class ProtonDrivePhotosClient {
             account,
             cryptoModule,
             this.photoShares,
+            fullConfig.clientUid,
         );
         this.photos = initPhotosModule(apiService, this.photoShares, this.nodes.access);
         this.sharing = initSharingModule(
@@ -112,6 +126,7 @@ export class ProtonDrivePhotosClient {
             cryptoModule,
             this.photoShares,
             this.nodes.access,
+            PHOTOS_SHARE_TARGET_TYPES,
         );
         this.download = initDownloadModule(
             telemetry,
@@ -204,6 +219,16 @@ export class ProtonDrivePhotosClient {
         yield* this.photos.timeline.iterateTimeline(signal);
     }
 
+    /**
+     * Iterates the trashed nodes.
+     *
+     * See `ProtonDriveClient.iterateTrashedNodes` for more information.
+     */
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating trashed nodes');
+        yield* convertInternalNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
+    }
+
     /**
      * Iterates the nodes by their UIDs.
      *
@@ -226,14 +251,163 @@ export class ProtonDrivePhotosClient {
     }
 
     /**
-     * Iterates the albums.
+     * Rename the node.
      *
-     * The output is not sorted and the order of the nodes is not guaranteed.
+     * See `ProtonDriveClient.renameNode` for more information.
      */
-    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
-        this.logger.info('Iterating albums');
-        // TODO: expose album type
-        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
+        this.logger.info(`Renaming node ${getUid(nodeUid)}`);
+        return convertInternalNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
+    }
+
+    /**
+     * Trash the nodes.
+     *
+     * See `ProtonDriveClient.trashNodes` for more information.
+     */
+    async *trashNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Trashing ${nodeUids.length} nodes`);
+        yield* this.nodes.management.trashNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Restore the nodes from the trash to their original place.
+     *
+     * See `ProtonDriveClient.restoreNodes` for more information.
+     */
+    async *restoreNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Restoring ${nodeUids.length} nodes`);
+        yield* this.nodes.management.restoreNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Delete the nodes permanently.
+     *
+     * See `ProtonDriveClient.deleteNodes` for more information.
+     */
+    async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Deleting ${nodeUids.length} nodes`);
+        yield* this.nodes.management.deleteNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Empty the trash.
+     *
+     * See `ProtonDriveClient.emptyTrash` for more information.
+     */
+    async emptyTrash(): Promise<void> {
+        this.logger.info('Emptying trash');
+        throw new Error('Method not implemented');
+    }
+
+    /**
+     * Iterates the nodes shared by the user.
+     *
+     * See `ProtonDriveClient.iterateSharedNodes` for more information.
+     */
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating shared nodes by me');
+        yield* convertInternalNodeIterator(this.sharing.access.iterateSharedNodes(signal));
+    }
+
+    /**
+     * Iterates the nodes shared with the user.
+     *
+     * See `ProtonDriveClient.iterateSharedNodesWithMe` for more information.
+     */
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating shared nodes with me');
+
+        for await (const node of this.sharing.access.iterateSharedNodesWithMe(signal)) {
+            yield convertInternalNode(node);
+        }
+    }
+
+    /**
+     * Leave shared node that was previously shared with the user.
+     *
+     * See `ProtonDriveClient.leaveSharedNode` for more information.
+     */
+    async leaveSharedNode(nodeUid: NodeOrUid): Promise<void> {
+        this.logger.info(`Leaving shared node with me ${getUid(nodeUid)}`);
+        await this.sharing.access.removeSharedNodeWithMe(getUid(nodeUid));
+    }
+
+    /**
+     * Iterates the invitations to shared nodes.
+     *
+     * See `ProtonDriveClient.iterateInvitations` for more information.
+     */
+    async *iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
+        this.logger.info('Iterating invitations');
+        yield* this.sharing.access.iterateInvitations(signal);
+    }
+
+    /**
+     * Accept the invitation to the shared node.
+     *
+     * See `ProtonDriveClient.acceptInvitation` for more information.
+     */
+    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.
+     *
+     * See `ProtonDriveClient.rejectInvitation` for more information.
+     */
+    async rejectInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Rejecting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.rejectInvitation(getUid(invitationUid));
+    }
+
+    /**
+     * Get sharing info of the node.
+     *
+     * See `ProtonDriveClient.getSharingInfo` for more information.
+     */
+    async getSharingInfo(nodeUid: NodeOrUid): Promise<ShareResult | undefined> {
+        this.logger.info(`Getting sharing info for ${getUid(nodeUid)}`);
+        return this.sharing.management.getSharingInfo(getUid(nodeUid));
+    }
+
+    /**
+     * Share or update sharing of the node.
+     *
+     * See `ProtonDriveClient.shareNode` for more information.
+     */
+    async shareNode(nodeUid: NodeOrUid, settings: ShareNodeSettings): Promise<ShareResult> {
+        this.logger.info(`Sharing node ${getUid(nodeUid)}`);
+        return this.sharing.management.shareNode(getUid(nodeUid), settings);
+    }
+
+    /**
+     * Unshare the node, completely or partially.
+     *
+     * See `ProtonDriveClient.unshareNode` for more information.
+     */
+    async unshareNode(nodeUid: NodeOrUid, settings?: UnshareNodeSettings): Promise<ShareResult | undefined> {
+        if (!settings) {
+            this.logger.info(`Unsharing node ${getUid(nodeUid)}`);
+        } else {
+            this.logger.info(`Partially unsharing ${getUid(nodeUid)}`);
+        }
+        return this.sharing.management.unshareNode(getUid(nodeUid), settings);
+    }
+
+    /**
+     * Resend the invitation email to shared node.
+     *
+     * See `ProtonDriveClient.resendInvitation` for more information.
+     */
+    async resendInvitation(
+        nodeUid: NodeOrUid,
+        invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid,
+    ): Promise<void> {
+        this.logger.info(`Resending invitation ${getUid(invitationUid)}`);
+        return this.sharing.management.resendInvitationEmail(getUid(nodeUid), getUid(invitationUid));
     }
 
     /**
@@ -279,4 +453,15 @@ export class ProtonDrivePhotosClient {
         const parentFolderUid = await this.nodes.access.getVolumeRootFolder();
         return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
     }
+
+    /**
+     * Iterates the albums.
+     *
+     * The output is not sorted and the order of the nodes is not guaranteed.
+     */
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating albums');
+        // TODO: expose album type
+        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    }
 }