@protontech/drive-sdk 0.9.6 → 0.9.8

package/src/internal/upload/streamUploader.ts

@@ -219,13 +219,14 @@ export class StreamUploader {
     }
 
     protected async commitFile(thumbnails: Thumbnail[]) {
-        this.verifyIntegrity(thumbnails);
+        const digests = this.digests.digests();
+        this.verifyIntegrity(thumbnails, digests);
 
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
             size: this.metadata.expectedSize,
             blockSizes: this.uploadedBlockSizes,
-            digests: this.digests.digests(),
+            digests,
         };
         await this.uploadManager.commitDraft(
             this.revisionDraft,
@@ -607,7 +608,7 @@ export class StreamUploader {
         }
     }
 
-    protected verifyIntegrity(thumbnails: Thumbnail[]) {
+    protected verifyIntegrity(thumbnails: Thumbnail[], digests: { sha1: string }) {
         const expectedBlockCount =
             Math.ceil(this.metadata.expectedSize / FILE_CHUNK_SIZE) + (thumbnails ? thumbnails?.length : 0);
         if (this.uploadedBlockCount !== expectedBlockCount) {
@@ -622,6 +623,12 @@ export class StreamUploader {
                 expectedFileSize: this.metadata.expectedSize,
             });
         }
+        if (this.metadata.expectedSha1 && digests.sha1 !== this.metadata.expectedSha1) {
+            throw new IntegrityError(c('Error').t`File hash does not match expected hash`, {
+                uploadedSha1: digests.sha1,
+                expectedSha1: this.metadata.expectedSha1,
+            });
+        }
     }
 
     /**

package/src/protonDrivePhotosClient.ts

@@ -117,7 +117,13 @@ export class ProtonDrivePhotosClient {
             this.photoShares,
             fullConfig.clientUid,
         );
-        this.photos = initPhotosModule(telemetry, apiService, cryptoModule, this.photoShares, this.nodes.access);
+        this.photos = initPhotosModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            this.photoShares,
+            this.nodes.access,
+        );
         this.sharing = initSharingModule(
             telemetry,
             apiService,
@@ -299,13 +305,11 @@ export class ProtonDrivePhotosClient {
     }
 
     /**
-     * Empty the trash.
-     *
-     * See `ProtonDriveClient.emptyTrash` for more information.
+     * Empty the trash for the photos volume.
      */
     async emptyTrash(): Promise<void> {
-        this.logger.info('Emptying trash');
-        throw new Error('Method not implemented');
+        this.logger.info('Emptying photo volume trash');
+        return this.nodes.management.emptyTrash();
     }
 
     /**
@@ -509,6 +513,63 @@ export class ProtonDrivePhotosClient {
         return this.photos.timeline.findPhotoDuplicates(name, generateSha1, signal);
     }
 
+    /**
+     * Creates a new album with the given name.
+     *
+     * @param name - The name for the new album.
+     * @returns The created album node.
+     */
+    async createAlbum(name: string): Promise<MaybePhotoNode> {
+        this.logger.info('Creating album');
+        return convertInternalPhotoNodePromise(this.photos.albums.createAlbum(name));
+    }
+
+    /**
+     * Updates an existing album.
+     *
+     * Updates can include a new name and/or a cover photo.
+     *
+     * @param nodeUid - The UID of the album to edit.
+     * @param updates - The updates to apply.
+     * @returns The updated album node.
+     */
+    async updateAlbum(
+        nodeUid: NodeOrUid,
+        updates: {
+            name?: string;
+            coverPhotoNodeUid?: NodeOrUid;
+        },
+    ): Promise<MaybePhotoNode> {
+        this.logger.info(`Updating album ${getUid(nodeUid)}`);
+        const coverPhotoNodeUid = updates.coverPhotoNodeUid ? getUid(updates.coverPhotoNodeUid) : undefined;
+        return convertInternalPhotoNodePromise(
+            this.photos.albums.updateAlbum(getUid(nodeUid), {
+                name: updates.name,
+                coverPhotoNodeUid,
+            }),
+        );
+    }
+
+    /**
+     * Deletes an album.
+     *
+     * 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.
+     *
+     * This operation is irreversible. Both the album and the photos will be
+     * permanently deleted, skipping the trash.
+     *
+     * @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> {
+        this.logger.info(`Deleting album ${getUid(nodeUid)}`);
+        await this.photos.albums.deleteAlbum(getUid(nodeUid), options);
+    }
+
     /**
      * Iterates the albums.
      *

package/src/protonDrivePublicLinkClient.ts

@@ -70,6 +70,12 @@ export class ProtonDrivePublicLinkClient {
          * This is used by Docs app to encrypt and decrypt document updates.
          */
         getDocsKey: (nodeUid: NodeOrUid) => Promise<SessionKey>;
+        /**
+         * Experimental feature to get the passphrase for a node.
+         *
+         * This is used by public link page to report abuse.
+         */
+        getNodePassphrase: (nodeUid: NodeOrUid) => Promise<string>;
         /**
          * Experimental feature to check if hashes match the malware database.
          */
@@ -175,6 +181,14 @@ export class ProtonDrivePublicLinkClient {
                 }
                 return keys.contentKeyPacketSessionKey;
             },
+            getNodePassphrase: async (nodeUid: NodeOrUid) => {
+                this.logger.debug(`Getting node passphrase for ${getUid(nodeUid)}`);
+                const keys = await this.sharingPublic.nodes.access.getNodeKeys(getUid(nodeUid));
+                if (!keys.passphrase) {
+                    throw new Error('Node does not have a passphrase');
+                }
+                return keys.passphrase
+            },
             scanHashes: async (hashes: string[]): Promise<NodesSecurityScanResult> => {
                 this.logger.debug(`Scanning ${hashes.length} hashes`);
                 return this.sharingPublic.nodes.security.scanHashes(hashes);