@protontech/drive-sdk 0.4.1 → 0.5.0

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

@@ -138,24 +138,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,

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

@@ -1,7 +1,7 @@
 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 +476,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 +555,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,13 +606,24 @@ describe('nodeAPIService', () => {
             ]);
         });
 
-        it('should fail deleting nodes from multiple volumes', async () => {
-            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');
-            }
+        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 },
+            ]);
         });
     });
 
@@ -600,3 +660,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);
+    });
+});

package/src/internal/nodes/apiService.ts

@@ -128,7 +128,7 @@ export class NodeAPIService {
 
     async *iterateNodes(
         nodeUids: string[],
-        ownVolumeId: string,
+        ownVolumeId: string | undefined,
         filterOptions?: FilterOptions,
         signal?: AbortSignal,
     ): AsyncGenerator<EncryptedNode> {
@@ -389,55 +389,49 @@ export class NodeAPIService {
         return makeNodeUid(volumeId, response.LinkID);
     }
 
-    // Improvement requested: split into multiple calls for many nodes.
     async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const nodeIds = nodeUids.map(splitNodeUid);
-        const volumeId = assertAndGetSingleVolumeId(c('Operation').t`Trashing items`, nodeIds);
-
-        const response = await this.apiService.post<PostTrashNodesRequest, PostTrashNodesResponse>(
-            `drive/v2/volumes/${volumeId}/trash_multiple`,
-            {
-                LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
-            },
-            signal,
-        );
+        for (const { volumeId, batchNodeIds, batchNodeUids } of groupNodeUidsByVolumeAndIteratePerBatch(nodeUids)) {
+            const response = await this.apiService.post<PostTrashNodesRequest, PostTrashNodesResponse>(
+                `drive/v2/volumes/${volumeId}/trash_multiple`,
+                {
+                    LinkIDs: batchNodeIds,
+                },
+                signal,
+            );
 
-        // TODO: remove `as` when backend fixes OpenAPI schema.
-        yield* handleResponseErrors(nodeUids, volumeId, response.Responses as LinkResponse[]);
+            // TODO: remove `as` when backend fixes OpenAPI schema.
+            yield * handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
+        }
     }
 
-    // Improvement requested: split into multiple calls for many nodes.
     async *restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const nodeIds = nodeUids.map(splitNodeUid);
-        const volumeId = assertAndGetSingleVolumeId(c('Operation').t`Restoring items`, nodeIds);
-
-        const response = await this.apiService.put<PutRestoreNodesRequest, PutRestoreNodesResponse>(
-            `drive/v2/volumes/${volumeId}/trash/restore_multiple`,
-            {
-                LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
-            },
-            signal,
-        );
+        for (const { volumeId, batchNodeIds, batchNodeUids } of groupNodeUidsByVolumeAndIteratePerBatch(nodeUids)) {
+            const response = await this.apiService.put<PutRestoreNodesRequest, PutRestoreNodesResponse>(
+                `drive/v2/volumes/${volumeId}/trash/restore_multiple`,
+                {
+                    LinkIDs: batchNodeIds,
+                },
+                signal,
+            );
 
-        // TODO: remove `as` when backend fixes OpenAPI schema.
-        yield* handleResponseErrors(nodeUids, volumeId, response.Responses as LinkResponse[]);
+            // TODO: remove `as` when backend fixes OpenAPI schema.
+            yield* handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
+        }
     }
 
-    // Improvement requested: split into multiple calls for many nodes.
     async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const nodeIds = nodeUids.map(splitNodeUid);
-        const volumeId = assertAndGetSingleVolumeId(c('Operation').t`Deleting items`, nodeIds);
-
-        const response = await this.apiService.post<PostDeleteNodesRequest, PostDeleteNodesResponse>(
-            `drive/v2/volumes/${volumeId}/trash/delete_multiple`,
-            {
-                LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
-            },
-            signal,
-        );
+        for (const { volumeId, batchNodeIds, batchNodeUids } of groupNodeUidsByVolumeAndIteratePerBatch(nodeUids)) {
+            const response = await this.apiService.post<PostDeleteNodesRequest, PostDeleteNodesResponse>(
+                `drive/v2/volumes/${volumeId}/trash/delete_multiple`,
+                {
+                    LinkIDs: batchNodeIds,
+                },
+                signal,
+            );
 
-        // TODO: remove `as` when backend fixes OpenAPI schema.
-        yield* handleResponseErrors(nodeUids, volumeId, response.Responses as LinkResponse[]);
+            // TODO: remove `as` when backend fixes OpenAPI schema.
+            yield* handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
+        }
     }
 
     async createFolder(
@@ -513,15 +507,6 @@ export class NodeAPIService {
     }
 }
 
-function assertAndGetSingleVolumeId(operationForErrorMessage: string, nodeIds: { volumeId: string }[]): string {
-    const uniqueVolumeIds = new Set(nodeIds.map(({ volumeId }) => volumeId));
-    if (uniqueVolumeIds.size !== 1) {
-        throw new ValidationError(c('Error').t`${operationForErrorMessage} from multiple sections is not allowed`);
-    }
-    const volumeId = nodeIds[0].volumeId;
-    return volumeId;
-}
-
 type LinkResponse = {
     LinkID: string;
     Response: {
@@ -657,6 +642,34 @@ function linkToEncryptedNode(
     throw new Error(`Unknown node type: ${link.Link.Type}`);
 }
 
+export function* groupNodeUidsByVolumeAndIteratePerBatch(
+    nodeUids: string[],
+): Generator<{ volumeId: string; batchNodeIds: string[]; batchNodeUids: string[] }> {
+    const allNodeIds = nodeUids.map((nodeUid: string) => {
+        const { volumeId, nodeId } = splitNodeUid(nodeUid);
+        return { volumeId, nodeIds: { nodeId, nodeUid } };
+    });
+
+    const nodeIdsByVolumeId = new Map<string, { nodeId: string; nodeUid: string }[]>();
+    for (const { volumeId, nodeIds } of allNodeIds) {
+        if (!nodeIdsByVolumeId.has(volumeId)) {
+            nodeIdsByVolumeId.set(volumeId, []);
+        }
+        nodeIdsByVolumeId.get(volumeId)?.push(nodeIds);
+    }
+
+    for (const [volumeId, nodeIds] of nodeIdsByVolumeId.entries()) {
+        for (const nodeIdsBatch of batch(nodeIds, API_NODES_BATCH_SIZE)) {
+            yield {
+                volumeId,
+                batchNodeIds: nodeIdsBatch.map(({ nodeId }) => nodeId),
+                batchNodeUids: nodeIdsBatch.map(({ nodeUid }) => nodeUid),
+            };
+        }
+    }
+}
+
+
 function transformRevisionResponse(
     volumeId: string,
     nodeId: string,

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

@@ -0,0 +1,129 @@
+import { NodesDebouncer } from './debouncer';
+import { Logger } from '../../interface';
+
+describe('NodesDebouncer', () => {
+    let debouncer: NodesDebouncer;
+    let mockLogger: jest.Mocked<Logger>;
+
+    beforeEach(() => {
+        mockLogger = {
+            debug: jest.fn(),
+            info: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+        };
+        debouncer = new NodesDebouncer(mockLogger);
+
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+        debouncer.clear();
+    });
+
+    it('should register a node for loading and wait for it to finish', async () => {
+        const nodeUid = 'test-node-1';
+        debouncer.loadingNode(nodeUid);
+
+        // Verify that the node is registered by checking if waitForLoadingNode works
+        const waitPromise = debouncer.waitForLoadingNode(nodeUid);
+        expect(waitPromise).toBeInstanceOf(Promise);
+
+        // Finish loading to clean up
+        debouncer.finishedLoadingNode(nodeUid);
+        await waitPromise;
+    });
+
+    it('should allow multiple nodes to be registered', async () => {
+        const nodeUid1 = 'test-node-1';
+        const nodeUid2 = 'test-node-2';
+
+        debouncer.loadingNode(nodeUid1);
+        debouncer.loadingNode(nodeUid2);
+
+        const wait1 = debouncer.waitForLoadingNode(nodeUid1);
+        const wait2 = debouncer.waitForLoadingNode(nodeUid2);
+
+        expect(wait1).toBeInstanceOf(Promise);
+        expect(wait2).toBeInstanceOf(Promise);
+
+        debouncer.finishedLoadingNode(nodeUid1);
+        debouncer.finishedLoadingNode(nodeUid2);
+        await Promise.all([wait1, wait2]);
+    });
+
+    it('should register multiple nodes at once', async () => {
+        const nodeUid1 = 'test-node-1';
+        const nodeUid2 = 'test-node-2';
+
+        debouncer.loadingNodes([nodeUid1, nodeUid2]);
+
+        const wait1 = debouncer.waitForLoadingNode(nodeUid1);
+        const wait2 = debouncer.waitForLoadingNode(nodeUid2);
+
+        expect(wait1).toBeInstanceOf(Promise);
+        expect(wait2).toBeInstanceOf(Promise);
+
+        debouncer.finishedLoadingNode(nodeUid1);
+        debouncer.finishedLoadingNode(nodeUid2);
+        await Promise.all([wait1, wait2]);
+    });
+
+    it('should warn about registering the same node twice', async () => {
+        const nodeUid = 'test-node-1';
+
+        // Register the same node twice
+        debouncer.loadingNode(nodeUid);
+        debouncer.loadingNode(nodeUid);
+
+        expect(mockLogger.warn).toHaveBeenCalledWith(`debouncer: Loading twice for: ${nodeUid}`);
+    });
+
+    it('should timeout', async () => {
+        const nodeUid = 'test-node-1';
+        debouncer.loadingNode(nodeUid);
+
+        jest.advanceTimersByTime(6000);
+        expect(mockLogger.warn).toHaveBeenCalledWith(`debouncer: Timeout for: ${nodeUid}`);
+        await expect(debouncer.waitForLoadingNode(nodeUid)).resolves.toBeUndefined();
+    });
+
+    describe('finishedLoadingNode', () => {
+        it('should handle non-existent node gracefully', async () => {
+            const nodeUid = 'non-existent-node';
+
+            expect(() => debouncer.finishedLoadingNode(nodeUid)).not.toThrow();
+        });
+
+        it('should remove node from internal map after finishing', async () => {
+            const nodeUid = 'test-node-1';
+            debouncer.loadingNode(nodeUid);
+            debouncer.finishedLoadingNode(nodeUid);
+
+            const waitPromise = debouncer.waitForLoadingNode(nodeUid);
+            await expect(waitPromise).resolves.toBe(undefined);
+        });
+    });
+
+    describe('waitForLoadingNode', () => {
+        it('should return immediately for non-registered node', async () => {
+            const nodeUid = 'non-existent-node';
+
+            const result = await debouncer.waitForLoadingNode(nodeUid);
+            expect(result).toBeUndefined();
+            expect(mockLogger.debug).not.toHaveBeenCalled();
+        });
+
+        it('should wait for registered node and log debug message', async () => {
+            const nodeUid = 'test-node-1';
+            debouncer.loadingNode(nodeUid);
+
+            const waitPromise = debouncer.waitForLoadingNode(nodeUid);
+
+            expect(mockLogger.debug).toHaveBeenCalledWith(`debouncer: Wait for: ${nodeUid}`);
+            debouncer.finishedLoadingNode(nodeUid);
+            await waitPromise;
+        });
+    });
+});