@protontech/drive-sdk 0.4.1 → 0.5.1

package/src/internal/upload/fileUploader.ts

@@ -43,10 +43,10 @@ class Uploader {
             });
         }
 
-        this.controller = new UploadController();
+        this.controller = new UploadController(this.abortController.signal);
     }
 
-    async writeFile(
+    async uploadFromFile(
         fileObject: File,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -67,7 +67,7 @@ class Uploader {
         return this.controller;
     }
 
-    async writeStream(
+    async uploadFromStream(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -83,7 +83,7 @@ class Uploader {
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
-    ): Promise<string> {
+    ): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         const uploader = await this.initStreamUploader();
         return uploader.start(stream, thumbnails, onProgress);
     }
@@ -119,7 +119,8 @@ class Uploader {
             revisionDraft,
             this.metadata,
             onFinish,
-            this.signal,
+            this.controller,
+            this.abortController,
         );
     }
 

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

@@ -108,6 +108,7 @@ describe('StreamUploader', () => {
 
         revisionDraft = {
             nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid',
             nodeKeys: {
                 signatureAddress: { addressId: 'addressId' },
             },
@@ -131,7 +132,8 @@ describe('StreamUploader', () => {
             revisionDraft,
             metadata,
             onFinish,
-            abortController.signal,
+            controller,
+            abortController,
         );
     });
 
@@ -143,7 +145,12 @@ describe('StreamUploader', () => {
         let stream: ReadableStream<Uint8Array>;
 
         const verifySuccess = async () => {
-            await uploader.start(stream, thumbnails, onProgress);
+            const result = await uploader.start(stream, thumbnails, onProgress);
+
+            expect(result).toEqual({
+                nodeRevisionUid: 'revisionUid',
+                nodeUid: 'nodeUid',
+            });
 
             const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
             expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
@@ -251,6 +258,8 @@ describe('StreamUploader', () => {
                 revisionDraft,
                 metadata,
                 onFinish,
+                controller,
+                abortController,
             );
 
             await verifySuccess();
@@ -278,6 +287,8 @@ describe('StreamUploader', () => {
                 revisionDraft,
                 metadata,
                 onFinish,
+                controller,
+                abortController,
             );
 
             await verifySuccess();
@@ -422,14 +433,6 @@ describe('StreamUploader', () => {
             await verifyOnProgress([1024, 4 * 1024 * 1024, 2 * 1024 * 1024, 4 * 1024 * 1024]);
         });
 
-        it('should handle abortion', async () => {
-            const error = new Error('Aborted');
-            const promise = uploader.start(stream, thumbnails, onProgress);
-            abortController.abort(error);
-            await promise;
-            expect(apiService.uploadBlock.mock.calls[0][4]?.aborted).toBe(true);
-        });
-
         describe('verifyIntegrity', () => {
             it('should report block verification error', async () => {
                 blockVerifier.verifyBlock = jest.fn().mockRejectedValue(new IntegrityError('Block verification error'));
@@ -459,9 +462,10 @@ describe('StreamUploader', () => {
                     {
                         // Fake expected size to break verification
                         expectedSize: 1 * 1024 * 1024 + 1024,
-                        mediaType: '',
-                    },
+                    } as UploadMetadata,
                     onFinish,
+                    controller,
+                    abortController,
                 );
 
                 await verifyFailure(
@@ -486,4 +490,44 @@ describe('StreamUploader', () => {
             });
         });
     });
+
+    describe('abort', () => {
+        const thumbnails: Thumbnail[] = [];
+        let stream: ReadableStream<Uint8Array>;
+        let streamController: ReadableStreamDefaultController<Uint8Array>;
+
+        beforeEach(() => {
+            stream = new ReadableStream({
+                start(controller) {
+                    streamController = controller;
+                },
+            });
+        });
+
+        it('should abort at the start', async () => {
+            const promise = uploader.start(stream, thumbnails);
+            abortController.abort();
+            await expect(promise).rejects.toThrow('Operation aborted');
+        });
+
+        it('should abort when encrypting blocks', async () => {
+            const promise = uploader.start(stream, thumbnails);
+            streamController.enqueue(new Uint8Array(FILE_CHUNK_SIZE));
+            streamController.enqueue(new Uint8Array(FILE_CHUNK_SIZE));
+            streamController.enqueue(new Uint8Array(FILE_CHUNK_SIZE));
+            abortController.abort();
+            await expect(promise).rejects.toThrow('Operation aborted');
+        });
+
+        it('should abort when uploading block', async () => {
+            apiService.uploadBlock = jest.fn().mockImplementation(async function () {
+                abortController.abort();
+            });
+
+            const promise = uploader.start(stream, thumbnails);
+            streamController.enqueue(new Uint8Array(FILE_CHUNK_SIZE));
+
+            await expect(promise).rejects.toThrow('Operation aborted');
+        });
+    });
 });

package/src/internal/upload/streamUploader.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
 import { Thumbnail, Logger, ThumbnailType, UploadMetadata } from '../../interface';
-import { IntegrityError } from '../../errors';
+import { AbortError, IntegrityError } from '../../errors';
 import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode, NotFoundAPIError } from '../apiService';
 import { getErrorMessage } from '../errors';
@@ -59,7 +59,6 @@ export class StreamUploader {
 
     protected digests: UploadDigests;
     protected controller: UploadController;
-    protected abortController: AbortController;
 
     protected encryptedThumbnails = new Map<ThumbnailType, EncryptedThumbnail>();
     protected encryptedBlocks = new Map<number, EncryptedBlock>();
@@ -75,6 +74,9 @@ export class StreamUploader {
     protected uploadedThumbnails: ({ type: ThumbnailType } & EncryptedBlockMetadata)[] = [];
     protected uploadedBlocks: ({ index: number } & EncryptedBlockMetadata)[] = [];
 
+    // Error of the whole upload - either encryption or upload error.
+    protected error: unknown | undefined;
+
     constructor(
         protected telemetry: UploadTelemetry,
         protected apiService: UploadAPIService,
@@ -84,7 +86,8 @@ export class StreamUploader {
         protected revisionDraft: NodeRevisionDraft,
         protected metadata: UploadMetadata,
         protected onFinish: (failure: boolean) => Promise<void>,
-        protected signal?: AbortSignal,
+        protected uploadController: UploadController,
+        protected abortController: AbortController,
     ) {
         this.telemetry = telemetry;
         this.logger = telemetry.getLoggerForRevision(revisionDraft.nodeRevisionUid);
@@ -95,23 +98,16 @@ export class StreamUploader {
         this.metadata = metadata;
         this.onFinish = onFinish;
 
-        this.signal = signal;
-        this.abortController = new AbortController();
-        if (signal) {
-            signal.addEventListener('abort', () => {
-                this.abortController.abort();
-            });
-        }
-
         this.digests = new UploadDigests();
-        this.controller = new UploadController();
+        this.controller = uploadController;
+        this.abortController = abortController;
     }
 
     async start(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
-    ): Promise<string> {
+    ): Promise<{ nodeRevisionUid: string; nodeUid: string }> {
         let failure = false;
 
         // File progress is tracked for telemetry - to track at what
@@ -154,7 +150,10 @@ export class StreamUploader {
             await this.onFinish(failure);
         }
 
-        return this.revisionDraft.nodeRevisionUid;
+        return {
+            nodeRevisionUid: this.revisionDraft.nodeRevisionUid,
+            nodeUid: this.revisionDraft.nodeUid,
+        };
     }
 
     private async encryptAndUploadBlocks(
@@ -178,8 +177,8 @@ export class StreamUploader {
             void this.abortUpload(error);
         });
 
-        while (!encryptionError) {
-            await this.controller.waitIfPaused();
+        while (!this.isUploadAborted) {
+            await this.controller.waitWhilePaused();
             await this.waitForUploadCapacityAndBufferedBlocks();
 
             if (this.isEncryptionFullyFinished) {
@@ -193,6 +192,17 @@ export class StreamUploader {
             }
         }
 
+        // If the upload was aborted due to encryption or upload error, throw
+        // the original error (it is failing upload).
+        // If the upload was aborted due to abort signal, throw AbortError
+        // (it is aborted by the user).
+        if (this.error) {
+            throw this.error;
+        }
+        if (this.abortController.signal.aborted) {
+            throw new AbortError();
+        }
+
         this.logger.debug(`All blocks uploading, waiting for them to finish`);
         // Technically this is finished as while-block above will break
         // when encryption is finished. But in case of error there could
@@ -228,6 +238,10 @@ export class StreamUploader {
         }
 
         for (const thumbnail of thumbnails) {
+            if (this.isUploadAborted) {
+                break;
+            }
+
             this.logger.debug(`Encrypting thumbnail ${thumbnail.type}`);
             const encryptedThumbnail = await this.cryptoService.encryptThumbnail(
                 this.revisionDraft.nodeKeys,
@@ -246,9 +260,13 @@ export class StreamUploader {
 
                 this.digests.update(block);
 
-                await this.controller.waitIfPaused();
+                await this.controller.waitWhilePaused();
                 await this.waitForBufferCapacity();
 
+                if (this.isUploadAborted) {
+                    break;
+                }
+
                 this.logger.debug(`Encrypting block ${index}`);
                 let attempt = 0;
                 let integrityError = false;
@@ -267,6 +285,11 @@ export class StreamUploader {
                             void this.telemetry.logBlockVerificationError(true);
                         }
                     } catch (error: unknown) {
+                        // Do not retry or report anything if the upload was aborted.
+                        if (error instanceof AbortError) {
+                            throw error;
+                        }
+
                         if (error instanceof IntegrityError) {
                             integrityError = true;
                         }
@@ -394,6 +417,11 @@ export class StreamUploader {
                 });
                 break;
             } catch (error: unknown) {
+                // Do not retry or report anything if the upload was aborted.
+                if (error instanceof AbortError) {
+                    throw error;
+                }
+
                 if (blockProgress !== 0) {
                     onProgress?.(-blockProgress);
                     blockProgress = 0;
@@ -456,6 +484,11 @@ export class StreamUploader {
                 });
                 break;
             } catch (error: unknown) {
+                // Do not retry or report anything if the upload was aborted.
+                if (error instanceof AbortError) {
+                    throw error;
+                }
+
                 if (blockProgress !== 0) {
                     onProgress?.(-blockProgress);
                     blockProgress = 0;
@@ -505,7 +538,17 @@ export class StreamUploader {
 
     private async waitForBufferCapacity() {
         if (this.encryptedBlocks.size >= MAX_BUFFERED_BLOCKS) {
-            await waitForCondition(() => this.encryptedBlocks.size < MAX_BUFFERED_BLOCKS);
+            try {
+                await waitForCondition(
+                    () => this.encryptedBlocks.size < MAX_BUFFERED_BLOCKS,
+                    this.abortController.signal,
+                );
+            } catch (error: unknown) {
+                if (error instanceof AbortError) {
+                    return;
+                }
+                throw error;
+            }
         }
     }
 
@@ -513,7 +556,17 @@ export class StreamUploader {
         while (this.ongoingUploads.size >= MAX_UPLOADING_BLOCKS) {
             await Promise.race(this.ongoingUploads.values().map(({ uploadPromise }) => uploadPromise));
         }
-        await waitForCondition(() => this.encryptedBlocks.size > 0 || this.encryptionFinished);
+        try {
+            await waitForCondition(
+                () => this.encryptedBlocks.size > 0 || this.encryptionFinished,
+                this.abortController.signal,
+            );
+        } catch (error: unknown) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
     }
 
     protected verifyIntegrity(thumbnails: Thumbnail[]) {
@@ -568,9 +621,14 @@ export class StreamUploader {
     }
 
     private async abortUpload(error: unknown) {
-        if (this.abortController.signal.aborted || this.signal?.aborted) {
+        if (this.isUploadAborted) {
             return;
         }
+        this.error = error;
         this.abortController.abort(error);
     }
+
+    private get isUploadAborted(): boolean {
+        return !!this.error || this.abortController.signal.aborted;
+    }
 }

package/src/protonDriveClient.ts

@@ -7,6 +7,7 @@ import {
     MaybeNode,
     MaybeMissingNode,
     NodeResult,
+    NodeResultWithNewUid,
     Revision,
     RevisionOrUid,
     ShareNodeSettings,
@@ -28,6 +29,7 @@ import {
     ThumbnailResult,
     SDKEvent,
     NodeType,
+    MemberRole,
 } from './interface';
 import {
     getUid,
@@ -36,6 +38,7 @@ import {
     convertInternalNodeIterator,
     convertInternalMissingNodeIterator,
     convertInternalNode,
+    convertInternalRevisionIterator,
 } from './transformers';
 import { Telemetry } from './telemetry';
 import { DriveAPIService } from './internal/apiService';
@@ -68,7 +71,7 @@ export class ProtonDriveClient {
     private download: ReturnType<typeof initDownloadModule>;
     private upload: ReturnType<typeof initUploadModule>;
     private devices: ReturnType<typeof initDevicesModule>;
-    private sessionManager: SharingPublicSessionManager;
+    private publicSessionManager: SharingPublicSessionManager;
 
     public experimental: {
         /**
@@ -93,6 +96,11 @@ export class ProtonDriveClient {
             isCustomPasswordProtected: boolean;
             isLegacy: boolean;
             vendorType: number;
+            directAccess?: {
+                nodeUid: string;
+                directRole: MemberRole;
+                publicRole: MemberRole;
+            };
         }>;
         /**
          * Experimental feature to authenticate a public link and
@@ -184,7 +192,13 @@ export class ProtonDriveClient {
             latestEventIdProvider,
         );
 
-        this.sessionManager = new SharingPublicSessionManager(httpClient, apiService, srpModule);
+        this.publicSessionManager = new SharingPublicSessionManager(
+            telemetry,
+            httpClient,
+            cryptoModule,
+            srpModule,
+            apiService,
+        );
 
         this.experimental = {
             getNodeUrl: async (nodeUid: NodeOrUid) => {
@@ -201,21 +215,25 @@ export class ProtonDriveClient {
             },
             getPublicLinkInfo: async (url: string) => {
                 this.logger.info(`Getting info for public link ${url}`);
-                return this.sessionManager.getInfo(url);
+                return this.publicSessionManager.getInfo(url);
             },
             authPublicLink: async (url: string, customPassword?: string) => {
                 this.logger.info(`Authenticating public link ${url}`);
-                const { httpClient, token, password } = await this.sessionManager.auth(url, customPassword);
+                const { httpClient, token, shareKey, rootUid } = await this.publicSessionManager.auth(
+                    url,
+                    customPassword,
+                );
                 return new ProtonDrivePublicLinkClient({
                     httpClient,
-                    cryptoCache,
                     account,
                     openPGPCryptoModule,
                     srpModule,
                     config,
                     telemetry,
+                    url,
                     token,
-                    password,
+                    publicShareKey: shareKey,
+                    publicRootNodeUid: rootUid,
                 });
             },
         };
@@ -408,7 +426,7 @@ export class ProtonDriveClient {
         nodeUids: NodeOrUid[],
         newParentNodeUid: NodeOrUid,
         signal?: AbortSignal,
-    ): AsyncGenerator<NodeResult> {
+    ): AsyncGenerator<NodeResultWithNewUid> {
         this.logger.info(`Copying ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
         yield* this.nodes.management.copyNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
     }
@@ -507,7 +525,7 @@ export class ProtonDriveClient {
      */
     async *iterateRevisions(nodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<Revision> {
         this.logger.info(`Iterating revisions of ${getUid(nodeUid)}`);
-        yield* this.nodes.revisions.iterateRevisions(getUid(nodeUid), signal);
+        yield* convertInternalRevisionIterator(this.nodes.revisions.iterateRevisions(getUid(nodeUid), signal));
     }
 
     /**
@@ -726,7 +744,7 @@ export class ProtonDriveClient {
      * ```typescript
      * const downloader = await client.getFileDownloader(nodeUid, signal);
      * const claimedSize = fileDownloader.getClaimedSizeInBytes();
-     * const downloadController = fileDownloader.writeToStream(stream, (downloadedBytes) => { ... });
+     * const downloadController = fileDownloader.downloadToStream(stream, (downloadedBytes) => { ... });
      *
      * signalController.abort(); // to cancel
      * downloadController.pause(); // to pause
@@ -786,12 +804,12 @@ export class ProtonDriveClient {
      *
      * ```typescript
      * const uploader = await client.getFileUploader(parentFolderUid, name, metadata, signal);
-     * const uploadController = await uploader.writeStream(stream, thumbnails, (uploadedBytes) => { ... });
+     * const uploadController = await uploader.uploadFromStream(stream, thumbnails, (uploadedBytes) => { ... });
      *
      * signalController.abort(); // to cancel
      * uploadController.pause(); // to pause
      * uploadController.resume(); // to resume
-     * const nodeUid = await uploadController.completion(); // to await completion
+     * const { nodeUid, nodeRevisionUid } = await uploadController.completion(); // to await completion
      * ```
      */
     async getFileUploader(