@protontech/drive-sdk 0.9.9 → 0.11.0

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

@@ -44,6 +44,10 @@ function generateAPIAlbumNode(linkOverrides = {}, overrides = {}) {
         ...node,
         Link: { ...node.Link, Type: 3, ...linkOverrides },
         Photo: null,
+        Album: {
+            PhotoCount: 1,
+            CoverLinkID: 'coverLinkId',
+        },
         Folder: null,
         ...overrides,
     };
@@ -103,6 +107,8 @@ describe('PhotosNodesAPIService', () => {
             const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
             expect(nodes).toHaveLength(1);
             expect(nodes[0].type).toBe(expectedType);
+
+            return nodes;
         }
 
         it('should convert folder (type 1) to folder node', async () => {
@@ -110,16 +116,16 @@ describe('PhotosNodesAPIService', () => {
         });
 
         it('should convert album (type 3) to album node', async () => {
-            await testIterateNodes(generateAPIAlbumNode(), NodeType.Album);
+            const nodes = await testIterateNodes(generateAPIAlbumNode(), NodeType.Album);
+
+            expect(nodes[0].album).toBeDefined();
+            expect(nodes[0].album?.photoCount).toEqual(1);
+            expect(nodes[0].album?.coverPhotoNodeUid).toBe('volumeId~coverLinkId');
         });
 
         it('should convert photo (type 2) to photo node with photo attributes', async () => {
-            apiMock.post = jest.fn().mockResolvedValue({ Links: [generateAPIPhotoNode()] });
-
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
+            const nodes = await testIterateNodes(generateAPIPhotoNode(), NodeType.Photo);
 
-            expect(nodes).toHaveLength(1);
-            expect(nodes[0].type).toBe(NodeType.Photo);
             expect(nodes[0].photo).toBeDefined();
             expect(nodes[0].photo?.captureTime).toEqual(new Date(1700000000 * 1000));
             expect(nodes[0].photo?.tags).toEqual([1, 2]);
@@ -161,6 +167,10 @@ describe('PhotosNodesCache', () => {
                         },
                     ],
                 },
+                album: {
+                    photoCount: 1,
+                    coverPhotoNodeUid: 'volumeId~coverLinkId',
+                },
             });
 
             const node = cache.deserialiseNode(serialisedNode);
@@ -170,6 +180,9 @@ describe('PhotosNodesCache', () => {
             expect(node.photo?.captureTime).toEqual(new Date('2023-11-14T22:13:20.000Z'));
             expect(node.photo?.albums[0].additionTime).toBeInstanceOf(Date);
             expect(node.photo?.albums[0].additionTime).toEqual(new Date('2023-11-15T10:00:00.000Z'));
+            expect(node.album).toBeDefined();
+            expect(node.album?.photoCount).toEqual(1);
+            expect(node.album?.coverPhotoNodeUid).toBe('volumeId~coverLinkId');
         });
 
         it('should handle node without photo attributes', () => {
@@ -187,6 +200,7 @@ describe('PhotosNodesCache', () => {
             const node = cache.deserialiseNode(serialisedNode);
 
             expect(node.photo).toBeUndefined();
+            expect(node.album).toBeUndefined();
         });
     });
 });
@@ -244,6 +258,10 @@ describe('PhotosNodesAccess', () => {
                     tags: [1, 2],
                     albums: [],
                 },
+                album: {
+                    photoCount: 1,
+                    coverPhotoNodeUid: 'volumeId~coverLinkId',
+                },
             };
 
             // @ts-expect-error Accessing protected method for testing
@@ -253,6 +271,9 @@ describe('PhotosNodesAccess', () => {
             expect(parsedNode.photo).toBeDefined();
             expect(parsedNode.photo?.captureTime).toEqual(new Date('2023-11-14T22:13:20.000Z'));
             expect(parsedNode.photo?.tags).toEqual([1, 2]);
+            expect(parsedNode.album).toBeDefined();
+            expect(parsedNode.album?.photoCount).toEqual(1);
+            expect(parsedNode.album?.coverPhotoNodeUid).toBe('volumeId~coverLinkId');
         });
     });
 });

package/src/internal/photos/nodes.ts

@@ -75,11 +75,21 @@ export class PhotosNodesAPIService extends NodeAPIServiceBase<
             };
         }
 
-        if (link.Link.Type === 3) {
+        if (link.Link.Type === 3 && link.Album) {
             return {
                 ...baseNodeMetadata,
+                album: {
+                    photoCount: link.Album.PhotoCount,
+                    coverPhotoNodeUid: link.Album.CoverLinkID
+                        ? makeNodeUid(volumeId, link.Album.CoverLinkID)
+                        : undefined,
+                },
                 encryptedCrypto: {
                     ...baseCryptoNodeMetadata,
+                    folder: {
+                        armoredExtendedAttributes: link.Album.XAttr || undefined,
+                        armoredHashKey: link.Album.NodeHashKey as string,
+                    },
                 },
             };
         }
@@ -111,7 +121,8 @@ export class PhotosNodesCache extends NodesCacheBase<DecryptedPhotoNode> {
             typeof node !== 'object' ||
             (typeof node.photo !== 'object' && node.photo !== undefined) ||
             (typeof node.photo?.captureTime !== 'string' && node.folder?.captureTime !== undefined) ||
-            (typeof node.photo?.albums !== 'object' && node.photo?.albums !== undefined)
+            (typeof node.photo?.albums !== 'object' && node.photo?.albums !== undefined) ||
+            (typeof node.album !== 'object' && node.album !== undefined)
         ) {
             throw new Error(`Invalid node data: ${nodeData}`);
         }
@@ -167,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(
@@ -190,6 +201,18 @@ export class PhotosNodesAccess extends NodesAccessBase<EncryptedPhotoNode, Decry
             };
         }
 
+        if (unparsedNode.type === NodeType.Album) {
+            const node = parseNodeBase(this.logger, {
+                ...unparsedNode,
+                type: NodeType.Folder,
+            });
+            return {
+                ...node,
+                album: unparsedNode.album,
+                type: NodeType.Album,
+            };
+        }
+
         return parseNodeBase(this.logger, unparsedNode);
     }
 }
@@ -210,6 +233,15 @@ export class PhotosNodesCryptoService extends NodesCryptoService {
             };
         }
 
+        if (decryptedNode.node.type === NodeType.Album) {
+            return {
+                node: {
+                    ...decryptedNode.node,
+                    album: encryptedNode.album,
+                },
+            };
+        }
+
         return decryptedNode;
     }
 }

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 };
+            }
+        }
+    }
+}