@protontech/drive-sdk 0.13.1 → 0.14.0

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