@protontech/drive-sdk 0.3.1 → 0.4.0

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

@@ -3,6 +3,7 @@ import { MemberRole, ProtonDriveAccount, ProtonDriveTelemetry, RevisionState } f
 import { getMockTelemetry } from '../../tests/telemetry';
 import { DecryptedNode, DecryptedNodeKeys, DecryptedUnparsedNode, EncryptedNode, SharesService } from './interface';
 import { NodesCryptoService } from './cryptoService';
+import { NodesCryptoReporter } from './cryptoReporter';
 
 describe('nodesCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;
@@ -74,7 +75,8 @@ describe('nodesCryptoService', () => {
             getVolumeMetricContext: jest.fn().mockResolvedValue('own_volume'),
         };
 
-        cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, sharesService);
+        const nodesCryptoReporter = new NodesCryptoReporter(telemetry, sharesService);
+        cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, nodesCryptoReporter);
     });
 
     const parentKey = 'parentKey' as unknown as PrivateKey;
@@ -983,7 +985,7 @@ describe('nodesCryptoService', () => {
         });
     });
 
-    describe('moveNode', () => {
+    describe('encryptNodeWithNewParent', () => {
         it('should encrypt node data for move operation', async () => {
             const node = {
                 name: { ok: true, value: 'testFile.txt' },
@@ -1010,7 +1012,7 @@ describe('nodesCryptoService', () => {
                 armoredPassphraseSignature: 'passphraseSignature',
             });
 
-            const result = await cryptoService.moveNode(node, keys as any, parentKeys, address);
+            const result = await cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, address);
 
             expect(result).toEqual({
                 encryptedName: 'encryptedNodeName',
@@ -1054,9 +1056,9 @@ describe('nodesCryptoService', () => {
                 addressKey: 'addressKey' as any,
             };
 
-            await expect(cryptoService.moveNode(node, keys as any, parentKeys, address)).rejects.toThrow(
-                'Moving item to a non-folder is not allowed',
-            );
+            await expect(
+                cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, address),
+            ).rejects.toThrow('Moving item to a non-folder is not allowed');
         });
 
         it('should throw error when node has invalid name', async () => {
@@ -1077,9 +1079,9 @@ describe('nodesCryptoService', () => {
                 addressKey: 'addressKey' as any,
             };
 
-            await expect(cryptoService.moveNode(node, keys as any, parentKeys, address)).rejects.toThrow(
-                'Cannot move item without a valid name, please rename the item first',
-            );
+            await expect(
+                cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, address),
+            ).rejects.toThrow('Cannot move item without a valid name, please rename the item first');
         });
     });
 });

package/src/internal/nodes/cryptoService.ts

@@ -7,27 +7,49 @@ import {
     Result,
     Author,
     AnonymousUser,
-    ProtonDriveAccount,
     ProtonDriveTelemetry,
     Logger,
     MetricsDecryptionErrorField,
     MetricVerificationErrorField,
     Membership,
+    ProtonDriveAccount,
 } from '../../interface';
 import { ValidationError } from '../../errors';
-import { getErrorMessage, getVerificationMessage } from '../errors';
-import { splitNodeUid } from '../uids';
+import { getErrorMessage } from '../errors';
 import {
     EncryptedNode,
     EncryptedNodeFolderCrypto,
     DecryptedUnparsedNode,
     DecryptedNode,
     DecryptedNodeKeys,
-    SharesService,
     EncryptedRevision,
     DecryptedUnparsedRevision,
 } from './interface';
 
+export interface NodesCryptoReporter {
+    handleClaimedAuthor(
+        node: NodesCryptoReporterNode,
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys?: boolean,
+    ): Promise<Author>;
+    reportDecryptionError(node: NodesCryptoReporterNode, field: MetricsDecryptionErrorField, error: unknown): void;
+    reportVerificationError(
+        node: NodesCryptoReporterNode,
+        field: MetricVerificationErrorField,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+    ): void;
+}
+
+type NodesCryptoReporterNode = {
+    uid: string;
+    creationTime: Date;
+};
+
 /**
  * Provides crypto operations for nodes metadata.
  *
@@ -41,20 +63,16 @@ import {
 export class NodesCryptoService {
     private logger: Logger;
 
-    private reportedDecryptionErrors = new Set<string>();
-    private reportedVerificationErrors = new Set<string>();
-
     constructor(
-        private telemetry: ProtonDriveTelemetry,
-        private driveCrypto: DriveCrypto,
+        telemetry: ProtonDriveTelemetry,
+        protected driveCrypto: DriveCrypto,
         private account: ProtonDriveAccount,
-        private shareService: SharesService,
+        private reporter: NodesCryptoReporter,
     ) {
-        this.telemetry = telemetry;
         this.logger = telemetry.getLogger('nodes-crypto');
         this.driveCrypto = driveCrypto;
         this.account = account;
-        this.shareService = shareService;
+        this.reporter = reporter;
     }
 
     async decryptNode(
@@ -107,7 +125,7 @@ export class NodesCryptoService {
             passphraseSessionKey = keyResult.passphraseSessionKey;
             keyAuthor = keyResult.author;
         } catch (error: unknown) {
-            void this.reportDecryptionError(node, 'nodeKey', error);
+            void this.reporter.reportDecryptionError(node, 'nodeKey', error);
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt node key: ${message}`;
             const { name, author: nameAuthor } = await namePromise;
@@ -159,7 +177,7 @@ export class NodesCryptoService {
                 hashKey = hashKeyResult.hashKey;
                 hashKeyAuthor = hashKeyResult.author;
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeHashKey', error);
+                void this.reporter.reportDecryptionError(node, 'nodeHashKey', error);
                 errors.push(error);
             }
 
@@ -170,7 +188,7 @@ export class NodesCryptoService {
                 };
                 folderExtendedAttributesAuthor = extendedAttributesResult.author;
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeExtendedAttributes', error);
+                void this.reporter.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 errors.push(error);
             }
         }
@@ -194,7 +212,7 @@ export class NodesCryptoService {
             try {
                 activeRevision = resultOk(await activeRevisionPromise);
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeExtendedAttributes', error);
+                void this.reporter.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 const message = getErrorMessage(error);
                 const errorMessage = c('Error').t`Failed to decrypt active revision: ${message}`;
                 activeRevision = resultError(new Error(errorMessage));
@@ -205,7 +223,7 @@ export class NodesCryptoService {
                 contentKeyPacketSessionKey = keySessionKeyResult.sessionKey;
                 contentKeyPacketAuthor =
                     keySessionKeyResult.verified !== undefined &&
-                    (await this.handleClaimedAuthor(
+                    (await this.reporter.handleClaimedAuthor(
                         node,
                         'nodeContentKey',
                         c('Property').t`content key`,
@@ -214,7 +232,7 @@ export class NodesCryptoService {
                         node.encryptedCrypto.signatureEmail,
                     ));
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeContentKey', error);
+                void this.reporter.reportDecryptionError(node, 'nodeContentKey', error);
                 const message = getErrorMessage(error);
                 const errorMessage = c('Error').t`Failed to decrypt content key: ${message}`;
                 contentKeyPacketAuthor = resultError({
@@ -295,7 +313,7 @@ export class NodesCryptoService {
             passphrase: key.passphrase,
             key: key.key,
             passphraseSessionKey: key.passphraseSessionKey,
-            author: await this.handleClaimedAuthor(
+            author: await this.reporter.handleClaimedAuthor(
                 node,
                 'nodeKey',
                 c('Property').t`key`,
@@ -326,7 +344,7 @@ export class NodesCryptoService {
 
             return {
                 name: resultOk(name),
-                author: await this.handleClaimedAuthor(
+                author: await this.reporter.handleClaimedAuthor(
                     node,
                     'nodeName',
                     c('Property').t`name`,
@@ -337,7 +355,7 @@ export class NodesCryptoService {
                 ),
             };
         } catch (error: unknown) {
-            void this.reportDecryptionError(node, 'nodeName', error);
+            void this.reporter.reportDecryptionError(node, 'nodeName', error);
             const errorMessage = getErrorMessage(error);
             return {
                 name: resultError(new Error(errorMessage)),
@@ -378,7 +396,7 @@ export class NodesCryptoService {
                     inviterEmailKeys || [],
                 );
 
-                sharedBy = await this.handleClaimedAuthor(
+                sharedBy = await this.reporter.handleClaimedAuthor(
                     node,
                     'membershipInviter',
                     c('Property').t`membership`,
@@ -387,7 +405,7 @@ export class NodesCryptoService {
                     node.encryptedCrypto.membership.inviterEmail,
                 );
             } catch (error: unknown) {
-                void this.reportVerificationError(node, 'membershipInviter');
+                void this.reporter.reportVerificationError(node, 'membershipInviter');
                 this.logger.error('Failed to verify invitation', error);
                 sharedBy = resultError({
                     claimedAuthor: node.encryptedCrypto.membership.inviterEmail,
@@ -428,7 +446,7 @@ export class NodesCryptoService {
 
         return {
             hashKey,
-            author: await this.handleClaimedAuthor(
+            author: await this.reporter.handleClaimedAuthor(
                 node,
                 'nodeHashKey',
                 c('Property').t`hash key`,
@@ -491,7 +509,7 @@ export class NodesCryptoService {
 
         return {
             extendedAttributes,
-            author: await this.handleClaimedAuthor(
+            author: await this.reporter.handleClaimedAuthor(
                 node,
                 'nodeExtendedAttributes',
                 c('Property').t`attributes`,
@@ -509,6 +527,7 @@ export class NodesCryptoService {
         extendedAttributes?: string,
     ): Promise<{
         encryptedCrypto: EncryptedNodeFolderCrypto & {
+            armoredNodePassphraseSignature: string;
             // signatureEmail and nameSignatureEmail are not optional.
             signatureEmail: string;
             nameSignatureEmail: string;
@@ -582,7 +601,7 @@ export class NodesCryptoService {
         };
     }
 
-    async moveNode(
+    async encryptNodeWithNewParent(
         node: Pick<DecryptedNode, 'name'>,
         keys: { passphrase: string; passphraseSessionKey: SessionKey; nameSessionKey: SessionKey },
         parentKeys: { key: PrivateKey; hashKey: Uint8Array },
@@ -626,118 +645,6 @@ export class NodesCryptoService {
             nameSignatureEmail: email,
         };
     }
-
-    private async handleClaimedAuthor(
-        node: { uid: string; creationTime: Date },
-        field: MetricVerificationErrorField,
-        signatureType: string,
-        verified: VERIFICATION_STATUS,
-        verificationErrors?: Error[],
-        claimedAuthor?: string,
-        notAvailableVerificationKeys = false,
-    ): Promise<Author> {
-        const author = handleClaimedAuthor(
-            signatureType,
-            verified,
-            verificationErrors,
-            claimedAuthor,
-            notAvailableVerificationKeys,
-        );
-        if (!author.ok) {
-            void this.reportVerificationError(node, field, verificationErrors, claimedAuthor);
-        }
-        return author;
-    }
-
-    private async reportVerificationError(
-        node: { uid: string; creationTime: Date },
-        field: MetricVerificationErrorField,
-        verificationErrors?: Error[],
-        claimedAuthor?: string,
-    ) {
-        if (this.reportedVerificationErrors.has(node.uid)) {
-            return;
-        }
-        this.reportedVerificationErrors.add(node.uid);
-
-        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
-
-        let addressMatchingDefaultShare, volumeType;
-        try {
-            const { volumeId } = splitNodeUid(node.uid);
-            const { email } = await this.shareService.getMyFilesShareMemberEmailKey();
-            addressMatchingDefaultShare = claimedAuthor ? claimedAuthor === email : undefined;
-            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
-        } catch (error: unknown) {
-            this.logger.error('Failed to check if claimed author matches default share', error);
-        }
-
-        this.logger.warn(
-            `Failed to verify ${field} for node ${node.uid} (from before 2024: ${fromBefore2024}, matching address: ${addressMatchingDefaultShare})`,
-        );
-
-        this.telemetry.recordMetric({
-            eventName: 'verificationError',
-            volumeType,
-            field,
-            addressMatchingDefaultShare,
-            fromBefore2024,
-            error: verificationErrors?.map((e) => e.message).join(', '),
-            uid: node.uid,
-        });
-    }
-
-    private async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
-        if (this.reportedDecryptionErrors.has(node.uid)) {
-            return;
-        }
-
-        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
-
-        let volumeType;
-        try {
-            const { volumeId } = splitNodeUid(node.uid);
-            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
-        } catch (error: unknown) {
-            this.logger.error('Failed to get metric context', error);
-        }
-
-        this.logger.error(`Failed to decrypt node ${node.uid} (from before 2024: ${fromBefore2024})`, error);
-
-        this.telemetry.recordMetric({
-            eventName: 'decryptionError',
-            volumeType,
-            field,
-            fromBefore2024,
-            error,
-            uid: node.uid,
-        });
-        this.reportedDecryptionErrors.add(node.uid);
-    }
-}
-
-/**
- * @param signatureType - Must be translated before calling this function.
- */
-function handleClaimedAuthor(
-    signatureType: string,
-    verified: VERIFICATION_STATUS,
-    verificationErrors?: Error[],
-    claimedAuthor?: string,
-    notAvailableVerificationKeys = false,
-): Author {
-    if (!claimedAuthor && notAvailableVerificationKeys) {
-        return resultOk(null as AnonymousUser);
-    }
-
-    if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
-        return resultOk(claimedAuthor || (null as AnonymousUser));
-    }
-
-    return resultError({
-        claimedAuthor: claimedAuthor,
-        error: getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
-    });
 }
 
 function getClaimedAuthor(

package/src/internal/nodes/errors.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../errors";
+
+export class NodeOutOfSyncError extends ValidationError {
+    name = 'NodeOutOfSyncError';
+}

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

@@ -52,7 +52,7 @@ describe('nodesModules integration tests', () => {
         driveCrypto = {};
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
         };
 
         nodesModule = initNodesModule(

package/src/internal/nodes/index.ts

@@ -10,6 +10,7 @@ import { NodeAPIService } from './apiService';
 import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { NodesCryptoReporter } from './cryptoReporter';
 import { SharesService } from './interface';
 import { NodesAccess } from './nodesAccess';
 import { NodesManagement } from './nodesManagement';
@@ -40,7 +41,8 @@ export function initNodesModule(
     const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
     const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
-    const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, sharesService);
+    const cryptoReporter = new NodesCryptoReporter(telemetry, sharesService);
+    const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
     const nodesAccess = new NodesAccess(
         telemetry.getLogger('nodes'),
         api,

package/src/internal/nodes/interface.ts

@@ -12,6 +12,10 @@ import {
     RevisionState,
 } from '../../interface';
 
+export type FilterOptions = {
+    type?: NodeType;
+};
+
 /**
  * Internal common node interface for both encrypted or decrypted node.
  */
@@ -56,7 +60,7 @@ export interface EncryptedNodeCrypto {
     nameSignatureEmail?: string;
     armoredKey: string;
     armoredNodePassphrase: string;
-    armoredNodePassphraseSignature: string;
+    armoredNodePassphraseSignature?: string;
     membership?: {
         inviterEmail: string;
         base64MemberSharePassphraseKeyPacket: string;
@@ -172,7 +176,7 @@ export interface DecryptedRevision extends Revision {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
     getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;

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

@@ -46,7 +46,7 @@ describe('nodesAccess', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         shareService = {
-            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             getSharePrivateKey: jest.fn(),
         };
 
@@ -209,7 +209,12 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith([node2.uid, node3.uid], 'volumeId', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(
+                    [node2.uid, node3.uid],
+                    'volumeId',
+                    undefined, // filterOptions
+                    undefined, // signal
+                );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(2);
                 expect(cache.setNode).toHaveBeenCalledTimes(2);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(2);
@@ -226,7 +231,11 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith(
+                    'volumeId~parentNodeid',
+                    false, // onlyFolders
+                    undefined, // signal
+                );
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
                 expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('volumeId~parentNodeid');
             });
@@ -247,11 +256,16 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith(
+                    'volumeId~parentNodeid',
+                    false, // onlyFolders
+                    undefined, // signal
+                );
                 expect(apiService.iterateNodes).toHaveBeenCalledWith(
                     ['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'],
                     'volumeId',
-                    undefined,
+                    undefined, // filterOptions
+                    undefined, // signal
                 );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
@@ -320,6 +334,50 @@ describe('nodesAccess', () => {
                     expect(error.cause).toEqual([new DecryptionError('Decryption failed')]);
                 }
             });
+
+            it('should return only filtered nodes from cache', async () => {
+                cache.isFolderChildrenLoaded = jest.fn().mockResolvedValue(true);
+                cache.iterateChildren = jest.fn().mockImplementation(async function* () {
+                    yield { ok: true, node: { ...node1, type: NodeType.Folder } };
+                    yield { ok: true, node: { ...node2, type: NodeType.Folder } };
+                    yield { ok: true, node: { ...node3, type: NodeType.File } };
+                    yield { ok: true, node: { ...node4, type: NodeType.File } };
+                });
+
+                const result = await Array.fromAsync(
+                    access.iterateFolderChildren('volumeId~parentNodeid', { type: NodeType.Folder }),
+                );
+
+                expect(result).toMatchObject([node1, node2]);
+                expect(cache.setFolderChildrenLoaded).not.toHaveBeenCalled();
+            });
+
+            it.only('should return only filtered nodes from API', async () => {
+                cache.isFolderChildrenLoaded = jest.fn().mockResolvedValue(false);
+                cache.getNode = jest.fn().mockImplementation((uid: string) => {
+                    if (uid === parentNode.uid) {
+                        return parentNode;
+                    }
+                    throw new Error('Entity not found');
+                });
+                apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
+                    yield 'volumeId~node1';
+                    yield 'volumeId~node2';
+                    yield 'volumeId~node3';
+                    yield 'volumeId~node4';
+                });
+                apiService.iterateNodes = jest.fn().mockImplementation(async function* () {
+                    yield { ...node1, parentUid: 'volumeId~parentNodeId', type: NodeType.Folder };
+                    yield { ...node2, parentUid: 'volumeId~parentNodeId', type: NodeType.Folder };
+                });
+
+                const result = await Array.fromAsync(
+                    access.iterateFolderChildren('volumeId~parentNodeid', { type: NodeType.Folder }),
+                );
+
+                expect(result).toMatchObject([node1, node2]);
+                expect(cache.setFolderChildrenLoaded).not.toHaveBeenCalled();
+            });
         });
 
         describe('iterateTrashedNodes', () => {
@@ -330,7 +388,7 @@ describe('nodesAccess', () => {
             const node4 = { uid: 'volumeId~node4', isStale: false } as DecryptedNode;
 
             beforeEach(() => {
-                shareService.getMyFilesIDs = jest.fn().mockResolvedValue({ volumeId });
+                shareService.getOwnVolumeIDs = jest.fn().mockResolvedValue({ volumeId });
                 apiService.iterateTrashedNodeUids = jest.fn().mockImplementation(async function* () {
                     yield node1.uid;
                     yield node2.uid;
@@ -359,7 +417,8 @@ describe('nodesAccess', () => {
                 expect(apiService.iterateNodes).toHaveBeenCalledWith(
                     ['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'],
                     volumeId,
-                    undefined,
+                    undefined, // filterOptions
+                    undefined, // signal
                 );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
@@ -417,7 +476,8 @@ describe('nodesAccess', () => {
                 expect(apiService.iterateNodes).toHaveBeenCalledWith(
                     ['volumeId~node2', 'volumeId~node3'],
                     'volumeId',
-                    undefined,
+                    undefined, // filterOptions
+                    undefined, // signal
                 );
             });