@protontech/drive-sdk 0.9.7 → 0.9.9

package/src/internal/photos/albumsCrypto.ts

@@ -0,0 +1,100 @@
+import { DriveCrypto, PrivateKey } from '../../crypto';
+import { DecryptedNodeKeys, NodeSigningKeys } from '../nodes/interface';
+
+/**
+ * Provides crypto operations for albums.
+ *
+ * Albums are special folders in the photos volume. This service reuses
+ * the drive crypto module for key and name encryption operations.
+ */
+export class AlbumsCryptoService {
+    constructor(private driveCrypto: DriveCrypto) {
+        this.driveCrypto = driveCrypto;
+    }
+
+    async createAlbum(
+        parentKeys: { key: PrivateKey; hashKey: Uint8Array },
+        signingKeys: NodeSigningKeys,
+        name: string,
+    ): Promise<{
+        encryptedCrypto: {
+            encryptedName: string;
+            hash: string;
+            armoredKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            signatureEmail: string;
+            armoredHashKey: string;
+        };
+        keys: DecryptedNodeKeys;
+    }> {
+        if (signingKeys.type !== 'userAddress') {
+            throw new Error('Creating album by anonymous user is not supported');
+        }
+        const email = signingKeys.email;
+        const nameAndPassphraseSigningKey = signingKeys.key;
+
+        const [nodeKeys, { armoredNodeName }, hash] = await Promise.all([
+            this.driveCrypto.generateKey([parentKeys.key], nameAndPassphraseSigningKey),
+            this.driveCrypto.encryptNodeName(name, undefined, parentKeys.key, nameAndPassphraseSigningKey),
+            this.driveCrypto.generateLookupHash(name, parentKeys.hashKey),
+        ]);
+
+        const { armoredHashKey, hashKey } = await this.driveCrypto.generateHashKey(nodeKeys.decrypted.key);
+
+        return {
+            encryptedCrypto: {
+                encryptedName: armoredNodeName,
+                hash,
+                armoredKey: nodeKeys.encrypted.armoredKey,
+                armoredNodePassphrase: nodeKeys.encrypted.armoredPassphrase,
+                armoredNodePassphraseSignature: nodeKeys.encrypted.armoredPassphraseSignature,
+                signatureEmail: email,
+                armoredHashKey,
+            },
+            keys: {
+                passphrase: nodeKeys.decrypted.passphrase,
+                key: nodeKeys.decrypted.key,
+                passphraseSessionKey: nodeKeys.decrypted.passphraseSessionKey,
+                hashKey,
+            },
+        };
+    }
+
+    async renameAlbum(
+        parentKeys: { key: PrivateKey; hashKey?: Uint8Array },
+        encryptedName: string,
+        signingKeys: NodeSigningKeys,
+        newName: string,
+    ): Promise<{
+        signatureEmail: string;
+        armoredNodeName: string;
+        hash: string;
+    }> {
+        if (!parentKeys.hashKey) {
+            throw new Error('Cannot rename album: parent folder hash key not available');
+        }
+        if (signingKeys.type !== 'userAddress') {
+            throw new Error('Renaming album by anonymous user is not supported');
+        }
+        const email = signingKeys.email;
+        const nameSigningKey = signingKeys.key;
+
+        const nodeNameSessionKey = await this.driveCrypto.decryptSessionKey(encryptedName, parentKeys.key);
+
+        const { armoredNodeName } = await this.driveCrypto.encryptNodeName(
+            newName,
+            nodeNameSessionKey,
+            parentKeys.key,
+            nameSigningKey,
+        );
+
+        const hash = await this.driveCrypto.generateLookupHash(newName, parentKeys.hashKey);
+
+        return {
+            signatureEmail: email,
+            armoredNodeName,
+            hash,
+        };
+    }
+}

package/src/internal/photos/apiService.ts

@@ -1,6 +1,12 @@
-import { DriveAPIService, drivePaths } from '../apiService';
+import { c } from 'ttag';
+
+import { ValidationError } from '../../errors';
+import { NodeResult } from '../../interface';
+import { APICodeError, DriveAPIService, drivePaths } from '../apiService';
+import { batch } from '../batch';
 import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
-import { makeNodeUid } from '../uids';
+import { makeNodeUid, splitNodeUid } from '../uids';
+import { AlbumItem } from './interface';
 
 type GetPhotoShareResponse =
     drivePaths['/drive/v2/shares/photos']['get']['responses']['200']['content']['application/json'];
@@ -18,6 +24,21 @@ type GetTimelineResponse =
 type GetAlbumsResponse =
     drivePaths['/drive/photos/volumes/{volumeID}/albums']['get']['responses']['200']['content']['application/json'];
 
+type GetAlbumChildrenResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/children']['get']['responses']['200']['content']['application/json'];
+
+type PostCreateAlbumRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/albums']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateAlbumResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/albums']['post']['responses']['200']['content']['application/json'];
+
+type PutUpdateAlbumRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+
 type PostPhotoDuplicateRequest = Extract<
     drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['requestBody'],
     { content: object }
@@ -25,6 +46,15 @@ type PostPhotoDuplicateRequest = Extract<
 type PostPhotoDuplicateResponse =
     drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['responses']['200']['content']['application/json'];
 
+type PostRemovePhotosFromAlbumRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/remove-multiple']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostRemovePhotosFromAlbumResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/remove-multiple']['post']['responses']['200']['content']['application/json'];
+
+const ALBUM_CONTAINS_PHOTOS_NOT_IN_TIMELINE_ERROR_CODE = 200302;
+
 /**
  * Provides API communication for fetching and manipulating photos and albums
  * metadata.
@@ -156,6 +186,31 @@ export class PhotosAPIService {
         }
     }
 
+    async *iterateAlbumChildren(
+        albumNodeUid: string,
+        signal?: AbortSignal,
+    ): AsyncGenerator<AlbumItem> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(albumNodeUid);
+        let anchor = '';
+        while (true) {
+            const response = await this.apiService.get<GetAlbumChildrenResponse>(
+                `drive/photos/volumes/${volumeId}/albums/${linkId}/children?Sort=Captured&Desc=1${anchor ? `&AnchorID=${anchor}` : ''}`,
+                signal,
+            );
+            for (const photo of response.Photos) {
+                yield {
+                    nodeUid: makeNodeUid(volumeId, photo.LinkID),
+                    captureTime: new Date(photo.CaptureTime * 1000),
+                };
+            }
+
+            if (!response.More || !response.AnchorID) {
+                break;
+            }
+            anchor = response.AnchorID;
+        }
+    }
+
     async checkPhotoDuplicates(
         volumeId: string,
         nameHashes: string[],
@@ -188,4 +243,115 @@ export class PhotosAPIService {
             };
         }).filter((duplicate) => duplicate !== undefined);
     }
+
+    async createAlbum(
+        parentNodeUid: string,
+        album: {
+            encryptedName: string;
+            hash: string;
+            armoredKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            signatureEmail: string;
+            armoredHashKey: string;
+        },
+    ): Promise<string> {
+        const { volumeId } = splitNodeUid(parentNodeUid);
+        const response = await this.apiService.post<PostCreateAlbumRequest, PostCreateAlbumResponse>(
+            `drive/photos/volumes/${volumeId}/albums`,
+            {
+                Locked: false,
+                Link: {
+                    Name: album.encryptedName,
+                    Hash: album.hash,
+                    NodeKey: album.armoredKey,
+                    NodePassphrase: album.armoredNodePassphrase,
+                    NodePassphraseSignature: album.armoredNodePassphraseSignature,
+                    SignatureEmail: album.signatureEmail,
+                    NodeHashKey: album.armoredHashKey,
+                    XAttr: null,
+                },
+            },
+        );
+
+        return makeNodeUid(volumeId, response.Album.Link.LinkID);
+    }
+
+    async updateAlbum(
+        albumNodeUid: string,
+        coverPhotoNodeUid?: string,
+        updatedName?: {
+            encryptedName: string;
+            hash: string;
+            originalHash: string;
+            nameSignatureEmail: string;
+        },
+    ): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(albumNodeUid);
+        const coverLinkId = coverPhotoNodeUid ? splitNodeUid(coverPhotoNodeUid).nodeId : undefined;
+        await this.apiService.put<PutUpdateAlbumRequest, void>(
+            `drive/photos/volumes/${volumeId}/albums/${linkId}`,
+            {
+                CoverLinkID: coverLinkId,
+                Link: updatedName
+                    ? {
+                          Name: updatedName.encryptedName,
+                          Hash: updatedName.hash,
+                          OriginalHash: updatedName.originalHash,
+                          NameSignatureEmail: updatedName.nameSignatureEmail,
+                      }
+                    : null,
+            },
+        );
+    }
+
+    async deleteAlbum(albumNodeUid: string, options: { force?: boolean } = {}): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(albumNodeUid);
+        try {
+            await this.apiService.delete(
+                `drive/photos/volumes/${volumeId}/albums/${linkId}?DeleteAlbumPhotos=${options.force ? 1 : 0}`,
+            );
+        } catch (error) {
+            if (error instanceof APICodeError && error.code === ALBUM_CONTAINS_PHOTOS_NOT_IN_TIMELINE_ERROR_CODE) {
+                throw new ValidationError(c('Error').t`Album contains photos not in timeline`);
+            }
+            throw error;
+        }
+    }
+
+    async *removePhotosFromAlbum(
+        albumNodeUid: string,
+        photoNodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResult> {
+        const { volumeId, nodeId: albumLinkId } = splitNodeUid(albumNodeUid);
+
+        const batchSize = 50;
+
+        for (const photoNodeUidsBatch of batch(photoNodeUids, batchSize)) {
+            const linkIds = photoNodeUidsBatch.map((nodeUid) => splitNodeUid(nodeUid).nodeId);
+
+            let errorMessage: string | undefined;
+            try {
+                await this.apiService.post<PostRemovePhotosFromAlbumRequest, PostRemovePhotosFromAlbumResponse>(
+                    `drive/photos/volumes/${volumeId}/albums/${albumLinkId}/remove-multiple`,
+                    {
+                        LinkIDs: linkIds,
+                    },
+                    signal,
+                );
+            } catch (error) {
+                errorMessage = error instanceof Error ? error.message : c('Error').t`Unknown error`;
+            }
+
+            // The API does not return individual results for each photo.
+            for (const uid of photoNodeUidsBatch) {
+                if (errorMessage) {
+                    yield { uid, ok: false, error: errorMessage };
+                } else {
+                    yield { uid, ok: true };
+                }
+            }
+        }
+    }
 }

package/src/internal/photos/index.ts

@@ -1,4 +1,3 @@
-import { DriveAPIService } from '../apiService';
 import { DriveCrypto } from '../../crypto';
 import {
     ProtonDriveAccount,
@@ -6,9 +5,12 @@ import {
     ProtonDriveEntitiesCache,
     ProtonDriveTelemetry,
 } from '../../interface';
+import { DriveAPIService } from '../apiService';
 import { NodesCryptoService } from '../nodes/cryptoService';
 import { NodesCryptoReporter } from '../nodes/cryptoReporter';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { NodesEventsHandler } from '../nodes/events';
+import { NodesRevisons } from '../nodes/nodesRevisions';
 import { ShareTargetType } from '../shares';
 import { SharesCache } from '../shares/cache';
 import { SharesCryptoCache } from '../shares/cryptoCache';
@@ -17,6 +19,7 @@ import { NodesService as UploadNodesService } from '../upload/interface';
 import { UploadTelemetry } from '../upload/telemetry';
 import { UploadQueue } from '../upload/queue';
 import { Albums } from './albums';
+import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { SharesService } from './interface';
 import { PhotosNodesAPIService, PhotosNodesAccess, PhotosNodesCache, PhotosNodesManagement } from './nodes';
@@ -29,10 +32,8 @@ import {
     PhotoUploadManager,
     PhotoUploadMetadata,
 } from './upload';
-import { NodesRevisons } from '../nodes/nodesRevisions';
-import { NodesEventsHandler } from '../nodes/events';
 
-export type { DecryptedPhotoNode } from './interface';
+export type { DecryptedPhotoNode, TimelineItem, AlbumItem, PhotoTag } from './interface';
 
 // Only photos and albums can be shared in photos volume.
 export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
@@ -51,6 +52,7 @@ export function initPhotosModule(
     nodesService: PhotosNodesAccess,
 ) {
     const api = new PhotosAPIService(apiService);
+    const albumsCryptoService = new AlbumsCryptoService(driveCrypto);
     const timeline = new PhotosTimeline(
         telemetry.getLogger('photos-timeline'),
         api,
@@ -58,7 +60,7 @@ export function initPhotosModule(
         photoShares,
         nodesService,
     );
-    const albums = new Albums(api, photoShares, nodesService);
+    const albums = new Albums(api, albumsCryptoService, photoShares, nodesService);
 
     return {
         timeline,

package/src/internal/photos/interface.ts

@@ -42,3 +42,27 @@ export type EcnryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
         contentHash?: string;
     })[];
 };
+
+export type TimelineItem = {
+    nodeUid: string;
+    captureTime: Date;
+    tags: PhotoTag[];
+}
+
+export type AlbumItem = {
+    nodeUid: string;
+    captureTime: Date;
+}
+
+export enum PhotoTag {
+    Favorites = 0,
+    Screenshots = 1,
+    Videos = 2,
+    LivePhotos = 3,
+    MotionPhotos = 4,
+    Selfies = 5,
+    Portraits = 6,
+    Bursts = 7,
+    Panoramas = 8,
+    Raw = 9,
+}

package/src/internal/photos/timeline.ts

@@ -2,6 +2,7 @@ import { DriveCrypto } from '../../crypto';
 import { Logger } from '../../interface';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
+import { TimelineItem } from './interface';
 import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 
@@ -23,11 +24,7 @@ export class PhotosTimeline {
         this.nodesService = nodesService;
     }
 
-    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
-        nodeUid: string;
-        captureTime: Date;
-        tags: number[];
-    }> {
+    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<TimelineItem> {
         const { volumeId } = await this.photoShares.getRootIDs();
         yield* this.apiService.iterateTimeline(volumeId, signal);
     }

package/src/internal/photos/upload.ts

@@ -109,13 +109,14 @@ export class PhotoStreamUploader extends StreamUploader {
     }
 
     async commitFile(thumbnails: Thumbnail[]) {
-        this.verifyIntegrity(thumbnails);
+        const digests = this.digests.digests();
+        this.verifyIntegrity(thumbnails, digests);
 
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
             size: this.metadata.expectedSize,
             blockSizes: this.uploadedBlockSizes,
-            digests: this.digests.digests(),
+            digests,
         };
 
         await this.photoUploadManager.commitDraftPhoto(this.revisionDraft, this.manifest, extendedAttributes, this.photoMetadata);

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

@@ -564,6 +564,44 @@ describe('StreamUploader', () => {
 
                 await verifyFailure('Some file bytes failed to upload', 10 * 1024 * 1024 + 1024);
             });
+
+            it('should succeed with matching expectedSha1', async () => {
+                metadata.expectedSha1 = '8c206a1a87599f532ce68675536f0b1546900d7a';
+
+                uploader = new StreamUploader(
+                    telemetry,
+                    apiService,
+                    cryptoService,
+                    uploadManager,
+                    blockVerifier,
+                    revisionDraft,
+                    metadata,
+                    onFinish,
+                    controller,
+                    abortController,
+                );
+
+                await verifySuccess();
+            });
+
+            it('should throw an error if SHA1 does not match', async () => {
+                metadata.expectedSha1 = 'wrong_sha1_hash_that_will_not_match';
+
+                uploader = new StreamUploader(
+                    telemetry,
+                    apiService,
+                    cryptoService,
+                    uploadManager,
+                    blockVerifier,
+                    revisionDraft,
+                    metadata,
+                    onFinish,
+                    controller,
+                    abortController,
+                );
+
+                await verifyFailure('File hash does not match expected hash', 10 * 1024 * 1024 + 1024);
+            });
         });
     });
 

package/src/internal/upload/streamUploader.ts

@@ -219,13 +219,14 @@ export class StreamUploader {
     }
 
     protected async commitFile(thumbnails: Thumbnail[]) {
-        this.verifyIntegrity(thumbnails);
+        const digests = this.digests.digests();
+        this.verifyIntegrity(thumbnails, digests);
 
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
             size: this.metadata.expectedSize,
             blockSizes: this.uploadedBlockSizes,
-            digests: this.digests.digests(),
+            digests,
         };
         await this.uploadManager.commitDraft(
             this.revisionDraft,
@@ -607,7 +608,7 @@ export class StreamUploader {
         }
     }
 
-    protected verifyIntegrity(thumbnails: Thumbnail[]) {
+    protected verifyIntegrity(thumbnails: Thumbnail[], digests: { sha1: string }) {
         const expectedBlockCount =
             Math.ceil(this.metadata.expectedSize / FILE_CHUNK_SIZE) + (thumbnails ? thumbnails?.length : 0);
         if (this.uploadedBlockCount !== expectedBlockCount) {
@@ -622,6 +623,12 @@ export class StreamUploader {
                 expectedFileSize: this.metadata.expectedSize,
             });
         }
+        if (this.metadata.expectedSha1 && digests.sha1 !== this.metadata.expectedSha1) {
+            throw new IntegrityError(c('Error').t`File hash does not match expected hash`, {
+                uploadedSha1: digests.sha1,
+                expectedSha1: this.metadata.expectedSha1,
+            });
+        }
     }
 
     /**

package/src/protonDrivePhotosClient.ts

@@ -38,6 +38,9 @@ import {
     initPhotoSharesModule,
     initPhotoUploadModule,
     initPhotosNodesModule,
+    AlbumItem,
+    TimelineItem,
+    PhotoTag,
 } from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
@@ -117,7 +120,13 @@ export class ProtonDrivePhotosClient {
             this.photoShares,
             fullConfig.clientUid,
         );
-        this.photos = initPhotosModule(telemetry, apiService, cryptoModule, this.photoShares, this.nodes.access);
+        this.photos = initPhotosModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            this.photoShares,
+            this.nodes.access,
+        );
         this.sharing = initSharingModule(
             telemetry,
             apiService,
@@ -218,12 +227,7 @@ export class ProtonDrivePhotosClient {
      * The output is sorted by the capture time, starting from the
      * the most recent photos.
      */
-    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
-        nodeUid: string;
-        captureTime: Date;
-        tags: number[];
-    }> {
-        // TODO: expose better type
+    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<TimelineItem> {
         yield* this.photos.timeline.iterateTimeline(signal);
     }
 
@@ -450,8 +454,7 @@ export class ProtonDrivePhotosClient {
         metadata: UploadMetadata & {
             captureTime?: Date;
             mainPhotoLinkID?: string;
-            // TODO: handle tags enum in the SDK
-            tags?: (0 | 3 | 1 | 2 | 7 | 4 | 5 | 6 | 8 | 9)[];
+            tags?: PhotoTag[];
         },
         signal?: AbortSignal,
     ): Promise<FileUploader> {
@@ -507,6 +510,63 @@ export class ProtonDrivePhotosClient {
         return this.photos.timeline.findPhotoDuplicates(name, generateSha1, signal);
     }
 
+    /**
+     * Creates a new album with the given name.
+     *
+     * @param name - The name for the new album.
+     * @returns The created album node.
+     */
+    async createAlbum(name: string): Promise<MaybePhotoNode> {
+        this.logger.info('Creating album');
+        return convertInternalPhotoNodePromise(this.photos.albums.createAlbum(name));
+    }
+
+    /**
+     * Updates an existing album.
+     *
+     * Updates can include a new name and/or a cover photo.
+     *
+     * @param nodeUid - The UID of the album to edit.
+     * @param updates - The updates to apply.
+     * @returns The updated album node.
+     */
+    async updateAlbum(
+        nodeUid: NodeOrUid,
+        updates: {
+            name?: string;
+            coverPhotoNodeUid?: NodeOrUid;
+        },
+    ): Promise<MaybePhotoNode> {
+        this.logger.info(`Updating album ${getUid(nodeUid)}`);
+        const coverPhotoNodeUid = updates.coverPhotoNodeUid ? getUid(updates.coverPhotoNodeUid) : undefined;
+        return convertInternalPhotoNodePromise(
+            this.photos.albums.updateAlbum(getUid(nodeUid), {
+                name: updates.name,
+                coverPhotoNodeUid,
+            }),
+        );
+    }
+
+    /**
+     * Deletes an album.
+     *
+     * Photos in the timeline will not be deleted. If the album has photos
+     * that are not in the timeline (uploaded by another user), the method
+     * will throw an error. The photos must be moved to the timeline, or
+     * the album must be deleted with `force` option that deletes the photos
+     * not in the timeline as well.
+     *
+     * This operation is irreversible. Both the album and the photos will be
+     * permanently deleted, skipping the trash.
+     *
+     * @param nodeUid - The UID of the album to delete.
+     * @param force - Whether to force the deletion.
+     */
+    async deleteAlbum(nodeUid: NodeOrUid, options: { force?: boolean } = {}): Promise<void> {
+        this.logger.info(`Deleting album ${getUid(nodeUid)}`);
+        await this.photos.albums.deleteAlbum(getUid(nodeUid), options);
+    }
+
     /**
      * Iterates the albums.
      *
@@ -517,4 +577,39 @@ export class ProtonDrivePhotosClient {
         // TODO: expose album type
         yield * convertInternalPhotoNodeIterator(this.photos.albums.iterateAlbums(signal));
     }
+
+    /**
+     * Iterates the photo placeholders of the given album.
+     *
+     * The output is sorted by the capture time, starting from the
+     * the most recent photos.
+     *
+     * @param albumNodeUid - The UID of the album.
+     * @param signal - An optional abort the operation.
+     */
+    async *iterateAlbum(albumNodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<AlbumItem> {
+        this.logger.info(`Iterating photos of album ${getUid(albumNodeUid)}`);
+        yield* this.photos.albums.iterateAlbum(getUid(albumNodeUid), signal);
+    }
+
+    /**
+     * Removes photos from an album.
+     *
+     * Photos are not deleted, they are just removed from the album.
+     * If a photo was added to the timeline by the user, it will remain
+     * in the timeline after being removed from the album.
+     *
+     * @param albumNodeUid - The UID of the album to remove photos from.
+     * @param photoNodeUids - The UIDs of the photos to remove from the album.
+     * @param signal - An optional abort signal to cancel the operation.
+     * @returns An async generator of the removed photo results.
+     */
+    async *removePhotosFromAlbum(
+        albumNodeUid: NodeOrUid,
+        photoNodeUids: NodeOrUid[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResult> {
+        this.logger.info(`Removing ${photoNodeUids.length} photos from album ${getUid(albumNodeUid)}`);
+        yield* this.photos.albums.removePhotos(getUid(albumNodeUid), getUids(photoNodeUids), signal);
+    }
 }