@protontech/drive-sdk 0.1.0 → 0.1.1

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

@@ -1,13 +1,13 @@
-import { getMockLogger } from "../../tests/logger";
-import { PrivateKey } from "../../crypto";
-import { DecryptionError } from "../../errors";
-import { NodeAPIService } from "./apiService";
-import { NodesCache } from "./cache"
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
+import { getMockLogger } from '../../tests/logger';
+import { PrivateKey } from '../../crypto';
+import { DecryptionError } from '../../errors';
+import { NodeAPIService } from './apiService';
+import { NodesCache } from './cache';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
 import { NodesAccess } from './nodesAccess';
-import { SharesService, DecryptedNode, DecryptedUnparsedNode, EncryptedNode, DecryptedNodeKeys } from "./interface";
-import { NodeType } from "../../interface";
+import { SharesService, DecryptedNode, DecryptedUnparsedNode, EncryptedNode, DecryptedNodeKeys } from './interface';
+import { NodeType } from '../../interface';
 
 describe('nodesAccess', () => {
     let apiService: NodeAPIService;
@@ -22,10 +22,10 @@ describe('nodesAccess', () => {
         apiService = {
             getNode: jest.fn(),
             iterateNodes: jest.fn().mockImplementation(async function* (uids: string[]) {
-                yield* uids.map((uid => ({ uid, parentUid: 'volumeId~parentNodeId' } as EncryptedNode)));
+                yield* uids.map((uid) => ({ uid, parentUid: 'volumeId~parentNodeId' }) as EncryptedNode);
             }),
             iterateChildrenNodeUids: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
             getNode: jest.fn(),
@@ -34,16 +34,16 @@ describe('nodesAccess', () => {
             isFolderChildrenLoaded: jest.fn().mockResolvedValue(false),
             setFolderChildrenLoaded: jest.fn(),
             removeNodes: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoCache = {
             getNodeKeys: jest.fn(),
             setNodeKeys: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             decryptNode: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         shareService = {
             getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
@@ -65,21 +65,27 @@ describe('nodesAccess', () => {
 
         it('should get node from API when cache is stale', async () => {
             const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' } as EncryptedNode;
-            const decryptedUnparsedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid', name: { ok: true, value: 'name' } } as DecryptedUnparsedNode;
+            const decryptedUnparsedNode = {
+                uid: 'volumeId~nodeId',
+                parentUid: 'volumeId~parentNodeid',
+                name: { ok: true, value: 'name' },
+            } as DecryptedUnparsedNode;
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: true, value: 'name' },
                 isStale: false,
                 activeRevision: undefined,
                 folder: undefined,
-                treeEventScopeId: "volumeId",
+                treeEventScopeId: 'volumeId',
             } as DecryptedNode;
             const decryptedKeys = { key: 'key' } as any as DecryptedNodeKeys;
 
             cache.getNode = jest.fn(() => Promise.resolve({ uid: 'volumeId~nodeId', isStale: true } as DecryptedNode));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
-            cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
+            cryptoService.decryptNode = jest.fn(() =>
+                Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }),
+            );
 
             const result = await access.getNode('volumeId~nodeId');
             expect(result).toEqual(decryptedNode);
@@ -92,7 +98,11 @@ describe('nodesAccess', () => {
 
         it('should get node from API missing cache', async () => {
             const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' } as EncryptedNode;
-            const decryptedUnparsedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid', name: { ok: true, value: 'name' } } as DecryptedUnparsedNode;
+            const decryptedUnparsedNode = {
+                uid: 'volumeId~nodeId',
+                parentUid: 'volumeId~parentNodeid',
+                name: { ok: true, value: 'name' },
+            } as DecryptedUnparsedNode;
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: true, value: 'name' },
@@ -106,7 +116,9 @@ describe('nodesAccess', () => {
             cache.getNode = jest.fn(() => Promise.reject(new Error('Entity not found')));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
-            cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
+            cryptoService.decryptNode = jest.fn(() =>
+                Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }),
+            );
 
             const result = await access.getNode('volumeId~nodeId');
             expect(result).toEqual(decryptedNode);
@@ -119,7 +131,11 @@ describe('nodesAccess', () => {
 
         it('should validate node name', async () => {
             const encryptedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid' } as EncryptedNode;
-            const decryptedUnparsedNode = { uid: 'volumeId~nodeId', parentUid: 'volumeId~parentNodeid', name: { ok: true, value: 'foo/bar' } } as DecryptedUnparsedNode;
+            const decryptedUnparsedNode = {
+                uid: 'volumeId~nodeId',
+                parentUid: 'volumeId~parentNodeid',
+                name: { ok: true, value: 'foo/bar' },
+            } as DecryptedUnparsedNode;
             const decryptedNode = {
                 ...decryptedUnparsedNode,
                 name: { ok: false, error: { name: 'foo/bar', error: "Name must not contain the character '/'" } },
@@ -130,7 +146,9 @@ describe('nodesAccess', () => {
             cache.getNode = jest.fn(() => Promise.reject(new Error('Entity not found')));
             apiService.getNode = jest.fn(() => Promise.resolve(encryptedNode));
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
-            cryptoService.decryptNode = jest.fn(() => Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }));
+            cryptoService.decryptNode = jest.fn(() =>
+                Promise.resolve({ node: decryptedUnparsedNode, keys: decryptedKeys }),
+            );
 
             const result = await access.getNode('volumeId~nodeId');
             expect(result).toMatchObject(decryptedNode);
@@ -139,11 +157,19 @@ describe('nodesAccess', () => {
 
     describe('iterate methods', () => {
         beforeEach(() => {
-            cryptoCache.getNodeKeys = jest.fn().mockImplementation((uid: string) => Promise.resolve({ key: 'key' } as any as DecryptedNodeKeys));
-            cryptoService.decryptNode = jest.fn().mockImplementation((encryptedNode: EncryptedNode) => Promise.resolve({
-                node: { uid: encryptedNode.uid, isStale: false, name: { ok: true, value: 'name' } } as DecryptedNode,
-                keys: { key: 'key' } as any as DecryptedNodeKeys,
-            }));
+            cryptoCache.getNodeKeys = jest
+                .fn()
+                .mockImplementation((uid: string) => Promise.resolve({ key: 'key' } as any as DecryptedNodeKeys));
+            cryptoService.decryptNode = jest.fn().mockImplementation((encryptedNode: EncryptedNode) =>
+                Promise.resolve({
+                    node: {
+                        uid: encryptedNode.uid,
+                        isStale: false,
+                        name: { ok: true, value: 'name' },
+                    } as DecryptedNode,
+                    keys: { key: 'key' } as any as DecryptedNodeKeys,
+                }),
+            );
         });
 
         describe('iterateChildren', () => {
@@ -222,7 +248,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.iterateNodes).toHaveBeenCalledWith(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'], 'volumeId', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(
+                    ['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'],
+                    'volumeId',
+                    undefined,
+                );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
@@ -243,7 +273,7 @@ describe('nodesAccess', () => {
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids: string[]) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: parentNode.uid } as EncryptedNode));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: parentNode.uid }) as EncryptedNode);
                 });
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
@@ -268,7 +298,11 @@ describe('nodesAccess', () => {
                         throw new DecryptionError('Decryption failed');
                     }
                     return Promise.resolve({
-                        node: { uid: encryptedNode.uid, isStale: false, name: { ok: true, value: 'name' } } as DecryptedNode,
+                        node: {
+                            uid: encryptedNode.uid,
+                            isStale: false,
+                            name: { ok: true, value: 'name' },
+                        } as DecryptedNode,
                         keys: { key: 'key' } as any as DecryptedNodeKeys,
                     });
                 });
@@ -283,11 +317,9 @@ describe('nodesAccess', () => {
                 try {
                     await node3;
                 } catch (error: any) {
-                    expect(error.cause).toEqual([
-                        new DecryptionError('Decryption failed'),
-                    ]);
+                    expect(error.cause).toEqual([new DecryptionError('Decryption failed')]);
                 }
-            })
+            });
         });
 
         describe('iterateTrashedNodes', () => {
@@ -324,7 +356,11 @@ describe('nodesAccess', () => {
                 const result = await Array.fromAsync(access.iterateTrashedNodes());
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateTrashedNodeUids).toHaveBeenCalledWith(volumeId, undefined);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'], volumeId, undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(
+                    ['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'],
+                    volumeId,
+                    undefined,
+                );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(4);
@@ -336,7 +372,7 @@ describe('nodesAccess', () => {
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids: string[]) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' } as EncryptedNode));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' }) as EncryptedNode);
                 });
 
                 const result = await Array.fromAsync(access.iterateTrashedNodes());
@@ -359,7 +395,9 @@ describe('nodesAccess', () => {
                     yield { ok: true, node: node4 };
                 });
 
-                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']));
+                const result = await Array.fromAsync(
+                    access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']),
+                );
                 expect(result).toMatchObject([node1, node2, node3, node4]);
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
             });
@@ -372,9 +410,15 @@ describe('nodesAccess', () => {
                     yield { ok: true, node: node4 };
                 });
 
-                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']));
+                const result = await Array.fromAsync(
+                    access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4']),
+                );
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith(['volumeId~node2', 'volumeId~node3'], 'volumeId', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(
+                    ['volumeId~node2', 'volumeId~node3'],
+                    'volumeId',
+                    undefined,
+                );
             });
 
             it('should remove from cache if missing on API and return back to caller', async () => {
@@ -385,11 +429,13 @@ describe('nodesAccess', () => {
                 });
                 apiService.iterateNodes = jest.fn().mockImplementation(async function* (uids: string[]) {
                     // Skip first node - make it missing.
-                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' } as EncryptedNode));
+                    yield* uids.slice(1).map((uid) => ({ uid, parentUid: 'volumeId~parentNodeid' }) as EncryptedNode);
                 });
 
-                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']));
-                expect(result).toMatchObject([node2, node3, {missingUid: 'volumeId~node1'}]);
+                const result = await Array.fromAsync(
+                    access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']),
+                );
+                expect(result).toMatchObject([node2, node3, { missingUid: 'volumeId~node1' }]);
                 expect(cache.removeNodes).toHaveBeenCalledWith(['volumeId~node1']);
             });
 
@@ -407,10 +453,10 @@ describe('nodesAccess', () => {
                     yield* uids.map((uid) => {
                         const parentUid = uid.replace('node', 'parentOfNode');
                         return {
-                        uid,
-                        parentUid,
-                        encryptedCrypto,
-                        } as EncryptedNode
+                            uid,
+                            parentUid,
+                            encryptedCrypto,
+                        } as EncryptedNode;
                     });
                 });
                 const decryptionError = new DecryptionError('Parent cannot be decrypted');
@@ -419,19 +465,27 @@ describe('nodesAccess', () => {
                         throw decryptionError;
                     }
                     return {
-                        key: {_idx: 32132},
+                        key: { _idx: 32132 },
                     } as any;
-                } );
+                });
 
-                const result = await Array.fromAsync(access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']));
+                const result = await Array.fromAsync(
+                    access.iterateNodes(['volumeId~node1', 'volumeId~node2', 'volumeId~node3']),
+                );
                 expect(result).toEqual([
                     {
                         ...node1,
                         encryptedCrypto,
                         parentUid: 'volumeId~parentOfNode1',
                         name: { ok: false, error: decryptionError },
-                        keyAuthor: { ok: false, error: { claimedAuthor: 'signatureEmail', error: decryptionError.message } },
-                        nameAuthor: { ok: false, error: { claimedAuthor: 'nameSignatureEmail', error: decryptionError.message } },
+                        keyAuthor: {
+                            ok: false,
+                            error: { claimedAuthor: 'signatureEmail', error: decryptionError.message },
+                        },
+                        nameAuthor: {
+                            ok: false,
+                            error: { claimedAuthor: 'nameSignatureEmail', error: decryptionError.message },
+                        },
                         errors: [decryptionError],
                     },
                     {
@@ -530,30 +584,42 @@ describe('nodesAccess', () => {
         const nodeUid = 'volumeId~nodeId';
 
         it('should return node URL of document', async () => {
-            jest.spyOn(access, 'getNode').mockReturnValue(Promise.resolve({ mediaType: 'application/vnd.proton.doc' } as any as DecryptedNode));
+            jest.spyOn(access, 'getNode').mockReturnValue(
+                Promise.resolve({ mediaType: 'application/vnd.proton.doc' } as any as DecryptedNode),
+            );
 
             const result = await access.getNodeUrl(nodeUid);
             expect(result).toBe('https://docs.proton.me/doc?type=doc&mode=open&volumeId=volumeId&linkId=nodeId');
         });
 
         it('should return node URL of sheet', async () => {
-            jest.spyOn(access, 'getNode').mockReturnValue(Promise.resolve({ mediaType: 'application/vnd.proton.sheet' } as any as DecryptedNode));
+            jest.spyOn(access, 'getNode').mockReturnValue(
+                Promise.resolve({ mediaType: 'application/vnd.proton.sheet' } as any as DecryptedNode),
+            );
 
             const result = await access.getNodeUrl(nodeUid);
             expect(result).toBe('https://docs.proton.me/doc?type=sheet&mode=open&volumeId=volumeId&linkId=nodeId');
         });
 
         it('should return node URL of image', async () => {
-            jest.spyOn(access, 'getNode').mockReturnValue(Promise.resolve({ type: NodeType.File } as any as DecryptedNode));
-            jest.spyOn(access as any, 'getRootNode').mockReturnValue(Promise.resolve({ shareId: 'shareId', type: NodeType.Folder } as any as DecryptedNode));
+            jest.spyOn(access, 'getNode').mockReturnValue(
+                Promise.resolve({ type: NodeType.File } as any as DecryptedNode),
+            );
+            jest.spyOn(access as any, 'getRootNode').mockReturnValue(
+                Promise.resolve({ shareId: 'shareId', type: NodeType.Folder } as any as DecryptedNode),
+            );
 
             const result = await access.getNodeUrl(nodeUid);
             expect(result).toBe('https://drive.proton.me/shareId/file/nodeId');
         });
 
         it('should return node URL of folder', async () => {
-            jest.spyOn(access, 'getNode').mockReturnValue(Promise.resolve({ type: NodeType.Folder } as any as DecryptedNode));
-            jest.spyOn(access as any, 'getRootNode').mockReturnValue(Promise.resolve({ shareId: 'shareId', type: NodeType.Folder } as any as DecryptedNode));
+            jest.spyOn(access, 'getNode').mockReturnValue(
+                Promise.resolve({ type: NodeType.Folder } as any as DecryptedNode),
+            );
+            jest.spyOn(access as any, 'getRootNode').mockReturnValue(
+                Promise.resolve({ shareId: 'shareId', type: NodeType.Folder } as any as DecryptedNode),
+            );
 
             const result = await access.getNodeUrl(nodeUid);
             expect(result).toBe('https://drive.proton.me/shareId/folder/nodeId');
@@ -567,7 +633,7 @@ describe('nodesAccess', () => {
             cache.setNode = jest.fn();
             await access.notifyNodeChanged(node.uid);
             expect(cache.getNode).toHaveBeenCalledWith(node.uid);
-            expect(cache.setNode).toHaveBeenCalledWith({...node, isStale: true});
+            expect(cache.setNode).toHaveBeenCalledWith({ ...node, isStale: true });
         });
         it('should update parent if needed', async () => {
             const node = { uid: 'volumeId~nodeId', parentUid: 'v1~pn1', isStale: false } as DecryptedNode;
@@ -575,7 +641,7 @@ describe('nodesAccess', () => {
             cache.setNode = jest.fn();
             await access.notifyNodeChanged(node.uid, 'v1~pn2');
             expect(cache.getNode).toHaveBeenCalledWith(node.uid);
-            expect(cache.setNode).toHaveBeenCalledWith({...node, parentUid: 'v1~pn2', isStale: true});
+            expect(cache.setNode).toHaveBeenCalledWith({ ...node, parentUid: 'v1~pn2', isStale: true });
         });
     });
 

package/src/internal/nodes/nodesAccess.ts

@@ -1,19 +1,19 @@
 import { c } from 'ttag';
 
-import { PrivateKey, SessionKey } from "../../crypto";
-import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from "../../interface";
-import { DecryptionError, ProtonDriveError } from "../../errors";
+import { PrivateKey, SessionKey } from '../../crypto';
+import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from '../../interface';
+import { DecryptionError, ProtonDriveError } from '../../errors';
 import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
-import { BatchLoading } from "../batchLoading";
-import { makeNodeUid, splitNodeUid } from "../uids";
-import { NodeAPIService } from "./apiService";
-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 { validateNodeName } from "./validations";
+import { BatchLoading } from '../batchLoading';
+import { makeNodeUid, splitNodeUid } from '../uids';
+import { NodeAPIService } from './apiService';
+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 { validateNodeName } from './validations';
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
 
 // This is the number of nodes that are loaded in parallel.
@@ -59,7 +59,7 @@ export class NodesAccess {
         let cachedNode;
         try {
             cachedNode = await this.cache.getNode(nodeUid);
-        } catch { }
+        } catch {}
 
         if (cachedNode && !cachedNode.isStale) {
             return cachedNode;
@@ -75,7 +75,10 @@ export class NodesAccess {
         // 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), batchSize: BATCH_LOADING_SIZE });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({
+            iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
+        });
 
         const areChildrenCached = await this.cache.isFolderChildrenLoaded(parentNodeUid);
         if (areChildrenCached) {
@@ -95,7 +98,7 @@ export class NodesAccess {
             let node;
             try {
                 node = await this.cache.getNode(nodeUid);
-            } catch { }
+            } catch {}
 
             if (node && !node.isStale) {
                 yield node;
@@ -111,12 +114,15 @@ export class NodesAccess {
     // Improvement requested: keep status of loaded trash and leverage cache.
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         const { volumeId } = await this.shareService.getMyFilesIDs();
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal), batchSize: BATCH_LOADING_SIZE });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({
+            iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
+        });
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
             let node;
             try {
                 node = await this.cache.getNode(nodeUid);
-            } catch { }
+            } catch {}
 
             if (node && !node.isStale) {
                 yield node;
@@ -129,7 +135,10 @@ 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), batchSize: BATCH_LOADING_SIZE });
+        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({
+            iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
+        });
         for await (const result of this.cache.iterateNodes(nodeUids)) {
             if (result.ok && !result.node.isStale) {
                 yield result.node;
@@ -176,13 +185,13 @@ export class NodesAccess {
         await this.cache.removeNodes([nodeUid]);
     }
 
-    private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
+    private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
         const { volumeId: ownVolumeId } = await this.shareService.getMyFilesIDs();
         const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
         return this.decryptNode(encryptedNode);
     }
 
-    private async* loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    private async *loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         for await (const result of this.loadNodesWithMissingReport(nodeUids, signal)) {
             if ('missingUid' in result) {
                 continue;
@@ -191,7 +200,10 @@ export class NodesAccess {
         }
     }
 
-    private async* loadNodesWithMissingReport(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
+    private async *loadNodesWithMissingReport(
+        nodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode | MissingNode> {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
@@ -207,7 +219,11 @@ export class NodesAccess {
                 return resultError(error);
             }
         };
-        const decryptedNodesIterator = asyncIteratorMap(encryptedNodesIterator, decryptNodeMapper, DECRYPTION_CONCURRENCY);
+        const decryptedNodesIterator = asyncIteratorMap(
+            encryptedNodesIterator,
+            decryptNodeMapper,
+            DECRYPTION_CONCURRENCY,
+        );
         for await (const node of decryptedNodesIterator) {
             if (node.ok) {
                 yield node.value;
@@ -232,7 +248,9 @@ export class NodesAccess {
         }
     }
 
-    private async decryptNode(encryptedNode: EncryptedNode): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
+    private async decryptNode(
+        encryptedNode: EncryptedNode,
+    ): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
         let parentKey;
         try {
             const parentKeys = await this.getParentKeys(encryptedNode);
@@ -299,18 +317,20 @@ export class NodesAccess {
             return {
                 ...unparsedNode,
                 isStale: false,
-                activeRevision: !unparsedNode.activeRevision?.ok ? unparsedNode.activeRevision : resultOk({
-                    uid: unparsedNode.activeRevision.value.uid,
-                    state: unparsedNode.activeRevision.value.state,
-                    creationTime: unparsedNode.activeRevision.value.creationTime,
-                    storageSize: unparsedNode.activeRevision.value.storageSize,
-                    contentAuthor: unparsedNode.activeRevision.value.contentAuthor,
-                    thumbnails: unparsedNode.activeRevision.value.thumbnails,
-                    ...extendedAttributes,
-                }),
+                activeRevision: !unparsedNode.activeRevision?.ok
+                    ? unparsedNode.activeRevision
+                    : resultOk({
+                          uid: unparsedNode.activeRevision.value.uid,
+                          state: unparsedNode.activeRevision.value.state,
+                          creationTime: unparsedNode.activeRevision.value.creationTime,
+                          storageSize: unparsedNode.activeRevision.value.storageSize,
+                          contentAuthor: unparsedNode.activeRevision.value.contentAuthor,
+                          thumbnails: unparsedNode.activeRevision.value.thumbnails,
+                          ...extendedAttributes,
+                      }),
                 folder: undefined,
                 treeEventScopeId: splitNodeUid(unparsedNode.uid).volumeId,
-            }
+            };
         }
 
         const extendedAttributes = unparsedNode.folder?.extendedAttributes
@@ -321,14 +341,18 @@ export class NodesAccess {
             name: nodeName,
             isStale: false,
             activeRevision: undefined,
-            folder: extendedAttributes ? {
-                ...extendedAttributes,
-            } : undefined,
+            folder: extendedAttributes
+                ? {
+                      ...extendedAttributes,
+                  }
+                : undefined,
             treeEventScopeId: splitNodeUid(unparsedNode.uid).volumeId,
-        }
+        };
     }
 
-    async getParentKeys(node: Pick<DecryptedNode, 'parentUid' | 'shareId'>): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+    async getParentKeys(
+        node: Pick<DecryptedNode, 'parentUid' | 'shareId'>,
+    ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
         if (node.parentUid) {
             try {
                 return await this.getNodeKeys(node.parentUid);
@@ -345,7 +369,7 @@ export class NodesAccess {
         if (node.shareId) {
             return {
                 key: await this.shareService.getSharePrivateKey(node.shareId),
-            }
+            };
         }
         // This is bug that should not happen.
         // API cannot provide node without parent or share.
@@ -365,11 +389,11 @@ export class NodesAccess {
     }
 
     async getNodePrivateAndSessionKeys(nodeUid: string): Promise<{
-        key: PrivateKey,
-        passphrase: string,
-        passphraseSessionKey: SessionKey,
-        contentKeyPacketSessionKey?: SessionKey,
-        nameSessionKey: SessionKey,
+        key: PrivateKey;
+        passphrase: string;
+        passphraseSessionKey: SessionKey;
+        contentKeyPacketSessionKey?: SessionKey;
+        nameSessionKey: SessionKey;
     }> {
         const node = await this.getNode(nodeUid);
         const { key: parentKey } = await this.getParentKeys(node);
@@ -385,10 +409,10 @@ export class NodesAccess {
     }
 
     async getRootNodeEmailKey(nodeUid: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
     }> {
         const rootNode = await this.getRootNode(nodeUid);
         if (!rootNode.shareId) {
@@ -418,5 +442,5 @@ export class NodesAccess {
     private async getRootNode(nodeUid: string): Promise<DecryptedNode> {
         const node = await this.getNode(nodeUid);
         return node.parentUid ? this.getRootNode(node.parentUid) : node;
-    };
+    }
 }