@protontech/drive-sdk 0.4.1 → 0.5.1

package/src/internal/apiService/errors.test.ts

@@ -1,3 +1,4 @@
+import { AbortError } from '../../errors';
 import { apiErrorFactory } from './errors';
 import * as errors from './errors';
 import { ErrorCode } from './errorCodes';
@@ -17,6 +18,15 @@ function mockAPIResponseAndResult(options: {
 }
 
 describe('apiErrorFactory should return', () => {
+    it('AbortError on aborted error', () => {
+        const abortError = new Error('AbortError');
+        abortError.name = 'AbortError';
+
+        const error = apiErrorFactory({ response: new Response(), error: abortError });
+        expect(error).toBeInstanceOf(AbortError);
+        expect(error.message).toBe('Request aborted');
+    });
+
     it('generic APIHTTPError when there is no specifc body', () => {
         const response = new Response('', { status: 404, statusText: 'Not found' });
         const error = apiErrorFactory({ response });

package/src/internal/apiService/errors.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { ServerError, ValidationError } from '../../errors';
+import { AbortError, ServerError, ValidationError } from '../../errors';
 import { ErrorCode, HTTPErrorCode } from './errorCodes';
 
 export function apiErrorFactory({
@@ -12,6 +12,10 @@ export function apiErrorFactory({
     result?: unknown;
     error?: unknown;
 }): ServerError {
+    if (error && error instanceof Error && error.name === 'AbortError') {
+        return new AbortError(c('Error').t`Request aborted`);
+    }
+
     // Backend responses with 404 both in the response and body code.
     // In such a case we want to stick to APIHTTPError to be very clear
     // it is not NotFoundAPIError.

package/src/internal/asyncIteratorMap.test.ts

@@ -1,3 +1,4 @@
+import { AbortError } from '../errors';
 import { asyncIteratorMap } from './asyncIteratorMap';
 
 // Helper function to create an async generator from array
@@ -147,4 +148,15 @@ describe('asyncIteratorMap', () => {
         expect(maxConcurrentExecutions).toBe(concurrencyLimit);
         expect(results).toEqual([2, 4, 6, 8, 10, 12, 14, 16]);
     });
+
+    test('throws AbortError if signal is aborted', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5]);
+        const mapper = async (x: number) => x * 2;
+
+        const ac = new AbortController();
+        ac.abort();
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper, 1, ac.signal);
+        await expect(collectResults(mappedGen)).rejects.toThrow(AbortError);
+    });
 });

package/src/internal/asyncIteratorMap.ts

@@ -1,3 +1,7 @@
+import { c } from 'ttag';
+
+import { AbortError } from '../errors';
+
 const DEFAULT_CONCURRENCY = 10;
 
 /**
@@ -18,6 +22,7 @@ export async function* asyncIteratorMap<I, O>(
     inputIterator: AsyncGenerator<I>,
     mapper: (item: I) => Promise<O>,
     concurrency: number = DEFAULT_CONCURRENCY,
+    signal?: AbortSignal,
 ): AsyncGenerator<O> {
     let done = false;
 
@@ -50,6 +55,9 @@ export async function* asyncIteratorMap<I, O>(
     };
 
     while (!done || executing.size > 0 || results.length > 0) {
+        if (signal?.aborted) {
+            throw new AbortError(c('Error').t`Operation aborted`);
+        }
         while (!done && executing.size < concurrency) {
             await pump();
         }

package/src/internal/download/controller.ts

@@ -1,11 +1,23 @@
+import { AbortError } from '../../errors';
 import { waitForCondition } from '../wait';
 
 export class DownloadController {
     private paused = false;
     public promise?: Promise<void>;
 
+    constructor(private signal?: AbortSignal) {
+        this.signal = signal;
+    }
+
     async waitWhilePaused(): Promise<void> {
-        await waitForCondition(() => !this.paused);
+        try {
+            await waitForCondition(() => !this.paused, this.signal);
+        } catch (error) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
     }
 
     pause(): void {

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

@@ -78,7 +78,7 @@ describe('FileDownloader', () => {
         } as DecryptedRevision;
     });
 
-    describe('writeToStream', () => {
+    describe('downloadToStream', () => {
         let onProgress: (downloadedBytes: number) => void;
         let onFinish: () => void;
 
@@ -89,7 +89,7 @@ describe('FileDownloader', () => {
         const verifySuccess = async (
             fileProgress: number = 6, // 3 blocks of length 1, 2, 3
         ) => {
-            const controller = downloader.writeToStream(stream, onProgress);
+            const controller = downloader.downloadToStream(stream, onProgress);
             await controller.completion();
 
             expect(apiService.iterateRevisionBlocks).toHaveBeenCalledWith('revisionUid', undefined);
@@ -103,7 +103,7 @@ describe('FileDownloader', () => {
         };
 
         const verifyFailure = async (error: string, downloadedBytes: number | undefined) => {
-            const controller = downloader.writeToStream(stream, onProgress);
+            const controller = downloader.downloadToStream(stream, onProgress);
 
             await expect(controller.completion()).rejects.toThrow(error);
 
@@ -156,9 +156,9 @@ describe('FileDownloader', () => {
         });
 
         it('should reject two download starts', async () => {
-            downloader.writeToStream(stream, onProgress);
-            expect(() => downloader.writeToStream(stream, onProgress)).toThrow('Download already started');
-            expect(() => downloader.unsafeWriteToStream(stream, onProgress)).toThrow('Download already started');
+            downloader.downloadToStream(stream, onProgress);
+            expect(() => downloader.downloadToStream(stream, onProgress)).toThrow('Download already started');
+            expect(() => downloader.unsafeDownloadToStream(stream, onProgress)).toThrow('Download already started');
         });
 
         it('should start a download and write to the stream', async () => {
@@ -347,7 +347,7 @@ describe('FileDownloader', () => {
         });
     });
 
-    describe('unsafeWriteToStream', () => {
+    describe('unsafeDownloadToStream', () => {
         let onProgress: (downloadedBytes: number) => void;
         let onFinish: () => void;
 
@@ -381,7 +381,7 @@ describe('FileDownloader', () => {
         });
 
         it('should skip verification steps', async () => {
-            const controller = downloader.unsafeWriteToStream(stream, onProgress);
+            const controller = downloader.unsafeDownloadToStream(stream, onProgress);
             await controller.completion();
 
             expect(apiService.iterateRevisionBlocks).toHaveBeenCalledWith('revisionUid', undefined);

package/src/internal/download/fileDownloader.ts

@@ -1,4 +1,7 @@
+import { c } from 'ttag';
+
 import { PrivateKey, SessionKey, base64StringToUint8Array } from '../../crypto';
+import { AbortError } from '../../errors';
 import { Logger } from '../../interface';
 import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
@@ -48,7 +51,7 @@ export class FileDownloader {
         this.revision = revision;
         this.signal = signal;
         this.onFinish = onFinish;
-        this.controller = new DownloadController();
+        this.controller = new DownloadController(this.signal);
     }
 
     getClaimedSizeInBytes(): number | undefined {
@@ -138,24 +141,24 @@ export class FileDownloader {
         }
     }
 
-    writeToStream(stream: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController {
+    downloadToStream(stream: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController {
         if (this.controller.promise) {
             throw new Error(`Download already started`);
         }
-        this.controller.promise = this.downloadToStream(stream, onProgress);
+        this.controller.promise = this.internalDownloadToStream(stream, onProgress);
         return this.controller;
     }
 
-    unsafeWriteToStream(stream: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController {
+    unsafeDownloadToStream(stream: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController {
         if (this.controller.promise) {
             throw new Error(`Download already started`);
         }
         const ignoreIntegrityErrors = true;
-        this.controller.promise = this.downloadToStream(stream, onProgress, ignoreIntegrityErrors);
+        this.controller.promise = this.internalDownloadToStream(stream, onProgress, ignoreIntegrityErrors);
         return this.controller;
     }
 
-    private async downloadToStream(
+    private async internalDownloadToStream(
         stream: WritableStream,
         onProgress?: (downloadedBytes: number) => void,
         ignoreIntegrityErrors = false,
@@ -289,6 +292,10 @@ export class FileDownloader {
                 logger.debug(`Decrypting`);
                 decryptedBlock = await this.cryptoService.decryptBlock(encryptedBlock, cryptoKeys);
             } catch (error) {
+                if (this.signal?.aborted) {
+                    throw new AbortError(c('Error').t`Operation aborted`);
+                }
+
                 if (blockProgress !== 0) {
                     onProgress?.(-blockProgress);
                     blockProgress = 0;

package/src/internal/nodes/apiService.test.ts

@@ -1,7 +1,8 @@
+import { NodeWithSameNameExistsValidationError, ValidationError } from '../../errors';
 import { MemberRole, NodeType } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { DriveAPIService, ErrorCode, InvalidRequirementsAPIError } from '../apiService';
-import { NodeAPIService } from './apiService';
+import { NodeAPIService, groupNodeUidsByVolumeAndIteratePerBatch } from './apiService';
 import { NodeOutOfSyncError } from './errors';
 
 function generateAPIFileNode(linkOverrides = {}, overrides = {}) {
@@ -476,6 +477,44 @@ describe('nodeAPIService', () => {
                 { uid: 'volumeId~nodeId2', ok: false, error: 'INSUFFICIENT_SCOPE' },
             ]);
         });
+
+        it('should trash nodes in batches', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async (_, { LinkIDs }) =>
+                Promise.resolve({
+                    Responses: LinkIDs.map((linkId: string) => ({
+                        LinkID: linkId,
+                        Response: {
+                            Code: ErrorCode.OK,
+                        },
+                    })),
+                }),
+            );
+
+            const nodeUids = Array.from({ length: 250 }, (_, i) => `volumeId1~nodeId${i}`);
+            const nodeIds = nodeUids.map((uid) => uid.split('~')[1]);
+
+            const results = await Array.fromAsync(api.trashNodes(nodeUids));
+            expect(results).toHaveLength(nodeUids.length);
+            expect(results.every((result) => result.ok)).toBe(true);
+
+            expect(apiMock.post).toHaveBeenCalledTimes(3);
+            expect(apiMock.post).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId1/trash_multiple',
+                { LinkIDs: nodeIds.slice(0, 100) },
+                undefined,
+            );
+            expect(apiMock.post).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId1/trash_multiple',
+                { LinkIDs: nodeIds.slice(100, 200) },
+                undefined,
+            );
+            expect(apiMock.post).toHaveBeenCalledWith(
+                'drive/v2/volumes/volumeId1/trash_multiple',
+                { LinkIDs: nodeIds.slice(200, 250) },
+                undefined,
+            );
+        });
     });
 
     describe('restoreNodes', () => {
@@ -517,17 +556,28 @@ describe('nodeAPIService', () => {
             ]);
         });
 
-        it('should fail restoring from multiple volumes', async () => {
-            try {
-                await Array.fromAsync(api.restoreNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
-                throw new Error('Should have thrown');
-            } catch (error: any) {
-                expect(error.message).toEqual('Restoring items from multiple sections is not allowed');
-            }
+        it('should restore nodes from multiple volumes', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.put = jest.fn(async (_, { LinkIDs }) =>
+                Promise.resolve({
+                    Responses: LinkIDs.map((linkId: string) => ({
+                        LinkID: linkId,
+                        Response: {
+                            Code: ErrorCode.OK,
+                        },
+                    })),
+                }),
+            );
+
+            const result = await Array.fromAsync(api.restoreNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
+            expect(result).toEqual([
+                { uid: 'volumeId1~nodeId1', ok: true },
+                { uid: 'volumeId2~nodeId2', ok: true },
+            ]);
         });
     });
 
-    describe('deleteNOdes', () => {
+    describe('deleteNodes', () => {
         it('should delete nodes', async () => {
             // @ts-expect-error Mocking for testing purposes
             apiMock.post = jest.fn(async () =>
@@ -557,12 +607,86 @@ describe('nodeAPIService', () => {
             ]);
         });
 
-        it('should fail deleting nodes from multiple volumes', async () => {
+        it('should delete nodes from multiple volumes', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async (_, { LinkIDs }) =>
+                Promise.resolve({
+                    Responses: LinkIDs.map((linkId: string) => ({
+                        LinkID: linkId,
+                        Response: {
+                            Code: ErrorCode.OK,
+                        },
+                    })),
+                }),
+            );
+
+            const result = await Array.fromAsync(api.deleteNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
+            expect(result).toEqual([
+                { uid: 'volumeId1~nodeId1', ok: true },
+                { uid: 'volumeId2~nodeId2', ok: true },
+            ]);
+        });
+    });
+
+    describe('createFolder', () => {
+        it('should create folder', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: ErrorCode.OK,
+                Folder: {
+                    ID: 'newNodeId',
+                },
+            });
+
+            const result = await api.createFolder('volumeId~parentNodeId', {
+                armoredKey: 'armoredKey',
+                armoredHashKey: 'armoredHashKey',
+                armoredNodePassphrase: 'armoredNodePassphrase',
+                armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                signatureEmail: 'signatureEmail',
+                encryptedName: 'encryptedName',
+                hash: 'hash',
+                armoredExtendedAttributes: 'armoredExtendedAttributes',
+            });
+
+            expect(result).toEqual('volumeId~newNodeId');
+            expect(apiMock.post).toHaveBeenCalledWith('drive/v2/volumes/volumeId/folders', {
+                ParentLinkID: 'parentNodeId',
+                NodeKey: 'armoredKey',
+                NodeHashKey: 'armoredHashKey',
+                NodePassphrase: 'armoredNodePassphrase',
+                NodePassphraseSignature: 'armoredNodePassphraseSignature',
+                SignatureEmail: 'signatureEmail',
+                Name: 'encryptedName',
+                Hash: 'hash',
+                XAttr: 'armoredExtendedAttributes',
+            });
+        });
+
+        it('should throw NodeWithSameNameExistsValidationError if node already exists', async () => {
+            apiMock.post = jest.fn().mockRejectedValue(
+                new ValidationError('Node already exists', ErrorCode.ALREADY_EXISTS, {
+                    ConflictLinkID: 'existingNodeId',
+                }),
+            );
+
             try {
-                await Array.fromAsync(api.deleteNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
-                throw new Error('Should have thrown');
-            } catch (error: any) {
-                expect(error.message).toEqual('Deleting items from multiple sections is not allowed');
+                await api.createFolder('volumeId~parentNodeId', {
+                    armoredKey: 'armoredKey',
+                    armoredHashKey: 'armoredHashKey',
+                    armoredNodePassphrase: 'armoredNodePassphrase',
+                    armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                    signatureEmail: 'signatureEmail',
+                    encryptedName: 'encryptedName',
+                    hash: 'hash',
+                    armoredExtendedAttributes: 'armoredExtendedAttributes',
+                });
+                expect(false).toBeTruthy();
+            } catch (error: unknown) {
+                expect(error).toBeInstanceOf(NodeWithSameNameExistsValidationError);
+                if (error instanceof NodeWithSameNameExistsValidationError) {
+                    expect(error.code).toEqual(ErrorCode.ALREADY_EXISTS);
+                    expect(error.existingNodeUid).toEqual('volumeId~existingNodeId');
+                }
             }
         });
     });
@@ -600,3 +724,126 @@ describe('nodeAPIService', () => {
         });
     });
 });
+
+describe('groupNodeUidsByVolumeAndIteratePerBatch', () => {
+    it('should handle empty array', () => {
+        const result = Array.from(groupNodeUidsByVolumeAndIteratePerBatch([]));
+        expect(result).toEqual([]);
+    });
+
+    it('should handle single volume with nodes that fit in one batch', () => {
+        const nodeUids = ['volumeId1~nodeId1', 'volumeId1~nodeId2', 'volumeId1~nodeId3'];
+
+        const result = Array.from(groupNodeUidsByVolumeAndIteratePerBatch(nodeUids));
+
+        expect(result).toEqual([
+            {
+                volumeId: 'volumeId1',
+                batchNodeIds: ['nodeId1', 'nodeId2', 'nodeId3'],
+                batchNodeUids: ['volumeId1~nodeId1', 'volumeId1~nodeId2', 'volumeId1~nodeId3'],
+            },
+        ]);
+    });
+
+    it('should handle single volume with nodes that require multiple batches', () => {
+        // Create 250 node UIDs to test batching (API_NODES_BATCH_SIZE = 100)
+        const nodeUids = Array.from({ length: 250 }, (_, i) => `volumeId1~nodeId${i}`);
+
+        const result = Array.from(groupNodeUidsByVolumeAndIteratePerBatch(nodeUids));
+
+        expect(result).toHaveLength(3); // 100 + 100 + 50
+
+        // First batch
+        expect(result[0]).toEqual({
+            volumeId: 'volumeId1',
+            batchNodeIds: Array.from({ length: 100 }, (_, i) => `nodeId${i}`),
+            batchNodeUids: Array.from({ length: 100 }, (_, i) => `volumeId1~nodeId${i}`),
+        });
+
+        // Second batch
+        expect(result[1]).toEqual({
+            volumeId: 'volumeId1',
+            batchNodeIds: Array.from({ length: 100 }, (_, i) => `nodeId${i + 100}`),
+            batchNodeUids: Array.from({ length: 100 }, (_, i) => `volumeId1~nodeId${i + 100}`),
+        });
+
+        // Third batch
+        expect(result[2]).toEqual({
+            volumeId: 'volumeId1',
+            batchNodeIds: Array.from({ length: 50 }, (_, i) => `nodeId${i + 200}`),
+            batchNodeUids: Array.from({ length: 50 }, (_, i) => `volumeId1~nodeId${i + 200}`),
+        });
+    });
+
+    it('should handle multiple volumes with nodes distributed across them', () => {
+        const nodeUids = [
+            'volumeId1~nodeId1',
+            'volumeId2~nodeId2',
+            'volumeId1~nodeId3',
+            'volumeId3~nodeId4',
+            'volumeId2~nodeId5',
+        ];
+
+        const result = Array.from(groupNodeUidsByVolumeAndIteratePerBatch(nodeUids));
+
+        expect(result).toHaveLength(3); // One batch per volume
+
+        // Results should be grouped by volume
+        const volumeId1Batch = result.find((batch) => batch.volumeId === 'volumeId1');
+        const volumeId2Batch = result.find((batch) => batch.volumeId === 'volumeId2');
+        const volumeId3Batch = result.find((batch) => batch.volumeId === 'volumeId3');
+
+        expect(volumeId1Batch).toEqual({
+            volumeId: 'volumeId1',
+            batchNodeIds: ['nodeId1', 'nodeId3'],
+            batchNodeUids: ['volumeId1~nodeId1', 'volumeId1~nodeId3'],
+        });
+
+        expect(volumeId2Batch).toEqual({
+            volumeId: 'volumeId2',
+            batchNodeIds: ['nodeId2', 'nodeId5'],
+            batchNodeUids: ['volumeId2~nodeId2', 'volumeId2~nodeId5'],
+        });
+
+        expect(volumeId3Batch).toEqual({
+            volumeId: 'volumeId3',
+            batchNodeIds: ['nodeId4'],
+            batchNodeUids: ['volumeId3~nodeId4'],
+        });
+    });
+
+    it('should handle multiple volumes where some require multiple batches', () => {
+        // Volume 1: 150 nodes (2 batches)
+        // Volume 2: 50 nodes (1 batch)
+        // Volume 3: 200 nodes (2 batches)
+        const volume1Nodes = Array.from({ length: 150 }, (_, i) => `volumeId1~nodeId${i}`);
+        const volume2Nodes = Array.from({ length: 50 }, (_, i) => `volumeId2~nodeId${i}`);
+        const volume3Nodes = Array.from({ length: 200 }, (_, i) => `volumeId3~nodeId${i}`);
+
+        const nodeUids = [...volume1Nodes, ...volume2Nodes, ...volume3Nodes];
+
+        const result = Array.from(groupNodeUidsByVolumeAndIteratePerBatch(nodeUids));
+
+        expect(result).toHaveLength(5); // 2 + 1 + 2 batches
+
+        // Group results by volume
+        const volume1Batches = result.filter((batch) => batch.volumeId === 'volumeId1');
+        const volume2Batches = result.filter((batch) => batch.volumeId === 'volumeId2');
+        const volume3Batches = result.filter((batch) => batch.volumeId === 'volumeId3');
+
+        expect(volume1Batches).toHaveLength(2);
+        expect(volume2Batches).toHaveLength(1);
+        expect(volume3Batches).toHaveLength(2);
+
+        // Verify volume 1 batches
+        expect(volume1Batches[0].batchNodeIds).toHaveLength(100);
+        expect(volume1Batches[1].batchNodeIds).toHaveLength(50);
+
+        // Verify volume 2 batch
+        expect(volume2Batches[0].batchNodeIds).toHaveLength(50);
+
+        // Verify volume 3 batches
+        expect(volume3Batches[0].batchNodeIds).toHaveLength(100);
+        expect(volume3Batches[1].batchNodeIds).toHaveLength(100);
+    });
+});