@protontech/drive-sdk 0.8.0 → 0.9.0

package/src/internal/download/fileDownloader.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
 import { PrivateKey, SessionKey, base64StringToUint8Array } from '../../crypto';
-import { AbortError } from '../../errors';
+import { AbortError, IntegrityError } from '../../errors';
 import { Logger } from '../../interface';
 import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
@@ -10,7 +10,7 @@ import { DownloadAPIService } from './apiService';
 import { getBlockIndex } from './blockIndex';
 import { DownloadController } from './controller';
 import { DownloadCryptoService } from './cryptoService';
-import { BlockMetadata, RevisionKeys } from './interface';
+import { BlockMetadata, RevisionKeys, SignatureVerificationError } from './interface';
 import { BufferedSeekableStream } from './seekableStream';
 import { DownloadTelemetry } from './telemetry';
 
@@ -233,13 +233,17 @@ export class FileDownloader {
                 );
             }
 
-            await writer.close();
             void this.telemetry.downloadFinished(this.revision.uid, fileProgress);
             this.logger.info(`Download succeeded`);
         } catch (error: unknown) {
-            this.logger.error(`Download failed`, error);
+            if (error instanceof SignatureVerificationError) {
+                this.logger.warn(`Download finished with signature verification issues`);
+                this.controller.setIsDownloadCompleteWithSignatureIssues(true);
+                error = new IntegrityError(error.message, error.debug, { cause: error });
+            } else {
+                this.logger.error(`Download failed`, error);
+            }
             void this.telemetry.downloadFailed(this.revision.uid, error, fileProgress, this.getClaimedSizeInBytes());
-            await writer.abort?.();
             throw error;
         } finally {
             this.logger.debug(`Download cleanup`);

package/src/internal/download/interface.ts

@@ -1,4 +1,5 @@
 import { PrivateKey, PublicKey, SessionKey } from '../../crypto';
+import { IntegrityError } from '../../errors';
 import { NodeType, Result, MissingNode, MetricVolumeType } from '../../interface';
 import { DecryptedNode, DecryptedRevision } from '../nodes';
 
@@ -35,3 +36,17 @@ export interface NodesServiceNode {
 export interface RevisionsService {
     getRevision(nodeRevisionUid: string): Promise<DecryptedRevision>;
 }
+
+/**
+ * Error thrown when the manifest signature verification fails.
+ * This is a special case that is reported as download complete with signature
+ * issues. The client must then ask the user to agree to save the file anyway
+ * or abort and clean up the file.
+ *
+ * This error is not exposed to the client. It is only used internally to track
+ * the signature verification issues. For the client it must be reported as
+ * the IntegrityError.
+ */
+export class SignatureVerificationError extends IntegrityError {
+    name = 'SignatureVerificationError';
+}

package/src/internal/nodes/apiService.ts

@@ -57,6 +57,9 @@ type PostCopyNodeRequest = Extract<
 type PostCopyNodeResponse =
     drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['responses']['200']['content']['application/json'];
 
+type EmptyTrashResponse =
+    drivePaths['/drive/volumes/{volumeID}/trash']['delete']['responses']['200']['content']['application/json'];
+
 type PostTrashNodesRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['requestBody'],
     { content: object }
@@ -436,6 +439,10 @@ export abstract class NodeAPIServiceBase<
         }
     }
 
+    async emptyTrash(volumeId: string): Promise<void> {
+        await this.apiService.delete<EmptyTrashResponse>(`drive/volumes/${volumeId}/trash`);
+    }
+
     async *restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for (const { volumeId, batchNodeIds, batchNodeUids } of groupNodeUidsByVolumeAndIteratePerBatch(nodeUids)) {
             const response = await this.apiService.put<PutRestoreNodesRequest, PutRestoreNodesResponse>(

package/src/internal/nodes/nodesManagement.ts

@@ -127,6 +127,12 @@ export abstract class NodesManagementBase<
         }
     }
 
+    async emptyTrash(): Promise<void> {
+        const node = await this.nodesAccess.getVolumeRootFolder();
+        const { volumeId } = splitNodeUid(node.uid);
+        await this.apiService.emptyTrash(volumeId);
+    }
+
     async moveNode(nodeUid: string, newParentUid: string): Promise<TDecryptedNode> {
         const node = await this.nodesAccess.getNode(nodeUid);
 

package/src/internal/upload/apiService.ts

@@ -45,6 +45,13 @@ type PostDeleteNodesRequest = Extract<
 type PostDeleteNodesResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/delete_multiple']['post']['responses']['200']['content']['application/json'];
 
+type PostLoadLinksMetadataRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostLoadLinksMetadataResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
+
 export class UploadAPIService {
     constructor(
         protected apiService: DriveAPIService,
@@ -262,4 +269,22 @@ export class UploadAPIService {
 
         await this.apiService.postBlockStream(url, token, formData, onProgress, signal);
     }
+
+    async isRevisionUploaded(nodeRevisionUid: string): Promise<boolean> {
+        const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
+        const result = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(
+            `drive/v2/volumes/${volumeId}/links`,
+            {
+                LinkIDs: [nodeId],
+            },
+        );
+        if (result.Links.length === 0) {
+            return false;
+        }
+        const link = result.Links[0];
+        return (
+            link.Link.State === 1 && // ACTIVE state
+            link.File?.ActiveRevision?.RevisionID === revisionId
+        );
+    }
 }

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

@@ -327,5 +327,42 @@ describe('UploadManager', () => {
             expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('parentUid');
             expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
         });
+
+        it('should ignore error if revision was committed successfully', async () => {
+            apiService.commitDraftRevision = jest
+                .fn()
+                .mockRejectedValue(new Error('Revision to commit must be a draft'));
+            apiService.isRevisionUploaded = jest.fn().mockResolvedValue(true);
+
+            await manager.commitDraft(nodeRevisionDraft as any, manifest, extendedAttributes);
+
+            expect(apiService.commitDraftRevision).toHaveBeenCalledWith(
+                nodeRevisionDraft.nodeRevisionUid,
+                expect.anything(),
+            );
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalled();
+        });
+
+        it('should throw error if revision was not committed successfully', async () => {
+            apiService.commitDraftRevision = jest
+                .fn()
+                .mockRejectedValue(new Error('Revision to commit must be a draft'));
+            apiService.isRevisionUploaded = jest.fn().mockResolvedValue(false);
+
+            await expect(manager.commitDraft(nodeRevisionDraft as any, manifest, extendedAttributes)).rejects.toThrow(
+                'Revision to commit must be a draft',
+            );
+            expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+        });
+
+        it('should throw original error if revision cannot be verified', async () => {
+            apiService.commitDraftRevision = jest.fn().mockRejectedValue(new Error('Failed to commit revision'));
+            apiService.isRevisionUploaded = jest.fn().mockRejectedValue(new Error('Failed to verify revision'));
+
+            await expect(manager.commitDraft(nodeRevisionDraft as any, manifest, extendedAttributes)).rejects.toThrow(
+                'Failed to commit revision',
+            );
+            expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+        });
     });
 });

package/src/internal/upload/manager.ts

@@ -246,7 +246,23 @@ export class UploadManager {
             manifest,
             generatedExtendedAttributes,
         );
-        await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
+        try {
+            await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
+        } catch (error: unknown) {
+            // Commit might be sent but due to network error no response is
+            // received. In this case, API service automatically retries the
+            // request. If the first attempt passed, it will fail on the second
+            // attempt. We need to check if the revision was actually committed.
+            try {
+                const isRevisionUploaded = await this.apiService.isRevisionUploaded(nodeRevisionDraft.nodeRevisionUid);
+                if (!isRevisionUploaded) {
+                    throw error;
+                }
+            } catch {
+                throw error; // Throw original error, not the checking one.
+            }
+            this.logger.warn(`Node commit failed but node was committed successfully ${nodeRevisionDraft.nodeUid}`);
+        }
         await this.notifyNodeUploaded(nodeRevisionDraft);
     }
 

package/src/internal/upload/streamUploader.ts

@@ -181,7 +181,7 @@ export class StreamUploader {
             await this.controller.waitWhilePaused();
             await this.waitForUploadCapacityAndBufferedBlocks();
 
-            if (this.isEncryptionFullyFinished) {
+            if (this.isEncryptionFullyFinished || this.isUploadAborted) {
                 break;
             }
 

package/src/protonDriveClient.ts

@@ -514,7 +514,7 @@ export class ProtonDriveClient {
 
     async emptyTrash(): Promise<void> {
         this.logger.info('Emptying trash');
-        throw new Error('Method not implemented');
+        return this.nodes.management.emptyTrash();
     }
 
     /**