@protontech/drive-sdk 0.7.2 → 0.8.0

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

@@ -45,15 +45,15 @@ describe('PhotosTimeline', () => {
         timeline = new PhotosTimeline(logger, apiService, driveCrypto, photoShares, nodesService);
     });
 
-    describe('isDuplicatePhoto', () => {
+    describe('findPhotoDuplicates', () => {
         it('should not call sha1 callback when there is no name hash match', async () => {
             const generateSha1 = jest.fn();
             apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue([]);
             driveCrypto.generateLookupHash = jest.fn().mockResolvedValue(nameHash);
 
-            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+            const result = await timeline.findPhotoDuplicates(name, generateSha1);
 
-            expect(result).toBe(false);
+            expect(result).toEqual([]);
             expect(generateSha1).not.toHaveBeenCalled();
             expect(photoShares.getRootIDs).toHaveBeenCalled();
             expect(nodesService.getNodeKeys).toHaveBeenCalledWith(rootNodeUid);
@@ -76,9 +76,9 @@ describe('PhotosTimeline', () => {
                 .mockResolvedValueOnce(nameHash)
                 .mockResolvedValueOnce(contentHash);
 
-            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+            const result = await timeline.findPhotoDuplicates(name, generateSha1);
 
-            expect(result).toBe(false);
+            expect(result).toEqual([]);
             expect(generateSha1).toHaveBeenCalledTimes(1);
             expect(driveCrypto.generateLookupHash).toHaveBeenCalledTimes(2);
             expect(driveCrypto.generateLookupHash).toHaveBeenNthCalledWith(1, name, hashKey);
@@ -102,15 +102,47 @@ describe('PhotosTimeline', () => {
                 .mockResolvedValueOnce(nameHash)
                 .mockResolvedValueOnce(contentHash);
 
-            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+            const result = await timeline.findPhotoDuplicates(name, generateSha1);
 
-            expect(result).toBe(true);
+            expect(result).toEqual([nodeUid1]);
             expect(generateSha1).toHaveBeenCalledTimes(1);
             expect(logger.debug).toHaveBeenCalledTimes(1);
             expect(logger.debug).toHaveBeenCalledWith(
                 `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUid1}`,
             );
         });
+
+        it('should return multiple node UIDs when multiple duplicates match', async () => {
+            const generateSha1 = jest.fn().mockResolvedValue(sha1);
+            const nodeUid1 = 'volumeId~node1';
+            const nodeUid2 = 'volumeId~node2';
+            const duplicates = [
+                {
+                    nameHash: nameHash,
+                    contentHash: contentHash,
+                    nodeUid: nodeUid1,
+                },
+                {
+                    nameHash: nameHash,
+                    contentHash: contentHash,
+                    nodeUid: nodeUid2,
+                },
+            ];
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue(duplicates);
+            driveCrypto.generateLookupHash = jest
+                .fn()
+                .mockResolvedValueOnce(nameHash)
+                .mockResolvedValueOnce(contentHash);
+
+            const result = await timeline.findPhotoDuplicates(name, generateSha1);
+
+            expect(result).toEqual([nodeUid1, nodeUid2]);
+            expect(generateSha1).toHaveBeenCalledTimes(1);
+            expect(logger.debug).toHaveBeenCalledTimes(1);
+            expect(logger.debug).toHaveBeenCalledWith(
+                `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUid1},${nodeUid2}`,
+            );
+        });
     });
 });
 

package/src/internal/photos/timeline.ts

@@ -32,7 +32,7 @@ export class PhotosTimeline {
         yield* this.apiService.iterateTimeline(volumeId, signal);
     }
 
-    async isDuplicatePhoto(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<boolean> {
+    async findPhotoDuplicates(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<string[]> {
         const { volumeId, rootNodeId } = await this.photoShares.getRootIDs();
         const rootNodeUid = makeNodeUid(volumeId, rootNodeId);
         const { hashKey } = await this.nodesService.getNodeKeys(rootNodeUid);
@@ -44,7 +44,7 @@ export class PhotosTimeline {
         const duplicates = await this.apiService.checkPhotoDuplicates(volumeId, [nameHash], signal);
 
         if (duplicates.length === 0) {
-            return false;
+            return [];
         }
 
         // Generate the SHA1 only when there is any matching node hash to avoid
@@ -57,13 +57,13 @@ export class PhotosTimeline {
         );
 
         if (matchingDuplicates.length === 0) {
-            return false;
+            return [];
         }
 
         const nodeUids = matchingDuplicates.map((duplicate) => duplicate.nodeUid);
         this.logger.debug(
             `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUids}`,
         );
-        return true;
+        return nodeUids;
     }
 }

package/src/internal/shares/apiService.ts

@@ -173,7 +173,7 @@ function convertSharePayload(response: GetShareResponse): EncryptedShare {
     };
 }
 
-function convertShareTypeNumberToEnum(type: 1 | 2 | 3 | 4): ShareType {
+function convertShareTypeNumberToEnum(type: 1 | 2 | 3 | 4 | 5): ShareType {
     switch (type) {
         case 1:
             return ShareType.Main;
@@ -183,5 +183,7 @@ function convertShareTypeNumberToEnum(type: 1 | 2 | 3 | 4): ShareType {
             return ShareType.Device;
         case 4:
             return ShareType.Photo;
+        case 5:
+            throw new Error('Organization shares are not supported yet');
     }
 }

package/src/internal/sharingPublic/nodes.ts

@@ -87,10 +87,10 @@ export class SharingPublicNodesManagement extends NodesManagement {
         super(apiService, cryptoCache, cryptoService, nodesAccess);
     }
 
-    async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *deleteMyNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         // Public link does not support trashing and deleting trashed nodes.
         // Instead, if user is owner, API allows directly deleting existing nodes.
-        for await (const result of this.apiService.deleteExistingNodes(nodeUids, signal)) {
+        for await (const result of this.apiService.deleteMyNodes(nodeUids, signal)) {
             if (result.ok) {
                 await this.nodesAccess.notifyNodeDeleted(result.uid);
             }

package/src/protonDriveClient.ts

@@ -495,7 +495,7 @@ export class ProtonDriveClient {
     }
 
     /**
-     * Delete the nodes permanently.
+     * Delete the trashed nodes permanently. Only the owner can do that.
      *
      * The operation is performed in batches and the results are yielded
      * as they are available. Order of the results is not guaranteed.
@@ -509,7 +509,7 @@ export class ProtonDriveClient {
      */
     async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Deleting ${nodeUids.length} nodes`);
-        yield* this.nodes.management.deleteNodes(getUids(nodeUids), signal);
+        yield* this.nodes.management.deleteTrashedNodes(getUids(nodeUids), signal);
     }
 
     async emptyTrash(): Promise<void> {

package/src/protonDrivePhotosClient.ts

@@ -295,7 +295,7 @@ export class ProtonDrivePhotosClient {
      */
     async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Deleting ${nodeUids.length} nodes`);
-        yield* this.nodes.management.deleteNodes(getUids(nodeUids), signal);
+        yield * this.nodes.management.deleteTrashedNodes(getUids(nodeUids), signal);
     }
 
     /**
@@ -479,10 +479,34 @@ export class ProtonDrivePhotosClient {
      * @param generateSha1 - A callback to generate the hex string representation of the SHA1 of the photo content.
      * @param signal - An optional abort signal to cancel the operation.
      * @returns True if the photo already exists in the timeline, false otherwise.
+     * @deprecated Use `findPhotoDuplicates` instead to get the node UIDs of duplicate photos.
      */
     async isDuplicatePhoto(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<boolean> {
         this.logger.info(`Checking if photo is a duplicate`);
-        return this.photos.timeline.isDuplicatePhoto(name, generateSha1, signal);
+        return this.photos.timeline.findPhotoDuplicates(name, generateSha1, signal).then(nodeUids => nodeUids.length !== 0);
+    }
+
+    /**
+     * Find duplicate photos by name and content.
+     *
+     * For given photo name, find existing photos with the same name
+     * in the timeline and check if the photo content is also the same.
+     * Only the same name is not considered as duplicate photo because
+     * it is expected that there are photos with the same name (e.g.,
+     * date as a name from multiple cameras, or rolling number).
+     *
+     * The function accepts a callback to generate the SHA1 and it is
+     * called only when there is any matching node name hash to avoid
+     * computation for every node if its not necessary.
+     *
+     * @param name - The name of the photo to check for duplicates.
+     * @param generateSha1 - A callback to generate the hex string representation of the SHA1 of the photo content.
+     * @param signal - An optional abort signal to cancel the operation.
+     * @returns An array of node UIDs of duplicate photos. Empty array if no duplicates found.
+     */
+    async findPhotoDuplicates(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<string[]> {
+        this.logger.info(`Checking if photo have duplicates`);
+        return this.photos.timeline.findPhotoDuplicates(name, generateSha1, signal);
     }
 
     /**

package/src/protonDrivePublicLinkClient.ts

@@ -233,13 +233,15 @@ export class ProtonDrivePublicLinkClient {
     }
 
     /**
-     * Delete the nodes permanently.
+     * Delete own nodes permanently. It skips the trash and allows to delete
+     * only nodes that are owned by the user. For anonymous files, this method
+     * allows to delete them only in the same session.
      *
      * See `ProtonDriveClient.deleteNodes` for more information.
      */
     async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Deleting ${nodeUids.length} nodes`);
-        yield* this.sharingPublic.nodes.management.deleteNodes(getUids(nodeUids), signal);
+        yield* this.sharingPublic.nodes.management.deleteMyNodes(getUids(nodeUids), signal);
     }
 
     /**