@protontech/drive-sdk 0.3.2 → 0.4.0

package/src/internal/nodes/apiService.ts

@@ -6,6 +6,7 @@ import { MemberRole, RevisionState } from '../../interface/nodes';
 import {
     DriveAPIService,
     drivePaths,
+    InvalidRequirementsAPIError,
     isCodeOk,
     nodeTypeNumberToNodeType,
     permissionsToMemberRole,
@@ -13,7 +14,8 @@ import {
 import { asyncIteratorRace } from '../asyncIteratorRace';
 import { batch } from '../batch';
 import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from '../uids';
-import { EncryptedNode, EncryptedRevision, Thumbnail } from './interface';
+import { NodeOutOfSyncError } from './errors';
+import { EncryptedNode, EncryptedRevision, FilterOptions, Thumbnail } from './interface';
 
 // This is the number of calls to the API that are made in parallel.
 const API_CONCURRENCY = 15;
@@ -48,6 +50,13 @@ type PutMoveNodeRequest = Extract<
 type PutMoveNodeResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['responses']['200']['content']['application/json'];
 
+type PostCopyNodeRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCopyNodeResponse =
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['responses']['200']['content']['application/json'];
+
 type PostTrashNodesRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['requestBody'],
     { content: object }
@@ -108,7 +117,7 @@ export class NodeAPIService {
     }
 
     async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
-        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, signal);
+        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, undefined, signal);
         const result = await nodesGenerator.next();
         if (!result.value) {
             throw new ValidationError(c('Error').t`Node not found`);
@@ -117,7 +126,12 @@ export class NodeAPIService {
         return result.value;
     }
 
-    async *iterateNodes(nodeUids: string[], ownVolumeId: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
+    async *iterateNodes(
+        nodeUids: string[],
+        ownVolumeId: string,
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<EncryptedNode> {
         const allNodeIds = nodeUids.map(splitNodeUid);
 
         const nodeIdsByVolumeId = new Map<string, string[]>();
@@ -139,7 +153,13 @@ export class NodeAPIService {
                 const isAdmin = volumeId === ownVolumeId;
 
                 yield (async function* () {
-                    const errorsPerVolume = yield* iterateNodesPerVolume(volumeId, nodeIds, isAdmin, signal);
+                    const errorsPerVolume = yield* iterateNodesPerVolume(
+                        volumeId,
+                        nodeIds,
+                        isAdmin,
+                        filterOptions,
+                        signal,
+                    );
                     if (errorsPerVolume.length) {
                         errors.push(...errorsPerVolume);
                     }
@@ -159,6 +179,7 @@ export class NodeAPIService {
         volumeId: string,
         nodeIds: string[],
         isOwnVolumeId: boolean,
+        filterOptions?: FilterOptions,
         signal?: AbortSignal,
     ): AsyncGenerator<EncryptedNode, unknown[]> {
         const errors: unknown[] = [];
@@ -174,7 +195,11 @@ export class NodeAPIService {
 
             for (const link of response.Links) {
                 try {
-                    yield linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    const encryptedNode = linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    if (filterOptions?.type && encryptedNode.type !== filterOptions.type) {
+                        continue;
+                    }
+                    yield encryptedNode;
                 } catch (error: unknown) {
                     this.logger.error(`Failed to transform node ${link.Link.LinkID}`, error);
                     errors.push(error);
@@ -186,13 +211,25 @@ export class NodeAPIService {
     }
 
     // Improvement requested: load next page sooner before all IDs are yielded.
-    async *iterateChildrenNodeUids(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<string> {
+    async *iterateChildrenNodeUids(
+        parentNodeUid: string,
+        onlyFolders: boolean = false,
+        signal?: AbortSignal,
+    ): AsyncGenerator<string> {
         const { volumeId, nodeId } = splitNodeUid(parentNodeUid);
 
         let anchor = '';
         while (true) {
+            const queryParams = new URLSearchParams();
+            if (onlyFolders) {
+                queryParams.set('FoldersOnly', '1');
+            }
+            if (anchor) {
+                queryParams.set('AnchorID', anchor);
+            }
+
             const response = await this.apiService.get<GetChildrenResponse>(
-                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${anchor ? `AnchorID=${anchor}` : ''}`,
+                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${queryParams.toString()}`,
                 signal,
             );
             for (const linkID of response.LinkIDs) {
@@ -251,16 +288,28 @@ export class NodeAPIService {
     ): Promise<void> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
 
-        await this.apiService.put<Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>, PutRenameNodeResponse>(
-            `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
-            {
-                Name: newNode.encryptedName,
-                NameSignatureEmail: newNode.nameSignatureEmail,
-                Hash: newNode.hash,
-                OriginalHash: originalNode.hash || null,
-            },
-            signal,
-        );
+        try {
+            await this.apiService.put<
+                Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>,
+                PutRenameNodeResponse
+            >(
+                `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
+                {
+                    Name: newNode.encryptedName,
+                    NameSignatureEmail: newNode.nameSignatureEmail,
+                    Hash: newNode.hash,
+                    OriginalHash: originalNode.hash || null,
+                },
+                signal,
+            );
+        } catch (error: unknown) {
+            // API returns generic code 2000 when node is out of sync.
+            // We map this to specific error for clarity.
+            if (error instanceof InvalidRequirementsAPIError) {
+                throw new NodeOutOfSyncError(error.message, error.code, { cause: error });
+            }
+            throw error;
+        }
     }
 
     async moveNode(
@@ -303,6 +352,43 @@ export class NodeAPIService {
         );
     }
 
+    async copyNode(
+        nodeUid: string,
+        newNode: {
+            parentUid: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature?: string;
+            signatureEmail?: string;
+            encryptedName: string;
+            nameSignatureEmail?: string;
+            hash: string;
+        },
+        signal?: AbortSignal,
+    ): Promise<string> {
+        const { volumeId, nodeId } = splitNodeUid(nodeUid);
+        const { volumeId: parentVolumeId, nodeId: parentNodeId } = splitNodeUid(newNode.parentUid);
+
+        const response = await this.apiService.post<PostCopyNodeRequest, PostCopyNodeResponse>(
+            `drive/volumes/${volumeId}/links/${nodeId}/copy`,
+            {
+                TargetVolumeID: parentVolumeId,
+                TargetParentLinkID: parentNodeId,
+                NodePassphrase: newNode.armoredNodePassphrase,
+                // @ts-expect-error: API accepts NodePassphraseSignature as optional.
+                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                // @ts-expect-error: API accepts SignatureEmail as optional.
+                SignatureEmail: newNode.signatureEmail,
+                Name: newNode.encryptedName,
+                // @ts-expect-error: API accepts NameSignatureEmail as optional.
+                NameSignatureEmail: newNode.nameSignatureEmail,
+                Hash: newNode.hash,
+            },
+            signal,
+        );
+
+        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);

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

@@ -985,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' },
@@ -1012,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',
@@ -1056,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 () => {
@@ -1079,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

@@ -601,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 },

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/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.
  */
@@ -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
                 );
             });
 

package/src/internal/nodes/nodesAccess.ts

@@ -12,7 +12,14 @@ import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
 import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from './extendedAttributes';
-import { SharesService, EncryptedNode, DecryptedUnparsedNode, DecryptedNode, DecryptedNodeKeys } from './interface';
+import {
+    SharesService,
+    EncryptedNode,
+    DecryptedUnparsedNode,
+    DecryptedNode,
+    DecryptedNodeKeys,
+    FilterOptions,
+} from './interface';
 import { validateNodeName } from './validations';
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
 
@@ -49,8 +56,8 @@ export class NodesAccess {
         this.shareService = shareService;
     }
 
-    async getMyFilesRootFolder() {
-        const { volumeId, rootNodeId } = await this.shareService.getMyFilesIDs();
+    async getVolumeRootFolder() {
+        const { volumeId, rootNodeId } = await this.shareService.getOwnVolumeIDs();
         const nodeUid = makeNodeUid(volumeId, rootNodeId);
         return this.getNode(nodeUid);
     }
@@ -71,12 +78,16 @@ export class NodesAccess {
         return node;
     }
 
-    async *iterateFolderChildren(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    async *iterateFolderChildren(
+        parentNodeUid: string,
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
         // Ensure the parent is loaded and up-to-date.
         const parentNode = await this.getNode(parentNodeUid);
 
         const batchLoading = new BatchLoading<string, DecryptedNode>({
-            iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal),
+            iterateItems: (nodeUids) => this.loadNodes(nodeUids, filterOptions, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
 
@@ -84,6 +95,9 @@ export class NodesAccess {
         if (areChildrenCached) {
             for await (const node of this.cache.iterateChildren(parentNodeUid)) {
                 if (node.ok && !node.node.isStale) {
+                    if (filterOptions?.type && node.node.type !== filterOptions.type) {
+                        continue;
+                    }
                     yield node.node;
                 } else {
                     yield* batchLoading.load(node.uid);
@@ -94,13 +108,17 @@ export class NodesAccess {
         }
 
         this.logger.debug(`Folder ${parentNodeUid} children are not cached`);
-        for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, signal)) {
+        const onlyFolders = filterOptions?.type === NodeType.Folder;
+        for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, onlyFolders, signal)) {
             let node;
             try {
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
             if (node && !node.isStale) {
+                if (filterOptions?.type && node.type !== filterOptions.type) {
+                    continue;
+                }
                 yield node;
             } else {
                 this.logger.debug(`Node ${nodeUid} from ${parentNodeUid} is ${node?.isStale ? 'stale' : 'not cached'}`);
@@ -108,14 +126,18 @@ export class NodesAccess {
             }
         }
         yield* batchLoading.loadRest();
-        await this.cache.setFolderChildrenLoaded(parentNodeUid);
+
+        // If some nodes were filtered out, we don't have the folder fully loaded.
+        if (!filterOptions) {
+            await this.cache.setFolderChildrenLoaded(parentNodeUid);
+        }
     }
 
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const { volumeId } = await this.shareService.getMyFilesIDs();
+        const { volumeId } = await this.shareService.getOwnVolumeIDs();
         const batchLoading = new BatchLoading<string, DecryptedNode>({
-            iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal),
+            iterateItems: (nodeUids) => this.loadNodes(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
@@ -136,7 +158,7 @@ export class NodesAccess {
 
     async *iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
         const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({
-            iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal),
+            iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
         for await (const result of this.cache.iterateNodes(nodeUids)) {
@@ -186,13 +208,17 @@ export class NodesAccess {
     }
 
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
-        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
         const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
         return this.decryptNode(encryptedNode);
     }
 
-    private async *loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        for await (const result of this.loadNodesWithMissingReport(nodeUids, signal)) {
+    private async *loadNodes(
+        nodeUids: string[],
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
+        for await (const result of this.loadNodesWithMissingReport(nodeUids, filterOptions, signal)) {
             if ('missingUid' in result) {
                 continue;
             }
@@ -202,14 +228,15 @@ export class NodesAccess {
 
     private async *loadNodesWithMissingReport(
         nodeUids: string[],
+        filterOptions?: FilterOptions,
         signal?: AbortSignal,
     ): AsyncGenerator<DecryptedNode | MissingNode> {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
-        const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
+        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
 
-        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, signal);
+        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
         const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {