@protontech/drive-sdk 0.10.0 → 0.11.0

package/src/crypto/driveCrypto.ts

@@ -1,3 +1,4 @@
+import { ProtonDriveTelemetry } from '../interface';
 import {
     OpenPGPCrypto,
     PrivateKey,
@@ -29,9 +30,11 @@ enum SIGNING_CONTEXTS {
  */
 export class DriveCrypto {
     constructor(
+        private telemetry: ProtonDriveTelemetry,
         private openPGPCrypto: OpenPGPCrypto,
         private srpModule: SRPModule,
     ) {
+        this.telemetry = telemetry;
         this.openPGPCrypto = openPGPCrypto;
         this.srpModule = srpModule;
     }
@@ -617,12 +620,14 @@ export class DriveCrypto {
     ): Promise<{
         encryptedData: Uint8Array<ArrayBuffer>;
     }> {
+        const start = performance.now();
         const { encryptedData } = await this.openPGPCrypto.encryptAndSign(
             thumbnailData,
             sessionKey,
             [], // Thumbnails use the session key so we do not send encryption key.
             signingKey,
         );
+        this.recordPerformance('content_encryption', thumbnailData.length, start);
 
         return {
             encryptedData,
@@ -638,11 +643,13 @@ export class DriveCrypto {
         verified: VERIFICATION_STATUS;
         verificationErrors?: Error[];
     }> {
+        const start = performance.now();
         const {
             data: decryptedThumbnail,
             verified,
             verificationErrors,
         } = await this.openPGPCrypto.decryptAndVerify(encryptedThumbnail, sessionKey, verificationKeys);
+        this.recordPerformance('content_decryption', decryptedThumbnail.length, start);
         return {
             decryptedThumbnail,
             verified,
@@ -659,12 +666,14 @@ export class DriveCrypto {
         encryptedData: Uint8Array<ArrayBuffer>;
         armoredSignature: string;
     }> {
+        const start = performance.now();
         const { encryptedData, signature } = await this.openPGPCrypto.encryptAndSignDetached(
             blockData,
             sessionKey,
             [], // Blocks use the session key so we do not send encryption key.
             signingKey,
         );
+        this.recordPerformance('content_encryption', blockData.length, start);
 
         const { armoredSignature } = await this.encryptSignature(signature, encryptionKey, sessionKey);
 
@@ -674,8 +683,13 @@ export class DriveCrypto {
         };
     }
 
-    async decryptBlock(encryptedBlock: Uint8Array<ArrayBuffer>, sessionKey: SessionKey): Promise<Uint8Array<ArrayBuffer>> {
+    async decryptBlock(
+        encryptedBlock: Uint8Array<ArrayBuffer>,
+        sessionKey: SessionKey,
+    ): Promise<Uint8Array<ArrayBuffer>> {
+        const start = performance.now();
         const { data: decryptedBlock } = await this.openPGPCrypto.decryptAndVerify(encryptedBlock, sessionKey, []);
+        this.recordPerformance('content_decryption', decryptedBlock.length, start);
 
         return decryptedBlock;
     }
@@ -716,7 +730,11 @@ export class DriveCrypto {
         return uint8ArrayToUtf8(password);
     }
 
-    async encryptShareUrlPassword(password: string, encryptionKey: PrivateKey, signingKey: PrivateKey): Promise<string> {
+    async encryptShareUrlPassword(
+        password: string,
+        encryptionKey: PrivateKey,
+        signingKey: PrivateKey,
+    ): Promise<string> {
         const { armoredData } = await this.openPGPCrypto.encryptAndSignArmored(
             new TextEncoder().encode(password),
             undefined,
@@ -725,6 +743,22 @@ export class DriveCrypto {
         );
         return armoredData;
     }
+
+    private recordPerformance(
+        type: 'content_encryption' | 'content_decryption',
+        bytesProcessed: number,
+        start: number,
+    ) {
+        const end = performance.now();
+        const duration = end - start;
+        this.telemetry.recordMetric({
+            eventName: 'performance',
+            type,
+            cryptoModel: 'v1',
+            bytesProcessed,
+            milliseconds: Math.round(duration),
+        });
+    }
 }
 
 export function uint8ArrayToUtf8(input: Uint8Array<ArrayBuffer>): string {

package/src/diagnostic/telemetry.ts

@@ -27,6 +27,9 @@ export class DiagnosticTelemetry extends EventsGenerator {
         if (event.eventName === 'volumeEventsSubscriptionsChanged') {
             return;
         }
+        if (event.eventName === 'performance') {
+            return;
+        }
 
         this.enqueueEvent({
             type: 'metric',

package/src/interface/index.ts

@@ -56,6 +56,7 @@ export type {
     PhotoAttributes,
     AlbumAttributes,
 } from './photos';
+export { PhotoTag } from './photos';
 export type {
     ProtonInvitation,
     ProtonInvitationWithNode,

package/src/interface/photos.ts

@@ -65,7 +65,20 @@ export type PhotoAttributes = {
     /**
      * List of tags assigned to the photo.
      */
-    tags: number[]; // TODO: enum
+    tags: PhotoTag[];
+};
+
+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/interface/telemetry.ts

@@ -18,7 +18,8 @@ export type MetricEvent =
     | MetricDecryptionErrorEvent
     | MetricVerificationErrorEvent
     | MetricBlockVerificationErrorEvent
-    | MetricVolumeEventsSubscriptionsChangedEvent;
+    | MetricVolumeEventsSubscriptionsChangedEvent
+    | MetricPerformanceEvent;
 
 export interface MetricAPIRetrySucceededEvent {
     eventName: 'apiRetrySucceeded';
@@ -118,3 +119,15 @@ export enum MetricVolumeType {
     Shared = 'shared',
     SharedPublic = 'shared_public',
 }
+
+/**
+ * Experimental metrics to track performance of encryption and decryption
+ * operations of the file content.
+ */
+export interface MetricPerformanceEvent {
+    eventName: 'performance';
+    type: 'content_encryption' | 'content_decryption';
+    cryptoModel: 'v1' | 'v1.5';
+    bytesProcessed: number;
+    milliseconds: number;
+}

package/src/internal/apiService/apiService.ts

@@ -137,8 +137,12 @@ export class DriveAPIService {
         return this.makeRequest(url, 'PUT', data, signal);
     }
 
-    async delete<Response>(url: string, signal?: AbortSignal): Promise<Response> {
-        return this.makeRequest(url, 'DELETE', undefined, signal);
+    async delete<RequestPayload, ResponsePayload>(
+        url: string,
+        data?: RequestPayload,
+        signal?: AbortSignal,
+    ): Promise<ResponsePayload> {
+        return this.makeRequest(url, 'DELETE', data, signal);
     }
 
     protected async makeRequest<RequestPayload, ResponsePayload>(

package/src/internal/nodes/apiService.ts

@@ -440,7 +440,7 @@ export abstract class NodeAPIServiceBase<
     }
 
     async emptyTrash(volumeId: string): Promise<void> {
-        await this.apiService.delete<EmptyTrashResponse>(`drive/volumes/${volumeId}/trash`);
+        await this.apiService.delete<undefined, EmptyTrashResponse>(`drive/volumes/${volumeId}/trash`);
     }
 
     async *restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
@@ -561,7 +561,7 @@ export abstract class NodeAPIServiceBase<
     async deleteRevision(nodeRevisionUid: string): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
 
-        await this.apiService.delete<DeleteRevisionResponse>(
+        await this.apiService.delete<undefined, DeleteRevisionResponse>(
             `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`,
         );
     }

package/src/internal/nodes/nodesAccess.ts

@@ -412,7 +412,7 @@ export abstract class NodesAccessBase<
         }
         // This is bug that should not happen.
         // API cannot provide node without parent or share.
-        throw new Error('Node has neither parent node nor share');
+        throw new Error(`Node has neither parent node nor share: ${node.uid}`);
     }
 
     async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {

package/src/internal/photos/addToAlbum.ts

@@ -1,13 +1,12 @@
 import { c } from 'ttag';
 
-import { ValidationError } from '../../errors';
 import { Logger, NodeResultWithError } from '../../interface';
 import { DecryptedNodeKeys, NodeSigningKeys } from '../nodes/interface';
 import { splitNodeUid } from '../uids';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { MissingRelatedPhotosError } from './errors';
-import { AddToAlbumEncryptedPhotoPayload, DecryptedPhotoNode } from './interface';
+import { PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 import { PhotosNodesAccess } from './nodes';
 
 /**
@@ -47,18 +46,20 @@ type PhotoQueueItem = {
 export class AddToAlbumProcess {
     private readonly albumVolumeId: string;
     private readonly retriedPhotoUids = new Set<string>();
+    private readonly payloadBuilder: PhotoTransferPayloadBuilder;
 
     constructor(
         private readonly albumNodeUid: string,
         private readonly albumKeys: DecryptedNodeKeys,
         private readonly signingKeys: NodeSigningKeys,
         private readonly apiService: PhotosAPIService,
-        private readonly cryptoService: AlbumsCryptoService,
+        cryptoService: AlbumsCryptoService,
         private readonly nodesService: PhotosNodesAccess,
         private readonly logger: Logger,
         private readonly signal?: AbortSignal,
     ) {
         this.albumVolumeId = splitNodeUid(albumNodeUid).volumeId;
+        this.payloadBuilder = new PhotoTransferPayloadBuilder(cryptoService, nodesService);
     }
 
     async *execute(photoNodeUids: string[]): AsyncGenerator<NodeResultWithError> {
@@ -71,7 +72,13 @@ export class AddToAlbumProcess {
     private async *processSameVolumeQueue(queue: PhotoQueueItem[]): AsyncGenerator<NodeResultWithError> {
         while (queue.length > 0) {
             const items = queue.splice(0, BATCH_LOADING_SIZE);
-            const { payloads, errors } = await this.preparePhotoPayloads(items);
+            const { payloads, errors } = await this.payloadBuilder.preparePhotoPayloads(
+                items,
+                this.albumNodeUid,
+                this.albumKeys,
+                this.signingKeys,
+                this.signal,
+            );
 
             for (const [uid, error] of errors) {
                 yield { uid, ok: false, error };
@@ -97,7 +104,13 @@ export class AddToAlbumProcess {
     private async *processDifferentVolumeQueue(queue: PhotoQueueItem[]): AsyncGenerator<NodeResultWithError> {
         while (queue.length > 0) {
             const items = queue.splice(0, BATCH_LOADING_SIZE);
-            const { payloads, errors } = await this.preparePhotoPayloads(items);
+            const { payloads, errors } = await this.payloadBuilder.preparePhotoPayloads(
+                items,
+                this.albumNodeUid,
+                this.albumKeys,
+                this.signingKeys,
+                this.signal,
+            );
 
             for (const [uid, error] of errors) {
                 yield { uid, ok: false, error };
@@ -105,7 +118,11 @@ export class AddToAlbumProcess {
 
             for (const payload of payloads) {
                 try {
-                    const newPhotoNodeUid = await this.apiService.copyPhotoToAlbum(this.albumNodeUid, payload, this.signal);
+                    const newPhotoNodeUid = await this.apiService.copyPhotoToAlbum(
+                        this.albumNodeUid,
+                        payload,
+                        this.signal,
+                    );
                     await this.nodesService.notifyChildCreated(newPhotoNodeUid);
                     yield { uid: payload.nodeUid, ok: true };
                 } catch (error) {
@@ -119,131 +136,14 @@ export class AddToAlbumProcess {
                     yield {
                         uid: payload.nodeUid,
                         ok: false,
-                        error: error instanceof Error ? error : new Error(c('Error').t`Unknown error`, { cause: error }),
+                        error:
+                            error instanceof Error ? error : new Error(c('Error').t`Unknown error`, { cause: error }),
                     };
                 }
             }
         }
     }
 
-    private async preparePhotoPayloads(items: PhotoQueueItem[]): Promise<{
-        payloads: AddToAlbumEncryptedPhotoPayload[];
-        errors: Map<string, Error>;
-    }> {
-        const payloads: AddToAlbumEncryptedPhotoPayload[] = [];
-        const errors = new Map<string, Error>();
-
-        const additionalRelatedMap = new Map(
-            items.map((item) => [item.photoNodeUid, item.additionalRelatedPhotoNodeUids]),
-        );
-
-        const nodeUids = items.map((item) => item.photoNodeUid);
-        for await (const photoNode of this.nodesService.iterateNodes(nodeUids, this.signal)) {
-            if ('missingUid' in photoNode) {
-                errors.set(photoNode.missingUid, new ValidationError(c('Error').t`Photo not found`));
-                continue;
-            }
-
-            try {
-                const additionalRelated = additionalRelatedMap.get(photoNode.uid) || [];
-                const payload = await this.preparePhotoPayload(photoNode, additionalRelated);
-                payloads.push(payload);
-            } catch (error) {
-                errors.set(
-                    photoNode.uid,
-                    error instanceof Error ? error : new Error(c('Error').t`Unknown error`, { cause: error }),
-                );
-            }
-        }
-
-        return { payloads, errors };
-    }
-
-    private async preparePhotoPayload(
-        photoNode: DecryptedPhotoNode,
-        additionalRelatedPhotoNodeUids: string[],
-    ): Promise<AddToAlbumEncryptedPhotoPayload> {
-        const photoData = await this.encryptPhotoForAlbum(photoNode);
-
-        const relatedNodeUids = [...new Set([
-            ...(photoNode.photo?.relatedPhotoNodeUids || []),
-            ...additionalRelatedPhotoNodeUids,
-        ])];
-
-        const relatedPhotos =
-            relatedNodeUids.length > 0 ? await this.prepareRelatedPhotoPayloads(relatedNodeUids) : [];
-
-        return {
-            ...photoData,
-            relatedPhotos,
-        };
-    }
-
-    private async prepareRelatedPhotoPayloads(
-        nodeUids: string[],
-    ): Promise<Omit<AddToAlbumEncryptedPhotoPayload, 'relatedPhotos'>[]> {
-        const payloads: Omit<AddToAlbumEncryptedPhotoPayload, 'relatedPhotos'>[] = [];
-
-        for await (const photoNode of this.nodesService.iterateNodes(nodeUids, this.signal)) {
-            // Missing related photos means that the related photo was deleted
-            // since the loading of the metadata. It can happen and should be
-            // ignored. The backend controls all the related photos are part
-            // of the request, thus the request will fail and be retried if
-            // there is any other race condition.
-            if ('missingUid' in photoNode) {
-                continue;
-            }
-            const payload = await this.encryptPhotoForAlbum(photoNode);
-            payloads.push(payload);
-        }
-
-        return payloads;
-    }
-
-    private async encryptPhotoForAlbum(
-        photoNode: DecryptedPhotoNode,
-    ): Promise<AddToAlbumEncryptedPhotoPayload> {
-        const nodeKeys = await this.nodesService.getNodePrivateAndSessionKeys(photoNode.uid);
-
-        const contentSha1 = photoNode.activeRevision?.ok
-            ? photoNode.activeRevision.value.claimedDigests?.sha1
-            : undefined;
-
-        if (!contentSha1) {
-            throw new Error('Cannot add photo to album without a content hash');
-        }
-
-        const encryptedCrypto = await this.cryptoService.encryptPhotoForAlbum(
-            photoNode.name,
-            contentSha1,
-            nodeKeys,
-            { key: this.albumKeys.key, hashKey: this.albumKeys.hashKey! },
-            this.signingKeys,
-        );
-
-        // Node could be uploaded or renamed by anonymous user and thus have
-        // missing signatures that must be added to the request.
-        // Node passphrase and signature email must be passed if and only if
-        // the signatures are missing (key author is null).
-        const anonymousKey = photoNode.keyAuthor.ok && photoNode.keyAuthor.value === null;
-        const keySignatureProperties = !anonymousKey
-            ? {}
-            : {
-                  signatureEmail: encryptedCrypto.signatureEmail,
-                  nodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
-              };
-
-        return {
-            nodeUid: photoNode.uid,
-            contentHash: encryptedCrypto.contentHash,
-            nameHash: encryptedCrypto.hash,
-            encryptedName: encryptedCrypto.encryptedName,
-            nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
-            nodePassphrase: encryptedCrypto.armoredNodePassphrase,
-            ...keySignatureProperties,
-        };
-    }
-
     /**
      * If the result indicates a MissingRelatedPhotosError that hasn't
      * been retried, returns a retry queue item. Otherwise returns undefined.
@@ -260,19 +160,14 @@ export class AddToAlbumProcess {
      * Returns undefined if the photo has already been retried, preventing
      * infinite retry loops.
      */
-    private createRetryQueueItem(
-        photoNodeUid: string,
-        error: MissingRelatedPhotosError,
-    ): PhotoQueueItem | undefined {
+    private createRetryQueueItem(photoNodeUid: string, error: MissingRelatedPhotosError): PhotoQueueItem | undefined {
         if (this.retriedPhotoUids.has(photoNodeUid)) {
             this.logger.warn(`Missing related photos for ${photoNodeUid}, already retried`);
             return undefined;
         }
 
         this.retriedPhotoUids.add(photoNodeUid);
-        this.logger.info(
-            `Missing related photos for ${photoNodeUid}, re-queuing: ${error.missingNodeUids.join(', ')}`,
-        );
+        this.logger.info(`Missing related photos for ${photoNodeUid}, re-queuing: ${error.missingNodeUids.join(', ')}`);
 
         return {
             photoNodeUid,
@@ -316,10 +211,8 @@ function splitByVolume(
  * Groups payloads into batches respecting the API limit.
  * Each payload's size counts itself plus its related photos.
  */
-function* createBatches(
-    payloads: AddToAlbumEncryptedPhotoPayload[],
-): Generator<AddToAlbumEncryptedPhotoPayload[]> {
-    let batch: AddToAlbumEncryptedPhotoPayload[] = [];
+function* createBatches(payloads: TransferEncryptedPhotoPayload[]): Generator<TransferEncryptedPhotoPayload[]> {
+    let batch: TransferEncryptedPhotoPayload[] = [];
     let batchSize = 0;
 
     for (const payload of payloads) {

package/src/internal/photos/{albums.test.ts → albumsManager.test.ts}

@@ -1,7 +1,7 @@
 import { NodeType } from '../../interface';
 import { ValidationError } from '../../errors';
 import { getMockTelemetry } from '../../tests/telemetry';
-import { Albums } from './albums';
+import { AlbumsManager } from './albumsManager';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { DecryptedPhotoNode } from './interface';
@@ -13,7 +13,7 @@ describe('Albums', () => {
     let cryptoService: AlbumsCryptoService;
     let photoShares: PhotoSharesManager;
     let nodesService: PhotosNodesAccess;
-    let albums: Albums;
+    let albums: AlbumsManager;
 
     let nodes: { [uid: string]: DecryptedPhotoNode };
 
@@ -97,7 +97,7 @@ describe('Albums', () => {
             notifyChildCreated: jest.fn(),
         };
 
-        albums = new Albums(getMockTelemetry(), apiService, cryptoService, photoShares, nodesService);
+        albums = new AlbumsManager(getMockTelemetry(), apiService, cryptoService, photoShares, nodesService);
     });
 
     describe('createAlbum', () => {

package/src/internal/photos/{albums.ts → albumsManager.ts}

@@ -16,7 +16,7 @@ const BATCH_LOADING_SIZE = 10;
 /**
  * Provides access and high-level actions for managing albums.
  */
-export class Albums {
+export class AlbumsManager {
     private logger: Logger;
 
     constructor(

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