@protontech/drive-sdk 0.10.0 → 0.12.0

package/src/internal/photos/apiService.ts

@@ -1,13 +1,14 @@
 import { c } from 'ttag';
 
 import { ValidationError } from '../../errors';
-import { NodeResultWithError } from '../../interface';
+import { NodeResultWithError, PhotoTag } from '../../interface';
 import { APICodeError, DriveAPIService, drivePaths, InvalidRequirementsAPIError, isCodeOk } from '../apiService';
 import { batch } from '../batch';
 import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
 import { makeNodeUid, splitNodeUid } from '../uids';
 import { MissingRelatedPhotosError } from './errors';
-import { AddToAlbumEncryptedPhotoPayload, AlbumItem } from './interface';
+import { AlbumItem } from './interface';
+import { TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 
 type GetPhotoShareResponse =
     drivePaths['/drive/v2/shares/photos']['get']['responses']['200']['content']['application/json'];
@@ -68,6 +69,19 @@ type PostRemovePhotosFromAlbumRequest = Extract<
 type PostRemovePhotosFromAlbumResponse =
     drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/remove-multiple']['post']['responses']['200']['content']['application/json'];
 
+type PostAddPhotoTagsRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/{linkID}/tags']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostRemovePhotoTagsRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/{linkID}/tags']['delete']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostFavoritePhotoRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/{linkID}/favorite']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+
 const ALBUM_CONTAINS_PHOTOS_NOT_IN_TIMELINE_ERROR_CODE = 200302;
 
 /**
@@ -337,15 +351,12 @@ export class PhotosAPIService {
      */
     async *addPhotosToAlbum(
         albumNodeUid: string,
-        photoPayloads: AddToAlbumEncryptedPhotoPayload[],
+        photoPayloads: TransferEncryptedPhotoPayload[],
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResultWithError> {
         const { volumeId, nodeId: albumLinkId } = splitNodeUid(albumNodeUid);
 
-        const allPhotoPayloads = photoPayloads.flatMap((photoPayload) => [
-            photoPayload,
-            ...(photoPayload.relatedPhotos || []),
-        ]);
+        const allPhotoPayloads = photoPayloads.flatMap((photoPayload) => [photoPayload, ...photoPayload.relatedPhotos]);
         const allPhotoData = allPhotoPayloads.map((photoPayload) => {
             const { nodeId } = splitNodeUid(photoPayload.nodeUid);
             return {
@@ -416,7 +427,7 @@ export class PhotosAPIService {
      */
     async copyPhotoToAlbum(
         albumNodeUid: string,
-        payload: AddToAlbumEncryptedPhotoPayload,
+        payload: TransferEncryptedPhotoPayload,
         signal?: AbortSignal,
     ): Promise<string> {
         const { volumeId: sourceVolumeId, nodeId: sourceLinkId } = splitNodeUid(payload.nodeUid);
@@ -438,14 +449,13 @@ export class PhotosAPIService {
                     SignatureEmail: payload.signatureEmail,
                     Photos: {
                         ContentHash: payload.contentHash,
-                        RelatedPhotos:
-                            payload.relatedPhotos?.map((related) => ({
-                                LinkID: splitNodeUid(related.nodeUid).nodeId,
-                                Hash: related.nameHash,
-                                Name: related.encryptedName,
-                                NodePassphrase: related.nodePassphrase,
-                                ContentHash: related.contentHash,
-                            })) || [],
+                        RelatedPhotos: payload.relatedPhotos.map((related) => ({
+                            LinkID: splitNodeUid(related.nodeUid).nodeId,
+                            Hash: related.nameHash,
+                            Name: related.encryptedName,
+                            NodePassphrase: related.nodePassphrase,
+                            ContentHash: related.contentHash,
+                        })),
                     },
                 },
                 signal,
@@ -499,4 +509,51 @@ export class PhotosAPIService {
             }
         }
     }
+
+    async addPhotoTags(nodeUid: string, tags: PhotoTag[]): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(nodeUid);
+        await this.apiService.post<PostAddPhotoTagsRequest, { Code: number }>(
+            `drive/photos/volumes/${volumeId}/links/${linkId}/tags`,
+            { Tags: tags },
+        );
+    }
+
+    async removePhotoTags(nodeUid: string, tags: PhotoTag[]): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(nodeUid);
+        await this.apiService.delete<PostRemovePhotoTagsRequest, { Code: number }>(
+            `drive/photos/volumes/${volumeId}/links/${linkId}/tags`,
+            { Tags: tags },
+        );
+    }
+
+    async setPhotoFavorite(nodeUid: string, payload?: TransferEncryptedPhotoPayload): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(nodeUid);
+        const requestBody = payload
+            ? {
+                  PhotoData: {
+                      Hash: payload.nameHash,
+                      Name: payload.encryptedName,
+                      NameSignatureEmail: payload.nameSignatureEmail,
+                      NodePassphrase: payload.nodePassphrase,
+                      ContentHash: payload.contentHash,
+                      NodePassphraseSignature: payload.nodePassphraseSignature ?? null,
+                      SignatureEmail: payload.signatureEmail ?? null,
+                      RelatedPhotos: payload.relatedPhotos.map((related) => ({
+                          LinkID: splitNodeUid(related.nodeUid).nodeId,
+                          Hash: related.nameHash,
+                          Name: related.encryptedName,
+                          NameSignatureEmail: related.nameSignatureEmail,
+                          NodePassphrase: related.nodePassphrase,
+                          ContentHash: related.contentHash,
+                          NodePassphraseSignature: related.nodePassphraseSignature ?? null,
+                          SignatureEmail: related.signatureEmail ?? null,
+                      })),
+                  },
+              }
+            : undefined;
+        await this.apiService.post<PostFavoritePhotoRequest, { Code: number }>(
+            `drive/photos/volumes/${volumeId}/links/${linkId}/favorite`,
+            requestBody,
+        );
+    }
 }

package/src/internal/photos/index.ts

@@ -1,5 +1,6 @@
 import { DriveCrypto } from '../../crypto';
 import {
+    FeatureFlagProvider,
     ProtonDriveAccount,
     ProtonDriveCryptoCache,
     ProtonDriveEntitiesCache,
@@ -18,13 +19,14 @@ import { SharesCryptoService } from '../shares/cryptoService';
 import { NodesService as UploadNodesService } from '../upload/interface';
 import { UploadTelemetry } from '../upload/telemetry';
 import { UploadQueue } from '../upload/queue';
-import { Albums } from './albums';
+import { AlbumsManager } from './albumsManager';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { SharesService } from './interface';
 import { PhotosNodesAPIService, PhotosNodesAccess, PhotosNodesCache, PhotosNodesManagement } from './nodes';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
+import { PhotosManager } from './photosManager';
 import {
     PhotoFileUploader,
     PhotoUploadAPIService,
@@ -33,7 +35,7 @@ import {
     PhotoUploadMetadata,
 } from './upload';
 
-export type { DecryptedPhotoNode, TimelineItem, AlbumItem, PhotoTag } from './interface';
+export type { DecryptedPhotoNode, TimelineItem, AlbumItem } from './interface';
 
 // Only photos and albums can be shared in photos volume.
 export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
@@ -60,11 +62,13 @@ export function initPhotosModule(
         photoShares,
         nodesService,
     );
-    const albums = new Albums(telemetry, api, albumsCryptoService, photoShares, nodesService);
+    const albums = new AlbumsManager(telemetry, api, albumsCryptoService, photoShares, nodesService);
+    const photos = new PhotosManager(telemetry.getLogger('photos-update'), api, albumsCryptoService, nodesService);
 
     return {
         timeline,
         albums,
+        photos,
     };
 }
 
@@ -145,10 +149,11 @@ export function initPhotoUploadModule(
     driveCrypto: DriveCrypto,
     sharesService: SharesService,
     nodesService: UploadNodesService,
+    featureFlagProvider: FeatureFlagProvider,
     clientUid?: string,
 ) {
     const api = new PhotoUploadAPIService(apiService, clientUid);
-    const cryptoService = new PhotoUploadCryptoService(driveCrypto, nodesService);
+    const cryptoService = new PhotoUploadCryptoService(telemetry, driveCrypto, nodesService, featureFlagProvider);
 
     const uploadTelemetry = new UploadTelemetry(telemetry, sharesService);
     const manager = new PhotoUploadManager(telemetry, api, cryptoService, nodesService, clientUid);

package/src/internal/photos/interface.ts

@@ -1,5 +1,5 @@
 import { PrivateKey } from '../../crypto';
-import { MetricVolumeType, PhotoAttributes, AlbumAttributes } from '../../interface';
+import { MetricVolumeType, PhotoAttributes, AlbumAttributes, PhotoTag } from '../../interface';
 import { DecryptedNode, EncryptedNode, DecryptedUnparsedNode } from '../nodes/interface';
 import { EncryptedShare } from '../shares';
 
@@ -24,7 +24,7 @@ export interface SharesService {
 }
 
 export type EncryptedPhotoNode = EncryptedNode & {
-    photo?: EcnryptedPhotoAttributes;
+    photo?: EncryptedPhotoAttributes;
     album?: AlbumAttributes;
 };
 
@@ -38,7 +38,7 @@ export type DecryptedPhotoNode = DecryptedNode & {
     album?: AlbumAttributes;
 };
 
-export type EcnryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
+export type EncryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
     contentHash?: string;
     albums: (PhotoAttributes['albums'][0] & {
         nameHash?: string;
@@ -56,28 +56,3 @@ 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,
-}
-
-export type AddToAlbumEncryptedPhotoPayload = {
-    nodeUid: string;
-    contentHash: string;
-    nameHash: string;
-    encryptedName: string;
-    nameSignatureEmail: string;
-    nodePassphrase: string;
-    nodePassphraseSignature?: string;
-    signatureEmail?: string;
-    relatedPhotos?: Omit<AddToAlbumEncryptedPhotoPayload, 'relatedPhotos'>[];
-};

package/src/internal/photos/nodes.ts

@@ -178,7 +178,7 @@ export class PhotosNodesAccess extends NodesAccessBase<EncryptedPhotoNode, Decry
 
         // This is bug that should not happen.
         // API cannot provide node without parent or share or album.
-        throw new Error('Node has neither parent node nor share nor album');
+        throw new Error(`Node has neither parent node nor share nor album: ${node.uid}`);
     }
 
     protected getDegradedUndecryptableNode(

package/src/internal/photos/photosManager.test.ts

@@ -0,0 +1,266 @@
+import { resultOk, PhotoTag } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { PhotosManager, UpdatePhotoSettings } from './photosManager';
+import { PhotosAPIService } from './apiService';
+import { AlbumsCryptoService } from './albumsCrypto';
+import { PhotosNodesAccess } from './nodes';
+import { DecryptedPhotoNode } from './interface';
+
+function createMockPhotoNode(uid: string, overrides: Partial<DecryptedPhotoNode> = {}): DecryptedPhotoNode {
+    return {
+        uid,
+        parentUid: 'volume1~parent',
+        hash: 'hash',
+        name: resultOk('photo.jpg'),
+        photo: {
+            captureTime: new Date(),
+            mainPhotoNodeUid: undefined,
+            relatedPhotoNodeUids: [],
+            tags: [],
+            albums: [],
+        },
+        activeRevision: {
+            ok: true,
+            value: {
+                uid: 'rev1',
+                state: 'active' as const,
+                creationTime: new Date(),
+                storageSize: 100,
+                signatureEmail: 'test@example.com',
+                claimedModificationTime: new Date(),
+                claimedSize: 100,
+                claimedDigests: { sha1: 'sha1hash' },
+                claimedBlockSizes: [100],
+            },
+        },
+        keyAuthor: { ok: true, value: 'test@example.com' },
+        ...overrides,
+    } as DecryptedPhotoNode;
+}
+
+async function collectUpdateResults(manager: PhotosManager, photos: UpdatePhotoSettings[], signal?: AbortSignal) {
+    const results = [];
+    for await (const result of manager.updatePhotos(photos, signal)) {
+        results.push(result);
+    }
+    return results;
+}
+
+describe('PhotosManager', () => {
+    let logger: ReturnType<typeof getMockLogger>;
+    let apiService: jest.Mocked<Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite'>>;
+    let cryptoService: jest.Mocked<Pick<AlbumsCryptoService, 'encryptPhotoForAlbum'>>;
+    let nodesService: jest.Mocked<
+        Pick<
+            PhotosNodesAccess,
+            | 'getVolumeRootFolder'
+            | 'getNodeKeys'
+            | 'getNodeSigningKeys'
+            | 'iterateNodes'
+            | 'getNodePrivateAndSessionKeys'
+            | 'notifyNodeChanged'
+        >
+    >;
+    let manager: PhotosManager;
+
+    const volumeRootKeys = {
+        key: 'rootKey' as any,
+        hashKey: new Uint8Array([1, 2, 3]),
+    };
+    const signingKeys = {
+        type: 'userAddress' as const,
+        email: 'test@example.com',
+        addressId: 'addressId',
+        key: 'signingKey' as any,
+    };
+    beforeEach(() => {
+        logger = getMockLogger();
+
+        apiService = {
+            addPhotoTags: jest.fn().mockResolvedValue(undefined),
+            removePhotoTags: jest.fn().mockResolvedValue(undefined),
+            setPhotoFavorite: jest.fn().mockResolvedValue(undefined),
+        };
+
+        cryptoService = {
+            encryptPhotoForAlbum: jest.fn().mockResolvedValue({
+                contentHash: 'contentHash',
+                hash: 'nameHash',
+                encryptedName: 'encryptedName',
+                nameSignatureEmail: 'test@example.com',
+                armoredNodePassphrase: 'passphrase',
+                armoredNodePassphraseSignature: 'signature',
+                signatureEmail: 'test@example.com',
+            }),
+        };
+
+        nodesService = {
+            getVolumeRootFolder: jest.fn().mockResolvedValue({ uid: 'volume1~root' }),
+            getNodeKeys: jest.fn().mockResolvedValue(volumeRootKeys),
+            getNodeSigningKeys: jest.fn().mockResolvedValue(signingKeys),
+            iterateNodes: jest.fn().mockImplementation(async function* (uids: string[]) {
+                for (const uid of uids) {
+                    yield createMockPhotoNode(uid);
+                }
+            }),
+            getNodePrivateAndSessionKeys: jest.fn().mockResolvedValue({
+                key: 'nodeKey' as any,
+                nameSessionKey: 'sessionKey' as any,
+                passphrase: 'passphrase',
+                passphraseSessionKey: 'passphraseSessionKey' as any,
+            }),
+            notifyNodeChanged: jest.fn().mockResolvedValue(undefined),
+        };
+
+        manager = new PhotosManager(logger, apiService as any, cryptoService as any, nodesService as any);
+    });
+
+    describe('updatePhotos', () => {
+        describe('add tags only', () => {
+            it('calls addPhotoTags and notifyNodeChanged for each photo', async () => {
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [PhotoTag.Screenshots], tagsToRemove: [] },
+                    { nodeUid: 'volume1~photo2', tagsToAdd: [PhotoTag.LivePhotos], tagsToRemove: [] },
+                ]);
+
+                expect(results).toEqual([
+                    { uid: 'volume1~photo1', ok: true },
+                    { uid: 'volume1~photo2', ok: true },
+                ]);
+                expect(apiService.addPhotoTags).toHaveBeenCalledTimes(2);
+                expect(apiService.addPhotoTags).toHaveBeenCalledWith('volume1~photo1', [PhotoTag.Screenshots]);
+                expect(apiService.addPhotoTags).toHaveBeenCalledWith('volume1~photo2', [PhotoTag.LivePhotos]);
+                expect(nodesService.getVolumeRootFolder).not.toHaveBeenCalled();
+                expect(apiService.setPhotoFavorite).not.toHaveBeenCalled();
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledTimes(2);
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo2');
+            });
+
+            it('filters Favorites from addTags and calls setPhotoFavorite with payload', async () => {
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [PhotoTag.Favorites], tagsToRemove: [] },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: true }]);
+                expect(nodesService.getVolumeRootFolder).toHaveBeenCalled();
+                expect(nodesService.getNodeKeys).toHaveBeenCalledWith('volume1~root');
+                expect(nodesService.getNodeSigningKeys).toHaveBeenCalledWith({ nodeUid: 'volume1~root' });
+                expect(apiService.setPhotoFavorite).toHaveBeenCalledTimes(1);
+                expect(apiService.setPhotoFavorite).toHaveBeenCalledWith(
+                    'volume1~photo1',
+                    expect.objectContaining({
+                        nodeUid: 'volume1~photo1',
+                        contentHash: 'contentHash',
+                        nameHash: 'nameHash',
+                        relatedPhotos: [],
+                    }),
+                );
+                expect(apiService.addPhotoTags).not.toHaveBeenCalled();
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
+            });
+
+            it('calls setPhotoFavorite and addPhotoTags when addTags includes Favorites and other tags', async () => {
+                const results = await collectUpdateResults(manager, [
+                    {
+                        nodeUid: 'volume1~photo1',
+                        tagsToAdd: [PhotoTag.Favorites, PhotoTag.Screenshots],
+                        tagsToRemove: [],
+                    },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: true }]);
+                expect(apiService.setPhotoFavorite).toHaveBeenCalledWith('volume1~photo1', expect.any(Object));
+                expect(apiService.addPhotoTags).toHaveBeenCalledWith('volume1~photo1', [PhotoTag.Screenshots]);
+            });
+
+            it('calls setPhotoFavorite when payload builder returns PhotoAlreadyInTargetError (photo already in root)', async () => {
+                nodesService.iterateNodes.mockImplementation(async function* (uids: string[]) {
+                    for (const uid of uids) {
+                        yield createMockPhotoNode(uid, { parentUid: 'volume1~root' });
+                    }
+                });
+
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [PhotoTag.Favorites], tagsToRemove: [] },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: true }]);
+                expect(apiService.setPhotoFavorite).toHaveBeenCalledWith('volume1~photo1', undefined);
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
+            });
+        });
+
+        describe('remove tags only', () => {
+            it('calls removePhotoTags and notifyNodeChanged for each photo', async () => {
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [], tagsToRemove: [PhotoTag.Screenshots] },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: true }]);
+                expect(apiService.removePhotoTags).toHaveBeenCalledWith('volume1~photo1', [PhotoTag.Screenshots]);
+                expect(apiService.addPhotoTags).not.toHaveBeenCalled();
+                expect(nodesService.getVolumeRootFolder).not.toHaveBeenCalled();
+                expect(apiService.setPhotoFavorite).not.toHaveBeenCalled();
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
+            });
+        });
+
+        describe('add and remove tags together', () => {
+            it('calls addPhotoTags and removePhotoTags and notifyNodeChanged', async () => {
+                const results = await collectUpdateResults(manager, [
+                    {
+                        nodeUid: 'volume1~photo1',
+                        tagsToAdd: [PhotoTag.Panoramas],
+                        tagsToRemove: [PhotoTag.Screenshots],
+                    },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: true }]);
+                expect(apiService.addPhotoTags).toHaveBeenCalledWith('volume1~photo1', [PhotoTag.Panoramas]);
+                expect(apiService.removePhotoTags).toHaveBeenCalledWith('volume1~photo1', [PhotoTag.Screenshots]);
+                expect(apiService.setPhotoFavorite).not.toHaveBeenCalled();
+                expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
+            });
+        });
+
+        describe('API failures', () => {
+            it('yields error result and logs when setPhotoFavorite fails', async () => {
+                const apiError = new Error('Favorite API failed');
+                apiService.setPhotoFavorite.mockRejectedValue(apiError);
+
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [PhotoTag.Favorites], tagsToRemove: [] },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: false, error: apiError }]);
+                expect(logger.error).toHaveBeenCalledWith('Update photos failed for volume1~photo1', apiError);
+                expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+            });
+
+            it('yields error result when addPhotoTags fails', async () => {
+                const apiError = new Error('Add tags failed');
+                apiService.addPhotoTags.mockRejectedValue(apiError);
+
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [PhotoTag.Screenshots], tagsToRemove: [] },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: false, error: apiError }]);
+                expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+            });
+
+            it('yields error result when removePhotoTags fails', async () => {
+                const apiError = new Error('Remove tags failed');
+                apiService.removePhotoTags.mockRejectedValue(apiError);
+
+                const results = await collectUpdateResults(manager, [
+                    { nodeUid: 'volume1~photo1', tagsToAdd: [], tagsToRemove: [PhotoTag.Videos] },
+                ]);
+
+                expect(results).toEqual([{ uid: 'volume1~photo1', ok: false, error: apiError }]);
+                expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

package/src/internal/photos/photosManager.ts

@@ -0,0 +1,144 @@
+import { c } from 'ttag';
+
+import { Logger, NodeResultWithError, PhotoTag } from '../../interface';
+import { PhotosAPIService } from './apiService';
+import { PhotoAlreadyInTargetError, PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
+import { PhotosNodesAccess } from './nodes';
+import { AlbumsCryptoService } from './albumsCrypto';
+import { AbortError } from '../../errors';
+import { BATCH_LOADING_SIZE } from '../sharing/sharingAccess';
+import { batch } from '../batch';
+
+export type UpdatePhotoSettings = {
+    nodeUid: string;
+    tagsToAdd: PhotoTag[];
+    tagsToRemove: PhotoTag[];
+};
+
+/**
+ * Manages updating photos: adding/removing tags and favoriting.
+ * Uses the same encrypted payload as add-to-album/copy for the favorite endpoint.
+ */
+export class PhotosManager {
+    private readonly payloadBuilder: PhotoTransferPayloadBuilder;
+
+    constructor(
+        private readonly logger: Logger,
+        private readonly apiService: PhotosAPIService,
+        albumsCryptoService: AlbumsCryptoService,
+        private readonly nodesService: PhotosNodesAccess,
+    ) {
+        this.payloadBuilder = new PhotoTransferPayloadBuilder(albumsCryptoService, nodesService);
+    }
+
+    async *updatePhotos(photos: UpdatePhotoSettings[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
+        for await (const {
+            photoSettings: { nodeUid, tagsToAdd, tagsToRemove },
+            payloadForFavorite,
+            error,
+        } of this.iterateNodeUidsWithFavoritePayloads(photos, signal)) {
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+
+            if (error) {
+                yield { uid: nodeUid, ok: false, error };
+                continue;
+            }
+
+            try {
+                if (tagsToAdd.includes(PhotoTag.Favorites)) {
+                    await this.apiService.setPhotoFavorite(nodeUid, payloadForFavorite);
+                }
+                const addTags = tagsToAdd.filter((tag) => tag !== PhotoTag.Favorites);
+                if (addTags.length) {
+                    await this.apiService.addPhotoTags(nodeUid, addTags);
+                }
+                if (tagsToRemove.length) {
+                    await this.apiService.removePhotoTags(nodeUid, tagsToRemove);
+                }
+
+                await this.nodesService.notifyNodeChanged(nodeUid);
+                yield { uid: nodeUid, ok: true };
+            } catch (error) {
+                this.logger.error(`Update photos failed for ${nodeUid}`, error);
+                yield {
+                    uid: nodeUid,
+                    ok: false,
+                    error: error instanceof Error ? error : new Error(c('Error').t`Unknown error`, { cause: error }),
+                };
+            }
+        }
+    }
+
+    private async *iterateNodeUidsWithFavoritePayloads(
+        photosSettings: UpdatePhotoSettings[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<{
+        photoSettings: UpdatePhotoSettings;
+        payloadForFavorite?: TransferEncryptedPhotoPayload;
+        error?: Error;
+    }> {
+        const photosSettingsWithoutFavorite = photosSettings.filter(
+            (photoSettings) => !photoSettings.tagsToAdd?.includes(PhotoTag.Favorites),
+        );
+        const photosSettingsWithFavorite = photosSettings.filter((photoSettings) =>
+            photoSettings.tagsToAdd?.includes(PhotoTag.Favorites),
+        );
+
+        for (const photoSettings of photosSettingsWithoutFavorite) {
+            yield { photoSettings };
+        }
+
+        if (!photosSettingsWithFavorite.length) {
+            return;
+        }
+
+        const rootNode = await this.nodesService.getVolumeRootFolder();
+        const volumeRootKeys = await this.nodesService.getNodeKeys(rootNode.uid);
+        const signingKeys = await this.nodesService.getNodeSigningKeys({ nodeUid: rootNode.uid });
+
+        // Batch iteration to fetch metadata for preparing the payloads in parallel.
+        for (const photoSettingsBatch of batch(photosSettingsWithFavorite, BATCH_LOADING_SIZE)) {
+            if (signal?.aborted) {
+                throw new AbortError();
+            }
+
+            const result = await this.payloadBuilder.preparePhotoPayloads(
+                photoSettingsBatch.map(({ nodeUid }) => ({ photoNodeUid: nodeUid })),
+                rootNode.uid,
+                volumeRootKeys,
+                signingKeys,
+                signal,
+            );
+
+            for (const [nodeUid, error] of result.errors) {
+                const photoSettings = photosSettingsWithFavorite.find(
+                    (photoSettings) => photoSettings.nodeUid === nodeUid,
+                );
+                if (!photoSettings) {
+                    this.logger.error(`Photo settings not found for ${nodeUid}, unexpected error`);
+                    continue;
+                }
+
+                // If the photo is already in the root node, we only set the favorite tag.
+                if (error instanceof PhotoAlreadyInTargetError) {
+                    yield { photoSettings };
+                    continue;
+                }
+                yield { photoSettings, error };
+            }
+
+            for (const payloadForFavorite of result.payloads) {
+                const photoSettings = photosSettingsWithFavorite.find(
+                    (photoSettings) => photoSettings.nodeUid === payloadForFavorite.nodeUid,
+                );
+                if (!photoSettings) {
+                    this.logger.error(`Photo settings not found for ${payloadForFavorite.nodeUid}, unexpected payload`);
+                    continue;
+                }
+                yield { photoSettings, payloadForFavorite };
+            }
+        }
+    }
+}