@protontech/drive-sdk 0.5.1 → 0.6.1

package/src/interface/upload.ts

@@ -32,7 +32,7 @@ export type UploadMetadata = {
     overrideExistingDraftByOtherClient?: boolean;
 };
 
-export interface FileRevisionUploader {
+export interface FileUploader {
     /**
      * Uploads a file from a stream.
      *
@@ -64,18 +64,6 @@ export interface FileRevisionUploader {
     ): Promise<UploadController>;
 }
 
-export interface FileUploader extends FileRevisionUploader {
-    /**
-     * Returns the available name for the file.
-     *
-     * The function will return a name that includes the original name with the
-     * available index. The name is guaranteed to be unique in the parent folder.
-     *
-     * Example new name: `file (2).txt`.
-     */
-    getAvailableName(): Promise<string>;
-}
-
 export interface UploadController {
     pause(): void;
     resume(): void;

package/src/internal/devices/interface.ts

@@ -13,7 +13,7 @@ export type DeviceMetadata = {
 };
 
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string }>;
     getMyFilesShareMemberEmailKey(): Promise<{
         addressId: string;
         email: string;

package/src/internal/devices/manager.test.ts

@@ -30,7 +30,7 @@ describe('DevicesManager', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getOwnVolumeIDs: jest.fn(),
+            getRootIDs: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {};
@@ -74,13 +74,13 @@ describe('DevicesManager', () => {
             shareId: 'shareid',
         } as DeviceMetadata;
 
-        sharesService.getOwnVolumeIDs.mockResolvedValue({ volumeId });
+        sharesService.getRootIDs.mockResolvedValue({ volumeId });
         cryptoService.createDevice.mockResolvedValue({ address, shareKey, node });
         apiService.createDevice.mockResolvedValue(createdDevice);
 
         const result = await manager.createDevice(name, deviceType);
 
-        expect(sharesService.getOwnVolumeIDs).toHaveBeenCalled();
+        expect(sharesService.getRootIDs).toHaveBeenCalled();
         expect(cryptoService.createDevice).toHaveBeenCalledWith(name);
         expect(apiService.createDevice).toHaveBeenCalledWith(
             { volumeId, type: deviceType },

package/src/internal/devices/manager.ts

@@ -47,7 +47,7 @@ export class DevicesManager {
     }
 
     async createDevice(name: string, deviceType: DeviceType): Promise<Device> {
-        const { volumeId } = await this.sharesService.getOwnVolumeIDs();
+        const { volumeId } = await this.sharesService.getRootIDs();
         const { address, shareKey, node } = await this.cryptoService.createDevice(name);
 
         const device = await this.apiService.createDevice(

package/src/internal/errors.test.ts

@@ -1,5 +1,6 @@
 import { VERIFICATION_STATUS } from '../crypto';
-import { getVerificationMessage } from './errors';
+import { AbortError, ConnectionError, RateLimitedError, ValidationError } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from './errors';
 
 describe('getVerificationMessage', () => {
     const testCases: [VERIFICATION_STATUS, Error[] | undefined, string | undefined, boolean, string][] = [
@@ -53,3 +54,63 @@ describe('getVerificationMessage', () => {
         });
     }
 });
+
+describe('isNotApplicationError', () => {
+    describe('SDK errors that should be ignored', () => {
+        it('returns true for AbortError', () => {
+            const error = new AbortError('Operation aborted');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for ValidationError', () => {
+            const error = new ValidationError('Validation failed');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for RateLimitedError', () => {
+            const error = new RateLimitedError('Rate limited');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for ConnectionError', () => {
+            const error = new ConnectionError('Connection failed');
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+    });
+
+    describe('General errors with specific names that should be ignored', () => {
+        it('returns true for Error with name AbortError', () => {
+            const error = new Error('Aborted');
+            error.name = 'AbortError';
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for Error with name OfflineError', () => {
+            const error = new Error('Offline');
+            error.name = 'OfflineError';
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+
+        it('returns true for Error with name TimeoutError', () => {
+            const error = new Error('Timeout');
+            error.name = 'TimeoutError';
+            expect(isNotApplicationError(error)).toBe(true);
+        });
+    });
+
+    describe('Errors that should not be ignored', () => {
+        it('returns false for regular Error', () => {
+            const error = new Error('Regular error');
+            expect(isNotApplicationError(error)).toBe(false);
+        });
+
+        it('returns false for undefined', () => {
+            expect(isNotApplicationError(undefined)).toBe(false);
+        });
+
+        it('returns false for non-Error object', () => {
+            const error = { message: 'Not an error' };
+            expect(isNotApplicationError(error)).toBe(false);
+        });
+    });
+});

package/src/internal/errors.ts

@@ -1,6 +1,7 @@
 import { c } from 'ttag';
 
 import { VERIFICATION_STATUS } from '../crypto';
+import { AbortError, ConnectionError, RateLimitedError, ValidationError } from '../errors';
 
 export function getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : c('Error').t`Unknown error`;
@@ -36,3 +37,29 @@ export function getVerificationMessage(
         ? c('Error').t`Signature verification for ${signatureType} failed`
         : c('Error').t`Signature verification failed`;
 }
+
+/**
+ * Returns true if the error is not an application error (it is for example
+ * a network error failing to fetch keys) and can be ignored for telemetry.
+ */
+export function isNotApplicationError(error?: unknown): boolean {
+    // SDK errors.
+    if (
+        error instanceof AbortError ||
+        error instanceof ValidationError ||
+        error instanceof RateLimitedError ||
+        error instanceof ConnectionError
+    ) {
+        return true;
+    }
+
+    // General errors that can come from the SDK dependencies (notably Account
+    // dependency which loads the keys for the crypto services).
+    if (error instanceof Error) {
+        if (error.name === 'AbortError' || error.name === 'OfflineError' || error.name === 'TimeoutError') {
+            return true;
+        }
+    }
+
+    return false;
+}

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

@@ -173,7 +173,7 @@ describe('nodeAPIService', () => {
             put: jest.fn(),
         };
 
-        api = new NodeAPIService(getMockLogger(), apiMock);
+        api = new NodeAPIService(getMockLogger(), apiMock, 'clientUid');
     });
 
     describe('getNode', () => {

package/src/internal/nodes/apiService.ts

@@ -102,6 +102,14 @@ type PostRestoreRevisionResponse =
 type DeleteRevisionResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['delete']['responses']['200']['content']['application/json'];
 
+
+type PostCheckAvailableHashesRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCheckAvailableHashesResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['responses']['200']['content']['application/json'];
+
 /**
  * Provides API communication for fetching and manipulating nodes metadata.
  *
@@ -112,9 +120,11 @@ export class NodeAPIService {
     constructor(
         private logger: Logger,
         private apiService: DriveAPIService,
+        private clientUid: string | undefined,
     ) {
         this.logger = logger;
         this.apiService = apiService;
+        this.clientUid = clientUid;
     }
 
     async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
@@ -526,6 +536,38 @@ export class NodeAPIService {
             `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`,
         );
     }
+
+    async checkAvailableHashes(
+        parentNodeUid: string,
+        hashes: string[],
+    ): Promise<{
+        availableHashes: string[];
+        pendingHashes: {
+            hash: string;
+            nodeUid: string;
+            revisionUid: string;
+            clientUid?: string;
+        }[];
+    }> {
+        const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
+        const result = await this.apiService.post<PostCheckAvailableHashesRequest, PostCheckAvailableHashesResponse>(
+            `drive/v2/volumes/${volumeId}/links/${parentNodeId}/checkAvailableHashes`,
+            {
+                Hashes: hashes,
+                ClientUID: this.clientUid ? [this.clientUid] : null,
+            },
+        );
+
+        return {
+            availableHashes: result.AvailableHashes,
+            pendingHashes: result.PendingHashes.map((hash) => ({
+                hash: hash.Hash,
+                nodeUid: makeNodeUid(volumeId, hash.LinkID),
+                revisionUid: makeNodeRevisionUid(volumeId, hash.LinkID, hash.RevisionID),
+                clientUid: hash.ClientUID || undefined,
+            })),
+        };
+    }
 }
 
 type LinkResponse = {

package/src/internal/nodes/cryptoReporter.ts

@@ -9,12 +9,9 @@ import {
     MetricsDecryptionErrorField,
     MetricVerificationErrorField,
 } from '../../interface';
-import { getVerificationMessage } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from '../errors';
 import { splitNodeUid } from '../uids';
-import {
-    EncryptedNode,
-    SharesService,
-} from './interface';
+import { EncryptedNode, SharesService } from './interface';
 
 export class NodesCryptoReporter {
     private logger: Logger;
@@ -92,6 +89,10 @@ export class NodesCryptoReporter {
     }
 
     async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
+        if (isNotApplicationError(error)) {
+            return;
+        }
+
         if (this.reportedDecryptionErrors.has(node.uid)) {
             return;
         }

package/src/internal/nodes/cryptoService.ts

@@ -645,6 +645,15 @@ export class NodesCryptoService {
             nameSignatureEmail: email,
         };
     }
+
+    async generateNameHashes(parentHashKey: Uint8Array, names: string[]): Promise<{ name: string; hash: string }[]> {
+        return Promise.all(
+            names.map(async (name) => ({
+                name,
+                hash: await this.driveCrypto.generateLookupHash(name, parentHashKey),
+            })),
+        );
+    }
 }
 
 function getClaimedAuthor(

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

@@ -53,7 +53,7 @@ describe('nodesModules integration tests', () => {
         driveCrypto = {};
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
         };
 
         nodesModule = initNodesModule(
@@ -64,6 +64,7 @@ describe('nodesModules integration tests', () => {
             account,
             driveCrypto,
             sharesService,
+            'clientUid',
         );
 
         nodesCache = new NodesCache(getMockLogger(), driveEntitiesCache);

package/src/internal/nodes/index.ts

@@ -37,8 +37,9 @@ export function initNodesModule(
     account: ProtonDriveAccount,
     driveCrypto: DriveCrypto,
     sharesService: SharesService,
+    clientUid: string | undefined,
 ) {
-    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService, clientUid);
     const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
     const cryptoReporter = new NodesCryptoReporter(telemetry, sharesService);

package/src/internal/nodes/interface.ts

@@ -177,7 +177,7 @@ export interface DecryptedRevision extends Revision {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
     getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;

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

@@ -0,0 +1,57 @@
+import { splitExtension, joinNameAndExtension } from './nodeName';
+
+describe('nodeName', () => {
+    describe('splitExtension', () => {
+        it('should handle empty string', () => {
+            const result = splitExtension('');
+            expect(result).toEqual(['', '']);
+        });
+
+        it('should split filename with extension correctly', () => {
+            const result = splitExtension('document.pdf');
+            expect(result).toEqual(['document', 'pdf']);
+        });
+
+        it('should handle filename without extension', () => {
+            const result = splitExtension('folder');
+            expect(result).toEqual(['folder', '']);
+        });
+
+        it('should split filename with multiple dots correctly', () => {
+            const result = splitExtension('my.file.name.txt');
+            expect(result).toEqual(['my.file.name', 'txt']);
+        });
+
+        it('should handle filename ending with dot', () => {
+            const result = splitExtension('dot.');
+            expect(result).toEqual(['dot.', '']);
+        });
+
+        it('should handle filename with only extension', () => {
+            const result = splitExtension('.gitignore');
+            expect(result).toEqual(['.gitignore', '']);
+        });
+    });
+
+    describe('joinNameAndExtension', () => {
+        it('should join name, index, and extension correctly', () => {
+            const result = joinNameAndExtension('document', 1, 'pdf');
+            expect(result).toBe('document (1).pdf');
+        });
+
+        it('should handle empty name with extension', () => {
+            const result = joinNameAndExtension('', 2, 'txt');
+            expect(result).toBe('(2).txt');
+        });
+
+        it('should handle name with empty extension', () => {
+            const result = joinNameAndExtension('document', 3, '');
+            expect(result).toBe('document (3)');
+        });
+
+        it('should handle both name and extension empty', () => {
+            const result = joinNameAndExtension('', 4, '');
+            expect(result).toBe('(4)');
+        });
+    });
+});

package/src/internal/nodes/nodeName.ts

@@ -0,0 +1,26 @@
+/**
+ * Split a filename into `[name, extension]`
+ */
+export function splitExtension(filename = ''): [string, string] {
+    const endIdx = filename.lastIndexOf('.');
+    if (endIdx === -1 || endIdx === 0 || endIdx === filename.length - 1) {
+        return [filename, ''];
+    }
+    return [filename.slice(0, endIdx), filename.slice(endIdx + 1)];
+}
+
+/**
+ * Join a filename into `name (index).extension`
+ */
+export function joinNameAndExtension(name: string, index: number, extension: string): string {
+    if (!name && !extension) {
+        return `(${index})`;
+    }
+    if (!name) {
+        return `(${index}).${extension}`;
+    }
+    if (!extension) {
+        return `${name} (${index})`;
+    }
+    return `${name} (${index}).${extension}`;
+}

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 = {
-            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             getSharePrivateKey: jest.fn(),
         };
 
@@ -388,7 +388,7 @@ describe('nodesAccess', () => {
             const node4 = { uid: 'volumeId~node4', isStale: false } as DecryptedNode;
 
             beforeEach(() => {
-                shareService.getOwnVolumeIDs = jest.fn().mockResolvedValue({ volumeId });
+                shareService.getRootIDs = jest.fn().mockResolvedValue({ volumeId });
                 apiService.iterateTrashedNodeUids = jest.fn().mockImplementation(async function* () {
                     yield node1.uid;
                     yield node2.uid;

package/src/internal/nodes/nodesAccess.ts

@@ -61,7 +61,7 @@ export class NodesAccess {
         private cryptoService: NodesCryptoService,
         private shareService: Pick<
             SharesService,
-            'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
+            'getRootIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
         >,
     ) {
         this.logger = telemetry.getLogger('nodes');
@@ -74,7 +74,7 @@ export class NodesAccess {
     }
 
     async getVolumeRootFolder() {
-        const { volumeId, rootNodeId } = await this.shareService.getOwnVolumeIDs();
+        const { volumeId, rootNodeId } = await this.shareService.getRootIDs();
         const nodeUid = makeNodeUid(volumeId, rootNodeId);
         return this.getNode(nodeUid);
     }
@@ -154,7 +154,7 @@ export class NodesAccess {
 
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const { volumeId } = await this.shareService.getOwnVolumeIDs();
+        const { volumeId } = await this.shareService.getRootIDs();
         const batchLoading = new BatchLoading<string, DecryptedNode>({
             iterateItems: (nodeUids) => this.loadNodes(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
@@ -230,7 +230,7 @@ export class NodesAccess {
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
         this.debouncer.loadingNode(nodeUid);
         try {
-            const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+            const { volumeId: ownVolumeId } = await this.shareService.getRootIDs();
             const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
             return this.decryptNode(encryptedNode);
         } finally {
@@ -259,7 +259,7 @@ export class NodesAccess {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
-        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+        const { volumeId: ownVolumeId } = await this.shareService.getRootIDs();
 
         const apiNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
 

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

@@ -61,6 +61,10 @@ describe('NodesManagement', () => {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
             createFolder: jest.fn(),
+            checkAvailableHashes: jest.fn().mockResolvedValue({
+                availableHashes: ['name1Hash'],
+                pendingHashes: [],
+            }),
         };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoCache = {
@@ -75,6 +79,20 @@ describe('NodesManagement', () => {
             }),
             encryptNodeWithNewParent: jest.fn(),
             createFolder: jest.fn(),
+            generateNameHashes: jest.fn().mockResolvedValue([
+                {
+                    name: 'name1',
+                    hash: 'name1Hash',
+                },
+                {
+                    name: 'name2',
+                    hash: 'name2Hash',
+                },
+                {
+                    name: 'name3',
+                    hash: 'name3Hash',
+                },
+            ]),
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesAccess = {
@@ -340,4 +358,51 @@ describe('NodesManagement', () => {
         expect(restored).toEqual(new Set(uids));
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
     });
+
+    describe('findAvailableName', () => {
+        it('should find available name', async () => {
+            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
+                return {
+                    availableHashes: ['name3Hash'],
+                    pendingHashes: [],
+                };
+            });
+
+            const result = await management.findAvailableName('parentUid', 'name');
+            expect(result).toBe('name3');
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
+                'name1Hash',
+                'name2Hash',
+                'name3Hash',
+            ]);
+        });
+
+        it('should find available name with multiple pages', async () => {
+            let firstCall = false;
+            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
+                if (!firstCall) {
+                    firstCall = true;
+                    return {
+                        // First page has no available hashes
+                        availableHashes: [],
+                        pendingHashes: [],
+                    };
+                }
+                return {
+                    availableHashes: ['name3Hash'],
+                    pendingHashes: [],
+                };
+            });
+
+            const result = await management.findAvailableName('parentUid', 'name');
+            expect(result).toBe('name3');
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(2);
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
+                'name1Hash',
+                'name2Hash',
+                'name3Hash',
+            ]);
+        });
+    });
 });

package/src/internal/nodes/nodesManagement.ts

@@ -8,10 +8,14 @@ import { NodeAPIService } from './apiService';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
 import { NodeOutOfSyncError } from './errors';
+import { generateFolderExtendedAttributes } from './extendedAttributes';
 import { DecryptedNode } from './interface';
+import { splitExtension, joinNameAndExtension } from './nodeName';
 import { NodesAccess } from './nodesAccess';
 import { validateNodeName } from './validations';
-import { generateFolderExtendedAttributes } from './extendedAttributes';
+
+const AVAILABLE_NAME_BATCH_SIZE = 10;
+const AVAILABLE_NAME_LIMIT = 1000;
 
 /**
  * Provides high-level actions for managing nodes.
@@ -349,4 +353,42 @@ export class NodesManagement {
         await this.cryptoCache.setNodeKeys(nodeUid, keys);
         return node;
     }
+
+    async findAvailableName(parentFolderUid: string, name: string): Promise<string> {
+        const { hashKey: parentHashKey } = await this.nodesAccess.getNodeKeys(parentFolderUid);
+        if (!parentHashKey) {
+            throw new ValidationError(c('Error').t`Creating files in non-folders is not allowed`);
+        }
+
+        const [namePart, extension] = splitExtension(name);
+
+        let startIndex = 1;
+        while (startIndex < AVAILABLE_NAME_LIMIT) {
+            const namesToCheck = startIndex === 1 ? [name] : [];
+            for (let i = startIndex; i < startIndex + AVAILABLE_NAME_BATCH_SIZE; i++) {
+                namesToCheck.push(joinNameAndExtension(namePart, i, extension));
+            }
+
+            const hashesToCheck = await this.cryptoService.generateNameHashes(parentHashKey, namesToCheck);
+
+            const { availableHashes } = await this.apiService.checkAvailableHashes(
+                parentFolderUid,
+                hashesToCheck.map(({ hash }) => hash),
+            );
+
+            if (!availableHashes.length) {
+                startIndex += AVAILABLE_NAME_BATCH_SIZE;
+                continue;
+            }
+
+            const availableHash = hashesToCheck.find(({ hash }) => hash === availableHashes[0]);
+            if (!availableHash) {
+                throw Error('Backend returned unexpected hash');
+            }
+
+            return availableHash.name;
+        }
+
+        throw new ValidationError(c('Error').t`No available name found`);
+    }
 }

package/src/internal/photos/albums.ts

@@ -21,7 +21,7 @@ export class Albums {
     }
 
     async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+        const { volumeId } = await this.photoShares.getRootIDs();
 
         const batchLoading = new BatchLoading<string, DecryptedNode>({
             iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),