@protontech/drive-sdk 0.5.0 → 0.6.0

package/src/internal/download/controller.ts

@@ -1,11 +1,23 @@
+import { AbortError } from '../../errors';
 import { waitForCondition } from '../wait';
 
 export class DownloadController {
     private paused = false;
     public promise?: Promise<void>;
 
+    constructor(private signal?: AbortSignal) {
+        this.signal = signal;
+    }
+
     async waitWhilePaused(): Promise<void> {
-        await waitForCondition(() => !this.paused);
+        try {
+            await waitForCondition(() => !this.paused, this.signal);
+        } catch (error) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
     }
 
     pause(): void {

package/src/internal/download/fileDownloader.ts

@@ -1,4 +1,7 @@
+import { c } from 'ttag';
+
 import { PrivateKey, SessionKey, base64StringToUint8Array } from '../../crypto';
+import { AbortError } from '../../errors';
 import { Logger } from '../../interface';
 import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
@@ -48,7 +51,7 @@ export class FileDownloader {
         this.revision = revision;
         this.signal = signal;
         this.onFinish = onFinish;
-        this.controller = new DownloadController();
+        this.controller = new DownloadController(this.signal);
     }
 
     getClaimedSizeInBytes(): number | undefined {
@@ -289,6 +292,10 @@ export class FileDownloader {
                 logger.debug(`Decrypting`);
                 decryptedBlock = await this.cryptoService.decryptBlock(encryptedBlock, cryptoKeys);
             } catch (error) {
+                if (this.signal?.aborted) {
+                    throw new AbortError(c('Error').t`Operation aborted`);
+                }
+
                 if (blockProgress !== 0) {
                     onProgress?.(-blockProgress);
                     blockProgress = 0;

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

@@ -1,3 +1,4 @@
+import { NodeWithSameNameExistsValidationError, ValidationError } from '../../errors';
 import { MemberRole, NodeType } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { DriveAPIService, ErrorCode, InvalidRequirementsAPIError } from '../apiService';
@@ -172,7 +173,7 @@ describe('nodeAPIService', () => {
             put: jest.fn(),
         };
 
-        api = new NodeAPIService(getMockLogger(), apiMock);
+        api = new NodeAPIService(getMockLogger(), apiMock, 'clientUid');
     });
 
     describe('getNode', () => {
@@ -627,6 +628,69 @@ describe('nodeAPIService', () => {
         });
     });
 
+    describe('createFolder', () => {
+        it('should create folder', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: ErrorCode.OK,
+                Folder: {
+                    ID: 'newNodeId',
+                },
+            });
+
+            const result = await api.createFolder('volumeId~parentNodeId', {
+                armoredKey: 'armoredKey',
+                armoredHashKey: 'armoredHashKey',
+                armoredNodePassphrase: 'armoredNodePassphrase',
+                armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                signatureEmail: 'signatureEmail',
+                encryptedName: 'encryptedName',
+                hash: 'hash',
+                armoredExtendedAttributes: 'armoredExtendedAttributes',
+            });
+
+            expect(result).toEqual('volumeId~newNodeId');
+            expect(apiMock.post).toHaveBeenCalledWith('drive/v2/volumes/volumeId/folders', {
+                ParentLinkID: 'parentNodeId',
+                NodeKey: 'armoredKey',
+                NodeHashKey: 'armoredHashKey',
+                NodePassphrase: 'armoredNodePassphrase',
+                NodePassphraseSignature: 'armoredNodePassphraseSignature',
+                SignatureEmail: 'signatureEmail',
+                Name: 'encryptedName',
+                Hash: 'hash',
+                XAttr: 'armoredExtendedAttributes',
+            });
+        });
+
+        it('should throw NodeWithSameNameExistsValidationError if node already exists', async () => {
+            apiMock.post = jest.fn().mockRejectedValue(
+                new ValidationError('Node already exists', ErrorCode.ALREADY_EXISTS, {
+                    ConflictLinkID: 'existingNodeId',
+                }),
+            );
+
+            try {
+                await api.createFolder('volumeId~parentNodeId', {
+                    armoredKey: 'armoredKey',
+                    armoredHashKey: 'armoredHashKey',
+                    armoredNodePassphrase: 'armoredNodePassphrase',
+                    armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                    signatureEmail: 'signatureEmail',
+                    encryptedName: 'encryptedName',
+                    hash: 'hash',
+                    armoredExtendedAttributes: 'armoredExtendedAttributes',
+                });
+                expect(false).toBeTruthy();
+            } catch (error: unknown) {
+                expect(error).toBeInstanceOf(NodeWithSameNameExistsValidationError);
+                if (error instanceof NodeWithSameNameExistsValidationError) {
+                    expect(error.code).toEqual(ErrorCode.ALREADY_EXISTS);
+                    expect(error.existingNodeUid).toEqual('volumeId~existingNodeId');
+                }
+            }
+        });
+    });
+
     describe('renameNode', () => {
         it('should rename node', async () => {
             await api.renameNode(

package/src/internal/nodes/apiService.ts

@@ -1,11 +1,12 @@
 import { c } from 'ttag';
 
-import { ProtonDriveError, ValidationError } from '../../errors';
+import { NodeWithSameNameExistsValidationError, ProtonDriveError, ValidationError } from '../../errors';
 import { Logger, NodeResult } from '../../interface';
 import { MemberRole, RevisionState } from '../../interface/nodes';
 import {
     DriveAPIService,
     drivePaths,
+    ErrorCode,
     InvalidRequirementsAPIError,
     isCodeOk,
     nodeTypeNumberToNodeType,
@@ -101,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.
  *
@@ -111,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> {
@@ -400,7 +411,7 @@ export class NodeAPIService {
             );
 
             // TODO: remove `as` when backend fixes OpenAPI schema.
-            yield * handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
+            yield* handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
         }
     }
 
@@ -449,21 +460,41 @@ export class NodeAPIService {
     ): Promise<string> {
         const { volumeId, nodeId: parentId } = splitNodeUid(parentUid);
 
-        const response = await this.apiService.post<PostCreateFolderRequest, PostCreateFolderResponse>(
-            `drive/v2/volumes/${volumeId}/folders`,
-            {
-                ParentLinkID: parentId,
-                NodeKey: newNode.armoredKey,
-                NodeHashKey: newNode.armoredHashKey,
-                NodePassphrase: newNode.armoredNodePassphrase,
-                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
-                SignatureEmail: newNode.signatureEmail,
-                Name: newNode.encryptedName,
-                Hash: newNode.hash,
-                // @ts-expect-error: XAttr is optional as undefined.
-                XAttr: newNode.armoredExtendedAttributes,
-            },
-        );
+        let response: PostCreateFolderResponse;
+        try {
+            response = await this.apiService.post<PostCreateFolderRequest, PostCreateFolderResponse>(
+                `drive/v2/volumes/${volumeId}/folders`,
+                {
+                    ParentLinkID: parentId,
+                    NodeKey: newNode.armoredKey,
+                    NodeHashKey: newNode.armoredHashKey,
+                    NodePassphrase: newNode.armoredNodePassphrase,
+                    NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                    SignatureEmail: newNode.signatureEmail,
+                    Name: newNode.encryptedName,
+                    Hash: newNode.hash,
+                    // @ts-expect-error: XAttr is optional as undefined.
+                    XAttr: newNode.armoredExtendedAttributes,
+                },
+            );
+        } catch (error: unknown) {
+            if (error instanceof ValidationError) {
+                if (error.code === ErrorCode.ALREADY_EXISTS) {
+                    const typedDetails = error.details as
+                        | {
+                              ConflictLinkID: string;
+                          }
+                        | undefined;
+
+                    const existingNodeUid = typedDetails?.ConflictLinkID
+                        ? makeNodeUid(volumeId, typedDetails.ConflictLinkID)
+                        : undefined;
+
+                    throw new NodeWithSameNameExistsValidationError(error.message, error.code, existingNodeUid);
+                }
+            }
+            throw error;
+        }
 
         return makeNodeUid(volumeId, response.Folder.ID);
     }
@@ -505,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/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/debouncer.test.ts

@@ -1,18 +1,14 @@
+import { ProtonDriveTelemetry } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
 import { NodesDebouncer } from './debouncer';
-import { Logger } from '../../interface';
 
 describe('NodesDebouncer', () => {
     let debouncer: NodesDebouncer;
-    let mockLogger: jest.Mocked<Logger>;
+    let mockTelemetry: ReturnType<typeof getMockTelemetry>;
 
     beforeEach(() => {
-        mockLogger = {
-            debug: jest.fn(),
-            info: jest.fn(),
-            warn: jest.fn(),
-            error: jest.fn(),
-        };
-        debouncer = new NodesDebouncer(mockLogger);
+        mockTelemetry = getMockTelemetry();
+        debouncer = new NodesDebouncer(mockTelemetry);
 
         jest.useFakeTimers();
     });
@@ -77,7 +73,22 @@ describe('NodesDebouncer', () => {
         debouncer.loadingNode(nodeUid);
         debouncer.loadingNode(nodeUid);
 
-        expect(mockLogger.warn).toHaveBeenCalledWith(`debouncer: Loading twice for: ${nodeUid}`);
+        expect(mockTelemetry.mockLogger.warn).toHaveBeenCalledWith(`Loading twice for: ${nodeUid}`);
+    });
+
+    it('should send metric when waiting for a long time', async () => {
+        const nodeUid = 'test-node-1';
+        debouncer.loadingNode(nodeUid);
+
+        const waitPromise = debouncer.waitForLoadingNode(nodeUid);
+        expect(mockTelemetry.recordMetric).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(1500);
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
+            eventName: 'debounceLongWait',
+        });
+
+        debouncer.finishedLoadingNode(nodeUid);
+        await waitPromise;
     });
 
     it('should timeout', async () => {
@@ -85,7 +96,7 @@ describe('NodesDebouncer', () => {
         debouncer.loadingNode(nodeUid);
 
         jest.advanceTimersByTime(6000);
-        expect(mockLogger.warn).toHaveBeenCalledWith(`debouncer: Timeout for: ${nodeUid}`);
+        expect(mockTelemetry.mockLogger.warn).toHaveBeenCalledWith(`Timeout for: ${nodeUid}`);
         await expect(debouncer.waitForLoadingNode(nodeUid)).resolves.toBeUndefined();
     });
 
@@ -112,7 +123,7 @@ describe('NodesDebouncer', () => {
 
             const result = await debouncer.waitForLoadingNode(nodeUid);
             expect(result).toBeUndefined();
-            expect(mockLogger.debug).not.toHaveBeenCalled();
+            expect(mockTelemetry.mockLogger.debug).not.toHaveBeenCalled();
         });
 
         it('should wait for registered node and log debug message', async () => {
@@ -121,7 +132,8 @@ describe('NodesDebouncer', () => {
 
             const waitPromise = debouncer.waitForLoadingNode(nodeUid);
 
-            expect(mockLogger.debug).toHaveBeenCalledWith(`debouncer: Wait for: ${nodeUid}`);
+            expect(mockTelemetry.mockLogger.debug).toHaveBeenCalledWith(`Wait for: ${nodeUid}`);
+
             debouncer.finishedLoadingNode(nodeUid);
             await waitPromise;
         });

package/src/internal/nodes/debouncer.ts

@@ -1,5 +1,4 @@
-import { Logger } from "../../interface";
-import { LoggerWithPrefix } from '../../telemetry';
+import { Logger, ProtonDriveTelemetry } from '../../interface';
 
 /**
  * The timeout for which the node is considered to be loading.
@@ -11,6 +10,12 @@ import { LoggerWithPrefix } from '../../telemetry';
  */
 const DEBOUNCE_TIMEOUT = 5000;
 
+/**
+ * The timeout for which the node is considered to be waiting for a long time.
+ * After this timeout the metric is sent.
+ */
+const DEBOUNCE_LONG_WAIT_TIMEOUT = 1000;
+
 /**
  * Helper to avoid loading the same node twice.
  *
@@ -23,6 +28,8 @@ const DEBOUNCE_TIMEOUT = 5000;
  * the node to be loaded if that is the case.
  */
 export class NodesDebouncer {
+    private logger: Logger;
+
     private promises: Map<
         string,
         {
@@ -32,8 +39,9 @@ export class NodesDebouncer {
         }
     > = new Map();
 
-    constructor(private logger: Logger) {
-        this.logger = new LoggerWithPrefix(logger, 'debouncer');
+    constructor(private telemetry: ProtonDriveTelemetry) {
+        this.logger = telemetry.getLogger('nodes-debouncer');
+        this.telemetry = telemetry;
     }
 
     loadingNodes(nodeUids: string[]) {
@@ -79,8 +87,16 @@ export class NodesDebouncer {
             return;
         }
 
+        const metricTimeout = setTimeout(() => {
+            this.telemetry.recordMetric({
+                eventName: 'debounceLongWait',
+            });
+        }, DEBOUNCE_LONG_WAIT_TIMEOUT);
+
         this.logger.debug(`Wait for: ${nodeUid}`);
         await result.promise;
+
+        clearTimeout(metricTimeout);
     }
 
     clear() {

package/src/internal/nodes/extendedAttributes.ts

@@ -208,11 +208,11 @@ function parseBlockSizes(
         return undefined;
     }
     if (!Array.isArray(blockSizes)) {
-        logger.warn(`XAttr block sizes "${blockSizes}" is not valid`);
+        logger.warn(`XAttr block sizes "${JSON.stringify(blockSizes)}" is not valid`);
         return undefined;
     }
     if (blockSizes.some((size) => typeof size !== 'number' || size <= 0)) {
-        logger.warn(`XAttr block sizes "${blockSizes}" is not valid`);
+        logger.warn(`XAttr block sizes "${JSON.stringify(blockSizes)}" is not valid`);
         return undefined;
     }
     if (blockSizes.length === 0) {

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

@@ -64,6 +64,7 @@ describe('nodesModules integration tests', () => {
             account,
             driveCrypto,
             sharesService,
+            'clientUid',
         );
 
         nodesCache = new NodesCache(getMockLogger(), driveEntitiesCache);

package/src/internal/nodes/index.ts

@@ -37,20 +37,14 @@ 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);
     const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
-    const nodesAccess = new NodesAccess(
-        telemetry.getLogger('nodes'),
-        api,
-        cache,
-        cryptoCache,
-        cryptoService,
-        sharesService,
-    );
+    const nodesAccess = new NodesAccess(telemetry, api, cache, cryptoCache, cryptoService, sharesService);
     const nodesEventHandler = new NodesEventsHandler(telemetry.getLogger('nodes-events'), cache);
     const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess);
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);

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

@@ -1,4 +1,4 @@
-import { getMockLogger } from '../../tests/logger';
+import { getMockTelemetry } from '../../tests/telemetry';
 import { PrivateKey } from '../../crypto';
 import { DecryptionError } from '../../errors';
 import { NodeAPIService } from './apiService';
@@ -50,7 +50,7 @@ describe('nodesAccess', () => {
             getSharePrivateKey: jest.fn(),
         };
 
-        access = new NodesAccess(getMockLogger(), apiService, cache, cryptoCache, cryptoService, shareService);
+        access = new NodesAccess(getMockTelemetry(), apiService, cache, cryptoCache, cryptoService, shareService);
     });
 
     describe('getNode', () => {
@@ -569,7 +569,11 @@ describe('nodesAccess', () => {
         it('should get share parent keys', async () => {
             shareService.getSharePrivateKey = jest.fn(() => Promise.resolve('shareKey' as any as PrivateKey));
 
-            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: undefined });
+            const result = await access.getParentKeys({
+                uid: 'volumeId~nodeId',
+                shareId: 'shareId',
+                parentUid: undefined,
+            });
             expect(result).toEqual({ key: 'shareKey' });
             expect(cryptoCache.getNodeKeys).not.toHaveBeenCalled();
         });
@@ -577,7 +581,11 @@ describe('nodesAccess', () => {
         it('should get node parent keys', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
 
-            const result = await access.getParentKeys({ shareId: undefined, parentUid: 'volumeId~parentNodeid' });
+            const result = await access.getParentKeys({
+                uid: 'volumeId~nodeId',
+                shareId: undefined,
+                parentUid: 'volumeId~parentNodeid',
+            });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });
@@ -585,7 +593,11 @@ describe('nodesAccess', () => {
         it('should get node parent keys even if share is set', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
 
-            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: 'volume1~parentNodeid' });
+            const result = await access.getParentKeys({
+                uid: 'volume1~nodeId',
+                shareId: 'shareId',
+                parentUid: 'volume1~parentNodeid',
+            });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });

package/src/internal/nodes/nodesAccess.ts

@@ -1,7 +1,16 @@
 import { c } from 'ttag';
 
 import { PrivateKey, SessionKey } from '../../crypto';
-import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from '../../interface';
+import {
+    InvalidNameError,
+    Logger,
+    MissingNode,
+    NodeType,
+    ProtonDriveTelemetry,
+    Result,
+    resultError,
+    resultOk,
+} from '../../interface';
 import { DecryptionError, ProtonDriveError } from '../../errors';
 import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
@@ -41,10 +50,11 @@ const DECRYPTION_CONCURRENCY = 30;
  * nodes metadata.
  */
 export class NodesAccess {
+    private logger: Logger;
     private debouncer: NodesDebouncer;
 
     constructor(
-        private logger: Logger,
+        private telemetry: ProtonDriveTelemetry,
         private apiService: NodeAPIService,
         private cache: NodesCache,
         private cryptoCache: NodesCryptoCache,
@@ -54,13 +64,13 @@ export class NodesAccess {
             'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
         >,
     ) {
-        this.logger = logger;
+        this.logger = telemetry.getLogger('nodes');
         this.apiService = apiService;
         this.cache = cache;
         this.cryptoCache = cryptoCache;
         this.cryptoService = cryptoService;
         this.shareService = shareService;
-        this.debouncer = new NodesDebouncer(this.logger);
+        this.debouncer = new NodesDebouncer(this.telemetry);
     }
 
     async getVolumeRootFolder() {
@@ -357,7 +367,7 @@ export class NodesAccess {
     }
 
     async getParentKeys(
-        node: Pick<DecryptedNode, 'parentUid' | 'shareId'>,
+        node: Pick<DecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
     ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
         if (node.parentUid) {
             try {