@protontech/drive-sdk 0.13.1 → 0.14.1

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/sharingPublic/session/index.ts

@@ -1 +1,2 @@
 export { SharingPublicSessionManager } from './manager';
+export { SharingPublicLinkSession } from './session';

package/src/internal/sharingPublic/session/manager.ts

@@ -87,6 +87,7 @@ export class SharingPublicSessionManager {
         shareKey: PrivateKey;
         rootUid: string;
         publicRole: MemberRole;
+        session: SharingPublicLinkSession;
     }> {
         let info = this.infosPerToken.get(token);
         if (!info) {
@@ -105,6 +106,7 @@ export class SharingPublicSessionManager {
             shareKey,
             rootUid,
             publicRole: permissionsToMemberRole(this.logger, encryptedShare.publicPermissions),
+            session,
         };
     }
 

package/src/internal/upload/telemetry.ts

@@ -1,5 +1,5 @@
 import { RateLimitedError, ValidationError, IntegrityError } from '../../errors';
-import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger } from '../../interface';
+import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger, MetricVolumeType } from '../../interface';
 import { LoggerWithPrefix, reduceSizePrecision } from '../../telemetry';
 import { APIHTTPError } from '../apiService';
 import { splitNodeUid, splitNodeRevisionUid } from '../uids';
@@ -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) {

package/src/protonDriveClient.ts

@@ -232,7 +232,7 @@ export class ProtonDriveClient {
                 const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url);
                 this.logger.info(`Authenticating public link token ${token}`);
 
-                const { httpClient, shareKey, rootUid, publicRole } = await this.publicSessionManager.auth(
+                const { httpClient, shareKey, rootUid, publicRole, session } = await this.publicSessionManager.auth(
                     token,
                     urlPassword,
                     customPassword,
@@ -250,6 +250,7 @@ export class ProtonDriveClient {
                     publicRootNodeUid: rootUid,
                     isAnonymousContext,
                     publicRole,
+                    session,
                 });
             },
         };

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