@protontech/drive-sdk 0.8.0 → 0.9.1

package/src/internal/download/seekableStream.test.ts

@@ -1,4 +1,4 @@
-import { SeekableReadableStream, BufferedSeekableStream } from './seekableStream';
+import { SeekableReadableStream, BufferedSeekableStream, UnderlyingSeekableSource } from './seekableStream';
 
 describe('SeekableReadableStream', () => {
     it('should call the seek callback when seek is called', async () => {
@@ -32,6 +32,7 @@ describe('SeekableReadableStream', () => {
 describe('BufferedSeekableStream', () => {
     let startWithCloseMock: jest.Mock;
     let pullMock: jest.Mock;
+    let seekableSource: UnderlyingSeekableSource;
 
     const data1 = new Uint8Array([1, 2, 3, 4, 5]);
     const data2 = new Uint8Array([6, 7, 8, 9, 10]);
@@ -53,6 +54,26 @@ describe('BufferedSeekableStream', () => {
             }
             readIndex++;
         });
+
+        // Simulates a real seekable source where seek repositions the read pointer
+        const fileData = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
+        let readPosition = 0;
+        const chunkSize = 5;
+
+        seekableSource = {
+            pull: jest.fn().mockImplementation((controller) => {
+                if (readPosition >= fileData.length) {
+                    controller.close();
+                    return;
+                }
+                const chunk = fileData.slice(readPosition, readPosition + chunkSize);
+                readPosition += chunk.length;
+                controller.enqueue(chunk);
+            }),
+            seek: jest.fn().mockImplementation((position: number) => {
+                readPosition = position;
+            }),
+        };
     });
 
     it('should throw error if highWaterMark is not 0', () => {
@@ -184,4 +205,108 @@ describe('BufferedSeekableStream', () => {
         const result4 = await stream.read(2);
         expect(result4).toEqual({ value: new Uint8Array([10]), done: true });
     });
+
+    it('should catch and ignore TypeError from releaseLock during seek', async () => {
+        const stream = new BufferedSeekableStream({
+            pull: pullMock,
+            seek: jest.fn(),
+        });
+
+        await stream.read(2);
+
+        const reader = (stream as any).reader;
+        const originalReleaseLock = reader.releaseLock.bind(reader);
+        jest.spyOn(reader, 'releaseLock').mockImplementation(() => {
+            originalReleaseLock();
+            throw new TypeError('Reader has pending read requests');
+        });
+
+        await expect(stream.seek(0)).resolves.not.toThrow();
+    });
+
+    it('should re-throw non-TypeError errors from releaseLock during seek', async () => {
+        const stream = new BufferedSeekableStream({
+            pull: pullMock,
+            seek: jest.fn(),
+        });
+
+        await stream.read(2);
+
+        const reader = (stream as any).reader;
+        const customError = new Error('Custom error');
+        jest.spyOn(reader, 'releaseLock').mockImplementation(() => {
+            throw customError;
+        });
+
+        await expect(stream.seek(0)).rejects.toThrow(customError);
+    });
+
+    it('should not call underlying seek when seeking within buffer range', async () => {
+        const seekMock = jest.fn();
+        const stream = new BufferedSeekableStream({
+            pull: pullMock,
+            seek: seekMock,
+        });
+
+        await stream.read(2);
+        expect(seekMock).not.toHaveBeenCalled();
+
+        // Seek within buffer range (buffer has bytes for positions 2-4)
+        await stream.seek(3);
+        expect(seekMock).not.toHaveBeenCalled();
+
+        // Seek to current position (still within buffer)
+        await stream.seek(3);
+        expect(seekMock).not.toHaveBeenCalled();
+    });
+
+    it('should not corrupt data when seeking to current position with seekable underlying source', async () => {
+        const stream = new BufferedSeekableStream(seekableSource);
+
+        // Read first 3 bytes [0, 1, 2], buffer will have [0, 1, 2, 3, 4]
+        const result1 = await stream.read(3);
+        expect(result1.value).toEqual(new Uint8Array([0, 1, 2]));
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Seek to position 3 (current position), should use buffer without seeking underlying source
+        await stream.seek(3);
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Buffer has [3, 4], needs 2 more from underlying source
+        // Underlying source stays at position 5, giving [5, 6, 7, 8, 9]
+        // Buffer becomes [3, 4, 5, 6, 7, 8, 9]
+        const result2 = await stream.read(4);
+        expect(result2.value).toEqual(new Uint8Array([3, 4, 5, 6]));
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Continue reading to verify stream integrity
+        const result3 = await stream.read(3);
+        expect(result3.value).toEqual(new Uint8Array([7, 8, 9]));
+    });
+
+    it('should call underlying seek only when seeking outside buffer range', async () => {
+        const stream = new BufferedSeekableStream(seekableSource);
+
+        // Read first 3 bytes [0, 1, 2], buffer will have [0, 1, 2, 3, 4]
+        await stream.read(3);
+        expect(seekableSource.seek).not.toHaveBeenCalled();
+
+        // Seek backward (outside buffer range) - should call underlying seek
+        await stream.seek(0);
+        expect(seekableSource.seek).toHaveBeenCalledWith(0);
+        expect(seekableSource.seek).toHaveBeenCalledTimes(1);
+
+        // Read and verify data is correct after backward seek
+        const result1 = await stream.read(3);
+        expect(result1.value).toEqual(new Uint8Array([0, 1, 2]));
+
+        // Seek forward past buffer end - should call underlying seek
+        await stream.seek(10);
+        expect(seekableSource.seek).toHaveBeenCalledWith(10);
+        expect(seekableSource.seek).toHaveBeenCalledTimes(2);
+
+        // Read and verify data is correct after forward seek
+        const result2 = await stream.read(3);
+        expect(result2.value).toEqual(new Uint8Array([10, 11, 12]));
+    });
 });

package/src/internal/download/seekableStream.ts

@@ -1,4 +1,4 @@
-interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
+export interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
     seek: (position: number) => void | Promise<void>;
 }
 
@@ -22,7 +22,10 @@ interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
 export class SeekableReadableStream extends ReadableStream<Uint8Array> {
     private seekCallback: (position: number) => void | Promise<void>;
 
-    constructor({ seek, ...underlyingSource }: UnderlyingSeekableSource, queuingStrategy?: QueuingStrategy<Uint8Array>) {
+    constructor(
+        { seek, ...underlyingSource }: UnderlyingSeekableSource,
+        queuingStrategy?: QueuingStrategy<Uint8Array>,
+    ) {
         super(underlyingSource, queuingStrategy);
         this.seekCallback = seek;
     }
@@ -160,23 +163,41 @@ export class BufferedSeekableStream extends SeekableReadableStream {
     async seek(position: number): Promise<void> {
         const endOfBufferPosition = this.currentPosition + (this.buffer.length - this.bufferPosition);
 
-        if (position > endOfBufferPosition) {
-            this.buffer = new Uint8Array(0);
-            this.bufferPosition = 0;
-        } else if (position < this.currentPosition) {
+        if (position > endOfBufferPosition || position < this.currentPosition) {
             this.buffer = new Uint8Array(0);
             this.bufferPosition = 0;
+
+            await super.seek(position);
+
+            if (this.reader) {
+                try {
+                    this.reader.releaseLock();
+                } catch (error) {
+                    // Streams API spec-compliant behavior: releaseLock() only throws TypeError when
+                    // there are pending read requests. This can occur due to timing differences between
+                    // when read() promises resolve on the client side vs when the browser's internal
+                    // stream mechanism fully completes.
+                    //
+                    // This manifests more frequently in Firefox than Chrome due to implementation
+                    // timing differences, but both are following the spec correctly.
+                    //
+                    // References:
+                    // - https://github.com/whatwg/streams/issues/1000
+                    // - https://developer.mozilla.org/en-US/docs/Web/API/ReadableStreamDefaultReader/releaseLock
+                    //
+                    // Safe to ignore since we're acquiring a new reader immediately after.
+                    if (!(error instanceof TypeError)) {
+                        throw error;
+                    }
+                }
+            }
+            this.reader = super.getReader();
+            this.streamClosed = false;
         } else {
+            // Position is within buffer range, just update buffer position.
             this.bufferPosition += position - this.currentPosition;
         }
 
-        await super.seek(position);
-
-        if (this.reader) {
-            this.reader.releaseLock();
-        }
-        this.reader = super.getReader();
-        this.streamClosed = false;
         this.currentPosition = position;
     }
 }

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/photos/index.ts

@@ -159,10 +159,10 @@ export function initPhotoUploadModule(
         metadata: PhotoUploadMetadata,
         signal?: AbortSignal,
     ): Promise<PhotoFileUploader> {
-        await queue.waitForCapacity(signal);
+        await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
-            queue.releaseCapacity();
+            queue.releaseCapacity(metadata.expectedSize);
         };
 
         return new PhotoFileUploader(

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/index.ts

@@ -45,10 +45,10 @@ export function initUploadModule(
         metadata: UploadMetadata,
         signal?: AbortSignal,
     ): Promise<FileUploader> {
-        await queue.waitForCapacity(signal);
+        await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
-            queue.releaseCapacity();
+            queue.releaseCapacity(metadata.expectedSize);
         };
 
         return new FileUploader(
@@ -76,10 +76,10 @@ export function initUploadModule(
         metadata: UploadMetadata,
         signal?: AbortSignal,
     ): Promise<FileRevisionUploader> {
-        await queue.waitForCapacity(signal);
+        await queue.waitForCapacity(metadata.expectedSize, signal);
 
         const onFinish = () => {
-            queue.releaseCapacity();
+            queue.releaseCapacity(metadata.expectedSize);
         };
 
         return new FileRevisionUploader(

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/queue.test.ts

@@ -0,0 +1,130 @@
+import { AbortError } from '../../errors';
+import { UploadQueue } from './queue';
+import { FILE_CHUNK_SIZE } from './streamUploader';
+
+describe('UploadQueue', () => {
+    let queue: UploadQueue;
+
+    beforeEach(() => {
+        queue = new UploadQueue();
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    it('should resolve immediately when queue is empty', async () => {
+        const promise = queue.waitForCapacity(0);
+        await promise;
+    });
+
+    it('should resolve immediately when under file upload limit', async () => {
+        // Fill queue with 4 uploads (limit is 5)
+        for (let i = 0; i < 4; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        const promise = queue.waitForCapacity(0);
+        await promise;
+    });
+
+    it('should wait when max concurrent file uploads is reached', async () => {
+        // Fill queue to max (5 uploads)
+        for (let i = 0; i < 5; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        let resolved = false;
+        const promise = queue.waitForCapacity(0).then(() => {
+            resolved = true;
+        });
+
+        await jest.advanceTimersByTimeAsync(100);
+        expect(resolved).toBe(false);
+
+        queue.releaseCapacity(0);
+
+        await jest.advanceTimersByTimeAsync(100);
+        await promise;
+        expect(resolved).toBe(true);
+    });
+
+    it('should wait when max concurrent upload size is reached', async () => {
+        // Fill queue with one large file that exceeds size limit
+        const largeSize = 10 * FILE_CHUNK_SIZE;
+        await queue.waitForCapacity(largeSize);
+
+        let resolved = false;
+        const promise = queue.waitForCapacity(0).then(() => {
+            resolved = true;
+        });
+
+        await jest.advanceTimersByTimeAsync(100);
+        expect(resolved).toBe(false);
+
+        queue.releaseCapacity(largeSize);
+
+        await jest.advanceTimersByTimeAsync(100);
+        await promise;
+        expect(resolved).toBe(true);
+    });
+
+    it('should track expected size correctly', async () => {
+        const size1 = 5 * FILE_CHUNK_SIZE;
+        const size2 = 4 * FILE_CHUNK_SIZE;
+
+        await queue.waitForCapacity(size1);
+        await queue.waitForCapacity(size2);
+
+        // Total is 9 * FILE_CHUNK_SIZE, limit is 10 * FILE_CHUNK_SIZE
+        // So next upload should still be allowed immediately
+        const promise = queue.waitForCapacity(3 * FILE_CHUNK_SIZE);
+        await promise;
+
+        // But now we're at limit, next one should wait
+        let resolved = false;
+        const waitingPromise = queue.waitForCapacity(0).then(() => {
+            resolved = true;
+        });
+
+        await jest.advanceTimersByTimeAsync(100);
+        expect(resolved).toBe(false);
+
+        queue.releaseCapacity(size1);
+        await jest.advanceTimersByTimeAsync(100);
+        await waitingPromise;
+        expect(resolved).toBe(true);
+    });
+
+    it('should reject when signal is aborted', async () => {
+        // Fill queue to max
+        for (let i = 0; i < 5; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        const controller = new AbortController();
+        const promise = queue.waitForCapacity(0, controller.signal);
+
+        controller.abort();
+
+        // Attach rejection handler BEFORE advancing timers to avoid unhandled rejection
+        const expectation = expect(promise).rejects.toThrow(AbortError);
+        await jest.advanceTimersByTimeAsync(50);
+        await expectation;
+    });
+
+    it('should reject immediately if signal is already aborted', async () => {
+        // Fill queue to max
+        for (let i = 0; i < 5; i++) {
+            await queue.waitForCapacity(0);
+        }
+
+        const controller = new AbortController();
+        controller.abort();
+
+        const promise = queue.waitForCapacity(0, controller.signal);
+        await expect(promise).rejects.toThrow(AbortError);
+    });
+});
+

package/src/internal/upload/queue.ts

@@ -1,4 +1,23 @@
 import { waitForCondition } from '../wait';
+import { FILE_CHUNK_SIZE } from './streamUploader';
+
+/**
+ * Maximum number of concurrent file uploads.
+ *
+ * It avoids uploading too many files at the same time. The total file size
+ * below also limits that, but if the file is empty, we still need to make
+ * a reasonable number of requests.
+ */
+const MAX_CONCURRENT_FILE_UPLOADS = 5;
+
+/**
+ * Maximum total file size that can be uploaded concurrently.
+ *
+ * It avoids uploading too many blocks at the same time, ensuring that on poor
+ * connection we don't do too many things at the same time that all fail due
+ * to network issues.
+ */
+const MAX_CONCURRENT_UPLOAD_SIZE = 10 * FILE_CHUNK_SIZE;
 
 /**
  * A queue that limits the number of concurrent uploads.
@@ -14,18 +33,24 @@ import { waitForCondition } from '../wait';
  * uploaded. That is something we want to add in the future to be
  * more performant for many small file uploads.
  */
-const MAX_CONCURRENT_UPLOADS = 5;
-
 export class UploadQueue {
-    private capacity = 0;
+    private totalFileUploads = 0;
+
+    private totalExpectedSize = 0;
 
-    // TODO: use expected size to control the size of the queue
-    async waitForCapacity(signal?: AbortSignal) {
-        await waitForCondition(() => this.capacity < MAX_CONCURRENT_UPLOADS, signal);
-        this.capacity++;
+    async waitForCapacity(expectedSize: number, signal?: AbortSignal) {
+        await waitForCondition(
+            () =>
+                this.totalFileUploads < MAX_CONCURRENT_FILE_UPLOADS &&
+                this.totalExpectedSize < MAX_CONCURRENT_UPLOAD_SIZE,
+            signal,
+        );
+        this.totalFileUploads++;
+        this.totalExpectedSize += expectedSize;
     }
 
-    releaseCapacity() {
-        this.capacity--;
+    releaseCapacity(expectedSize: number) {
+        this.totalFileUploads--;
+        this.totalExpectedSize -= expectedSize;
     }
 }