@protontech/drive-sdk 0.13.0 → 0.14.0

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

@@ -28,6 +28,7 @@ describe('photosAPIService', () => {
                 nodeUid: 'volumeId1~photoNodeId1',
                 contentHash: 'contentHash1',
                 nameHash: 'nameHash1',
+                originalNameHash: 'originalNameHash1',
                 encryptedName: 'encryptedName1',
                 nameSignatureEmail: 'nameSignatureEmail1',
                 nodePassphrase: 'nodePassphrase1',
@@ -38,6 +39,7 @@ describe('photosAPIService', () => {
                         nodeUid: 'volumeId1~photoNodeId2',
                         contentHash: 'contentHash2',
                         nameHash: 'nameHash2',
+                        originalNameHash: 'originalNameHash2',
                         encryptedName: 'encryptedName2',
                         nameSignatureEmail: 'nameSignatureEmail2',
                         nodePassphrase: 'nodePassphrase2',
@@ -151,6 +153,7 @@ describe('photosAPIService', () => {
                 nodeUid: 'volumeId2~photoNodeId1',
                 contentHash: 'contentHash1',
                 nameHash: 'nameHash1',
+                originalNameHash: 'originalNameHash1',
                 encryptedName: 'encryptedName1',
                 nameSignatureEmail: 'nameSignatureEmail1',
                 nodePassphrase: 'nodePassphrase1',
@@ -161,6 +164,7 @@ describe('photosAPIService', () => {
                         nodeUid: 'volumeId2~photoNodeId2',
                         contentHash: 'contentHash2',
                         nameHash: 'nameHash2',
+                        originalNameHash: 'originalNameHash2',
                         encryptedName: 'encryptedName2',
                         nameSignatureEmail: 'nameSignatureEmail2',
                         nodePassphrase: 'nodePassphrase2',
@@ -230,4 +234,155 @@ describe('photosAPIService', () => {
             await expect(promise).rejects.toThrow(error);
         });
     });
+
+    describe('transferPhotos', () => {
+        const photoPayloads = [
+            {
+                nodeUid: 'volumeId1~photoNodeId1',
+                contentHash: 'contentHash1',
+                nameHash: 'nameHash1',
+                originalNameHash: 'originalNameHash1',
+                encryptedName: 'encryptedName1',
+                nameSignatureEmail: 'nameSignatureEmail1',
+                nodePassphrase: 'nodePassphrase1',
+                nodePassphraseSignature: 'nodePassphraseSignature1',
+                signatureEmail: 'signatureEmail1',
+                relatedPhotos: [
+                    {
+                        nodeUid: 'volumeId1~photoNodeId2',
+                        contentHash: 'contentHash2',
+                        nameHash: 'nameHash2',
+                        originalNameHash: 'originalNameHash2',
+                        encryptedName: 'encryptedName2',
+                        nameSignatureEmail: 'nameSignatureEmail2',
+                        nodePassphrase: 'nodePassphrase2',
+                        nodePassphraseSignature: 'nodePassphraseSignature2',
+                        signatureEmail: 'signatureEmail2',
+                    },
+                ],
+            },
+        ];
+
+        it('should transfer photos', async () => {
+            apiMock.put = jest.fn().mockResolvedValue({
+                Code: 1000,
+                Responses: [
+                    {
+                        LinkID: 'photoNodeId1',
+                        Response: {
+                            Code: 1000,
+                        },
+                    },
+                ],
+            });
+
+            const result = await Array.fromAsync(api.transferPhotos(albumNodeUid, photoPayloads));
+
+            expect(result).toEqual([
+                {
+                    uid: 'volumeId1~photoNodeId1',
+                    ok: true,
+                },
+            ]);
+            expect(apiMock.put).toHaveBeenCalledWith(
+                `drive/photos/volumes/volumeId1/links/transfer-multiple`,
+                {
+                    ParentLinkID: 'albumNodeId',
+                    Links: [
+                        expect.objectContaining({
+                            LinkID: 'photoNodeId1',
+                            Hash: 'nameHash1',
+                            OriginalHash: 'originalNameHash1',
+                            Name: 'encryptedName1',
+                            NodePassphrase: 'nodePassphrase1',
+                            ContentHash: 'contentHash1',
+                            NodePassphraseSignature: null,
+                        }),
+                        expect.objectContaining({
+                            LinkID: 'photoNodeId2',
+                            Hash: 'nameHash2',
+                            OriginalHash: 'originalNameHash2',
+                            Name: 'encryptedName2',
+                            NodePassphrase: 'nodePassphrase2',
+                            ContentHash: 'contentHash2',
+                            NodePassphraseSignature: null,
+                        }),
+                    ],
+                    NameSignatureEmail: 'nameSignatureEmail1',
+                    SignatureEmail: null,
+                },
+                undefined,
+            );
+        });
+
+        it('should return MissingRelatedPhotosError if related photos are missing', async () => {
+            apiMock.put = jest.fn().mockResolvedValue({
+                Code: 1000,
+                Responses: [
+                    {
+                        LinkID: 'photoNodeId1',
+                        Response: {
+                            Code: 2000,
+                            Details: {
+                                Missing: ['photoNodeId3'],
+                            },
+                        },
+                    },
+                ],
+            });
+
+            const result = await Array.fromAsync(api.transferPhotos(albumNodeUid, photoPayloads));
+
+            expect(result).toEqual([
+                {
+                    uid: 'volumeId1~photoNodeId1',
+                    ok: false,
+                    error: new MissingRelatedPhotosError([]),
+                },
+            ]);
+            expect((result[0] as any).error.missingNodeUids).toEqual(['volumeId1~photoNodeId3']);
+        });
+
+        it('should return error for unknown error', async () => {
+            apiMock.put = jest.fn().mockResolvedValue({
+                Code: 1000,
+                Responses: [
+                    {
+                        LinkID: 'photoNodeId1',
+                        Response: {
+                            Code: 3000,
+                            Error: 'Some error',
+                        },
+                    },
+                ],
+            });
+
+            const result = await Array.fromAsync(api.transferPhotos(albumNodeUid, photoPayloads));
+
+            expect(result).toEqual([
+                {
+                    uid: 'volumeId1~photoNodeId1',
+                    ok: false,
+                    error: new APICodeError('Some error', 3000),
+                },
+            ]);
+        });
+
+        it('should throw if name signature emails differ', async () => {
+            const mixedPayloads = [
+                photoPayloads[0],
+                {
+                    ...photoPayloads[0],
+                    nodeUid: 'volumeId1~photoNodeIdOther',
+                    nameSignatureEmail: 'other@example.com',
+                    relatedPhotos: [],
+                },
+            ];
+
+            await expect(Array.fromAsync(api.transferPhotos(albumNodeUid, mixedPayloads))).rejects.toThrow(
+                'All photos must have the same name signature email',
+            );
+            expect(apiMock.put).not.toHaveBeenCalled();
+        });
+    });
 });

package/src/internal/photos/apiService.ts

@@ -1,12 +1,11 @@
 import { c } from 'ttag';
 
-import { ValidationError } from '../../errors';
 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 { AlbumContainsPhotosNotInTimelineError, MissingRelatedPhotosError } from './errors';
 import { AlbumItem } from './interface';
 import { TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 
@@ -82,6 +81,13 @@ type PostFavoritePhotoRequest = Extract<
     { content: object }
 >['content']['application/json'];
 
+type PutTransferPhotosRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/transfer-multiple']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PutTransferPhotosResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/links/transfer-multiple']['put']['responses']['200']['content']['application/json'];
+
 const ALBUM_CONTAINS_PHOTOS_NOT_IN_TIMELINE_ERROR_CODE = 200302;
 
 /**
@@ -336,7 +342,9 @@ export class PhotosAPIService {
             );
         } 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`);
+                const childLinkIds = (error.debug as { ChildLinkIDs: string[] })?.ChildLinkIDs || [];
+                const nodeUids = childLinkIds.map((linkId) => makeNodeUid(volumeId, linkId));
+                throw new AlbumContainsPhotosNotInTimelineError(error.message, error.code, nodeUids);
             }
             throw error;
         }
@@ -556,4 +564,85 @@ export class PhotosAPIService {
             requestBody,
         );
     }
+
+    async *transferPhotos(
+        newParentNodeUid: string,
+        photoPayloads: TransferEncryptedPhotoPayload[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResultWithError> {
+        const { volumeId, nodeId: newParentNodeId } = splitNodeUid(newParentNodeUid);
+
+        if (photoPayloads.length === 0) {
+            return;
+        }
+
+        const nameSignatureEmail = photoPayloads[0].nameSignatureEmail;
+        if (photoPayloads.some((photoPayload) => photoPayload.nameSignatureEmail !== nameSignatureEmail)) {
+            throw new Error('All photos must have the same name signature email');
+        }
+
+        const allPhotoPayloads = photoPayloads.flatMap((photoPayload) => [photoPayload, ...photoPayload.relatedPhotos]);
+        const allLinksData = allPhotoPayloads.map((photoPayload) => {
+            const { nodeId } = splitNodeUid(photoPayload.nodeUid);
+            return {
+                LinkID: nodeId,
+                Hash: photoPayload.nameHash,
+                OriginalHash: photoPayload.originalNameHash!,
+                Name: photoPayload.encryptedName,
+                NodePassphrase: photoPayload.nodePassphrase,
+                ContentHash: photoPayload.contentHash,
+                NodePassphraseSignature: null, // Required when moving an anonymous node.
+            };
+        });
+
+        const response = await this.apiService.put<PutTransferPhotosRequest, PutTransferPhotosResponse>(
+            `drive/photos/volumes/${volumeId}/links/transfer-multiple`,
+            {
+                ParentLinkID: newParentNodeId,
+                Links: allLinksData,
+                NameSignatureEmail: nameSignatureEmail,
+                SignatureEmail: null, // Required when moving an anonymous node.
+            },
+            signal,
+        );
+
+        const errors = new Map<string, Error>();
+
+        for (const r of response.Responses || []) {
+            const details = r as {
+                LinkID: string;
+                Response: {
+                    Code: number;
+                    Error?: string;
+                    Details: { Missing: string[] };
+                };
+            };
+
+            if (!details.Response.Code || !isCodeOk(details.Response.Code) || details.Response?.Error) {
+                const nodeUid = makeNodeUid(volumeId, details.LinkID);
+
+                if (details.Response.Details?.Missing) {
+                    const missingNodeUids = details.Response.Details.Missing.map((linkId) =>
+                        makeNodeUid(volumeId, linkId),
+                    );
+                    errors.set(nodeUid, new MissingRelatedPhotosError(missingNodeUids));
+                } else {
+                    errors.set(
+                        nodeUid,
+                        new APICodeError(details.Response.Error || c('Error').t`Unknown error`, details.Response.Code),
+                    );
+                }
+            }
+        }
+
+        for (const photoPayload of photoPayloads) {
+            const uid = photoPayload.nodeUid;
+            const error = errors.get(uid);
+            if (error) {
+                yield { uid, ok: false, error };
+            } else {
+                yield { uid, ok: true };
+            }
+        }
+    }
 }

package/src/internal/photos/errors.ts

@@ -1,5 +1,7 @@
 import { c } from 'ttag';
 
+import { ValidationError } from '../../errors';
+
 export class MissingRelatedPhotosError extends Error {
     constructor(public missingNodeUids: string[]) {
         // We do not want to leak the technical details of the error to the user.
@@ -9,3 +11,12 @@ export class MissingRelatedPhotosError extends Error {
         this.name = 'MissingRelatedPhotosError';
     }
 }
+
+export class AlbumContainsPhotosNotInTimelineError extends ValidationError {
+    public readonly photosOnlyInAlbumNodeUids: string[];
+
+    constructor(message: string, code: number, photosOnlyInAlbumNodeUids: string[]) {
+        super(message, code);
+        this.photosOnlyInAlbumNodeUids = photosOnlyInAlbumNodeUids;
+    }
+}

package/src/internal/photos/index.ts

@@ -62,8 +62,8 @@ export function initPhotosModule(
         photoShares,
         nodesService,
     );
-    const albums = new AlbumsManager(telemetry, api, albumsCryptoService, photoShares, nodesService);
     const photos = new PhotosManager(telemetry.getLogger('photos-update'), api, albumsCryptoService, nodesService);
+    const albums = new AlbumsManager(telemetry, api, albumsCryptoService, photoShares, nodesService, photos);
 
     return {
         timeline,

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

@@ -5,6 +5,7 @@ import { PhotosAPIService } from './apiService';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosNodesAccess } from './nodes';
 import { DecryptedPhotoNode } from './interface';
+import { MissingRelatedPhotosError } from './errors';
 
 function createMockPhotoNode(uid: string, overrides: Partial<DecryptedPhotoNode> = {}): DecryptedPhotoNode {
     return {
@@ -46,9 +47,19 @@ async function collectUpdateResults(manager: PhotosManager, photos: UpdatePhotoS
     return results;
 }
 
+async function collectSaveToTimelineResults(manager: PhotosManager, nodeUids: string[], signal?: AbortSignal) {
+    const results = [];
+    for await (const result of manager.saveToTimeline(nodeUids, signal)) {
+        results.push(result);
+    }
+    return results;
+}
+
 describe('PhotosManager', () => {
     let logger: ReturnType<typeof getMockLogger>;
-    let apiService: jest.Mocked<Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite'>>;
+    let apiService: jest.Mocked<
+        Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite' | 'transferPhotos'>
+    >;
     let cryptoService: jest.Mocked<Pick<AlbumsCryptoService, 'encryptPhotoForAlbum'>>;
     let nodesService: jest.Mocked<
         Pick<
@@ -80,6 +91,7 @@ describe('PhotosManager', () => {
             addPhotoTags: jest.fn().mockResolvedValue(undefined),
             removePhotoTags: jest.fn().mockResolvedValue(undefined),
             setPhotoFavorite: jest.fn().mockResolvedValue(undefined),
+            transferPhotos: jest.fn().mockImplementation(async function* () {}),
         };
 
         cryptoService = {
@@ -263,4 +275,34 @@ describe('PhotosManager', () => {
             });
         });
     });
+
+    describe('saveToTimeline', () => {
+        it('re-queues once on MissingRelatedPhotosError then succeeds without yielding the retry error', async () => {
+            const missingRelatedUid = 'volume1~related1';
+            let transferCall = 0;
+            apiService.transferPhotos.mockImplementation(async function* (_rootUid, payloads) {
+                transferCall++;
+                for (const payload of payloads) {
+                    if (transferCall === 1) {
+                        yield {
+                            uid: payload.nodeUid,
+                            ok: false,
+                            error: new MissingRelatedPhotosError([missingRelatedUid]),
+                        };
+                    } else {
+                        yield { uid: payload.nodeUid, ok: true };
+                    }
+                }
+            });
+
+            const results = await collectSaveToTimelineResults(manager, ['volume1~photo1']);
+
+            expect(results).toEqual([{ uid: 'volume1~photo1', ok: true }]);
+            expect(apiService.transferPhotos).toHaveBeenCalledTimes(2);
+            expect(logger.info).toHaveBeenCalledWith(
+                `Missing related photos for saving volume1~photo1, re-queuing: ${missingRelatedUid}`,
+            );
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
+        });
+    });
 });

package/src/internal/photos/photosManager.ts

@@ -1,13 +1,19 @@
 import { c } from 'ttag';
 
+import { AbortError } from '../../errors';
 import { Logger, NodeResultWithError, PhotoTag } from '../../interface';
+import { batch } from '../batch';
 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';
+import { createBatches } from './addToAlbum';
+import { MissingRelatedPhotosError } from './errors';
+
+/**
+ * The number of photos that are loaded in parallel to prepare the payloads.
+ */
+const BATCH_LOADING_SIZE = 20;
 
 export type UpdatePhotoSettings = {
     nodeUid: string;
@@ -31,6 +37,58 @@ export class PhotosManager {
         this.payloadBuilder = new PhotoTransferPayloadBuilder(albumsCryptoService, nodesService);
     }
 
+    async *saveToTimeline(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
+        const rootNode = await this.nodesService.getVolumeRootFolder();
+        const volumeRootKeys = await this.nodesService.getNodeKeys(rootNode.uid);
+        const signingKeys = await this.nodesService.getNodeSigningKeys({ nodeUid: rootNode.uid });
+
+        const queue: {
+            photoNodeUid: string;
+            additionalRelatedPhotoNodeUids: string[];
+        }[] = nodeUids.map((nodeUid) => ({ photoNodeUid: nodeUid, additionalRelatedPhotoNodeUids: [] }));
+        const retriedPhotoUids = new Set<string>();
+
+        while (queue.length > 0) {
+            const items = queue.splice(0, BATCH_LOADING_SIZE);
+            const { payloads, errors } = await this.payloadBuilder.preparePhotoPayloads(
+                items,
+                rootNode.uid,
+                volumeRootKeys,
+                signingKeys,
+                signal,
+            );
+
+            for (const [uid, error] of errors) {
+                yield { uid, ok: false, error };
+            }
+
+            for (const batch of createBatches(payloads)) {
+                for await (const result of this.apiService.transferPhotos(rootNode.uid, batch, signal)) {
+                    if (
+                        !result.ok &&
+                        result.error instanceof MissingRelatedPhotosError &&
+                        !retriedPhotoUids.has(result.uid)
+                    ) {
+                        retriedPhotoUids.add(result.uid);
+                        this.logger.info(
+                            `Missing related photos for saving ${result.uid}, re-queuing: ${result.error.missingNodeUids.join(', ')}`,
+                        );
+                        queue.push({
+                            photoNodeUid: result.uid,
+                            additionalRelatedPhotoNodeUids: result.error.missingNodeUids,
+                        });
+                        continue;
+                    }
+
+                    if (result.ok) {
+                        await this.nodesService.notifyNodeChanged(result.uid);
+                    }
+                    yield result;
+                }
+            }
+        }
+    }
+
     async *updatePhotos(photos: UpdatePhotoSettings[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
         for await (const {
             photoSettings: { nodeUid, tagsToAdd, tagsToRemove },

package/src/internal/photos/photosTransferPayloadBuilder.ts

@@ -14,12 +14,13 @@ type TransferEncryptedRelatedPhotoPayload = {
     nodeUid: string;
     contentHash: string;
     nameHash: string;
+    originalNameHash: string | undefined;
     encryptedName: string;
     nameSignatureEmail: string;
     nodePassphrase: string;
     nodePassphraseSignature?: string;
     signatureEmail?: string;
-}
+};
 
 /**
  * Item representing a photo to build a payload for.
@@ -186,6 +187,7 @@ export class PhotoTransferPayloadBuilder {
             nodeUid: photoNode.uid,
             contentHash: encryptedCrypto.contentHash,
             nameHash: encryptedCrypto.hash,
+            originalNameHash: photoNode.hash,
             encryptedName: encryptedCrypto.encryptedName,
             nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
             nodePassphrase: encryptedCrypto.armoredNodePassphrase,

package/src/internal/sharing/apiService.ts

@@ -79,12 +79,12 @@ type PostCreateShareResponse =
     drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
 
 type PostChangeSharePropertiesRequest = Extract<
-    drivePaths['/drive/shares/{shareID}/property']['post']['requestBody'],
+    drivePaths['/drive/shares/{shareID}/editors-can-share']['put']['requestBody'],
     { content: object }
 >['content']['application/json'];
 
 type PostChangeSharePropertiesResponse =
-    drivePaths['/drive/shares/{shareID}/property']['post']['responses']['200']['content']['application/json'];
+    drivePaths['/drive/shares/{shareID}/editors-can-share']['put']['responses']['200']['content']['application/json'];
 
 type PostInviteProtonUserRequest = Extract<
     drivePaths['/drive/v2/shares/{shareID}/invitations']['post']['requestBody'],
@@ -423,9 +423,9 @@ export class SharingAPIService {
     }
 
     async changeShareProperties(shareId: string, { editorsCanShare }: { editorsCanShare: boolean }) {
-        await this.apiService.post<PostChangeSharePropertiesRequest, PostChangeSharePropertiesResponse>(
-            `drive/shares/${shareId}/property`,
-            { EditorsCanShare: editorsCanShare },
+        await this.apiService.put<PostChangeSharePropertiesRequest, PostChangeSharePropertiesResponse>(
+            `drive/shares/${shareId}/editors-can-share`,
+            { Value: editorsCanShare },
         );
     }
 

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

@@ -133,7 +133,7 @@ describe('UploadManager', () => {
                 armoredEncryptedName: 'newNode:encryptedName',
                 hash: 'newNode:hash',
                 mediaType: 'myMimeType',
-                intendedUploadSize: 123456,
+                intendedUploadSize: 100_000,
                 armoredNodeKey: 'newNode:armoredKey',
                 armoredNodePassphrase: 'newNode:armoredPassphrase',
                 armoredNodePassphraseSignature: 'newNode:armoredPassphraseSignature',

package/src/internal/upload/manager.ts

@@ -9,6 +9,7 @@ import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
 import { NodeRevisionDraft, NodesService, NodeCrypto } from './interface';
 import { makeNodeUid, splitNodeUid } from '../uids';
+import { reduceSizePrecision } from '../../telemetry';
 
 /**
  * UploadManager is responsible for creating and deleting draft nodes
@@ -129,7 +130,7 @@ export class UploadManager {
                 armoredEncryptedName: generatedNodeCrypto.encryptedNode.encryptedName,
                 hash: generatedNodeCrypto.encryptedNode.hash,
                 mediaType: metadata.mediaType,
-                intendedUploadSize: metadata.expectedSize,
+                intendedUploadSize: reduceSizePrecision(metadata.expectedSize),
                 armoredNodeKey: generatedNodeCrypto.nodeKeys.encrypted.armoredKey,
                 armoredNodePassphrase: generatedNodeCrypto.nodeKeys.encrypted.armoredPassphrase,
                 armoredNodePassphraseSignature: generatedNodeCrypto.nodeKeys.encrypted.armoredPassphraseSignature,
@@ -349,7 +350,7 @@ export class UploadManager {
 
         const { nodeRevisionUid } = await this.apiService.createDraftRevision(nodeUid, {
             currentRevisionUid: node.activeRevision.value.uid,
-            intendedUploadSize: metadata.expectedSize,
+            intendedUploadSize: reduceSizePrecision(metadata.expectedSize),
         });
 
         return {

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

@@ -38,7 +38,9 @@ describe('UploadTelemetry', () => {
             eventName: 'upload',
             volumeType: 'own_volume',
             uploadedSize: 0,
+            approximateUploadedSize: 0,
             expectedSize: 1000,
+            approximateExpectedSize: 4095,
             error: 'unknown',
             originalError: error,
         });
@@ -52,7 +54,9 @@ describe('UploadTelemetry', () => {
             eventName: 'upload',
             volumeType: 'own_volume',
             uploadedSize: 500,
+            approximateUploadedSize: 4095,
             expectedSize: 1000,
+            approximateExpectedSize: 4095,
             error: 'unknown',
             originalError: error,
         });
@@ -65,7 +69,9 @@ describe('UploadTelemetry', () => {
             eventName: 'upload',
             volumeType: 'own_volume',
             uploadedSize: 1000,
+            approximateUploadedSize: 4095,
             expectedSize: 1000,
+            approximateExpectedSize: 4095,
         });
     });
 

package/src/internal/upload/telemetry.ts

@@ -1,6 +1,6 @@
 import { RateLimitedError, ValidationError, IntegrityError } from '../../errors';
-import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger } from '../../interface';
-import { LoggerWithPrefix } from '../../telemetry';
+import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger, MetricVolumeType } from '../../interface';
+import { LoggerWithPrefix, reduceSizePrecision } from '../../telemetry';
 import { APIHTTPError } from '../apiService';
 import { splitNodeUid, splitNodeRevisionUid } from '../uids';
 import { SharesService } from './interface';
@@ -85,7 +85,7 @@ export class UploadTelemetry {
             originalError?: unknown;
         },
     ) {
-        let volumeType;
+        let volumeType = MetricVolumeType.Unknown;
         try {
             volumeType = await this.sharesService.getVolumeMetricContext(volumeId);
         } catch (error: unknown) {
@@ -95,6 +95,8 @@ export class UploadTelemetry {
         this.telemetry.recordMetric({
             eventName: 'upload',
             volumeType,
+            approximateUploadedSize: reduceSizePrecision(options.uploadedSize),
+            approximateExpectedSize: reduceSizePrecision(options.expectedSize),
             ...options,
         });
     }

package/src/protonDrivePhotosClient.ts

@@ -559,9 +559,9 @@ export class ProtonDrivePhotosClient {
      *
      * 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.
+     * will throw an error. Then, either the photos must be saved to the
+     * timelines with `saveToTimeline` option, 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.
@@ -569,7 +569,7 @@ export class ProtonDrivePhotosClient {
      * @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> {
+    async deleteAlbum(nodeUid: NodeOrUid, options: { force?: boolean; saveToTimeline?: boolean } = {}): Promise<void> {
         this.logger.info(`Deleting album ${getUid(nodeUid)}`);
         await this.photos.albums.deleteAlbum(getUid(nodeUid), options);
     }