@protontech/drive-sdk 0.5.1 → 0.6.1

package/src/internal/photos/apiService.ts

@@ -18,6 +18,13 @@ type GetTimelineResponse =
 type GetAlbumsResponse =
     drivePaths['/drive/photos/volumes/{volumeID}/albums']['get']['responses']['200']['content']['application/json'];
 
+type PostPhotoDuplicateRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostPhotoDuplicateResponse =
+    drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['responses']['200']['content']['application/json'];
+
 /**
  * Provides API communication for fetching and manipulating photos and albums
  * metadata.
@@ -148,4 +155,37 @@ export class PhotosAPIService {
             anchor = response.AnchorID;
         }
     }
+
+    async checkPhotoDuplicates(
+        volumeId: string,
+        nameHashes: string[],
+        signal?: AbortSignal,
+    ): Promise<
+        {
+            nameHash: string;
+            contentHash: string;
+            nodeUid: string;
+            clientUid?: string;
+        }[]
+    > {
+        const response = await this.apiService.post<PostPhotoDuplicateRequest, PostPhotoDuplicateResponse>(
+            `drive/volumes/${volumeId}/photos/duplicates`,
+            {
+                NameHashes: nameHashes,
+            },
+            signal,
+        );
+
+        return response.DuplicateHashes.map((duplicate) => {
+            if (!duplicate.Hash || !duplicate.ContentHash || duplicate.LinkState !== 1 /* Active */) {
+                return undefined;
+            }
+            return {
+                nameHash: duplicate.Hash,
+                contentHash: duplicate.ContentHash,
+                nodeUid: makeNodeUid(volumeId, duplicate.LinkID),
+                clientUid: duplicate.ClientUID || undefined,
+            };
+        }).filter((duplicate) => duplicate !== undefined);
+    }
 }

package/src/internal/photos/index.ts

@@ -24,6 +24,10 @@ import {
     PhotoUploadManager,
     PhotoUploadMetadata,
 } from './upload';
+import { ShareTargetType } from '../shares';
+
+// Only photos and albums can be shared in photos volume.
+export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
 
 /**
  * Provides facade for the whole photos module.
@@ -32,12 +36,20 @@ import {
  * including API communication, crypto, caching, and event handling.
  */
 export function initPhotosModule(
+    telemetry: ProtonDriveTelemetry,
     apiService: DriveAPIService,
+    driveCrypto: DriveCrypto,
     photoShares: PhotoSharesManager,
     nodesService: NodesService,
 ) {
     const api = new PhotosAPIService(apiService);
-    const timeline = new PhotosTimeline(api, photoShares);
+    const timeline = new PhotosTimeline(
+        telemetry.getLogger('photos-timeline'),
+        api,
+        driveCrypto,
+        photoShares,
+        nodesService,
+    );
     const albums = new Albums(api, photoShares, nodesService);
 
     return {

package/src/internal/photos/interface.ts

@@ -4,7 +4,7 @@ import { DecryptedNode } from '../nodes';
 import { EncryptedShare } from '../shares';
 
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
@@ -26,4 +26,7 @@ export interface SharesService {
 export interface NodesService {
     getNode(nodeUid: string): Promise<DecryptedNode>;
     iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
+    getNodeKeys(nodeUid: string): Promise<{
+        hashKey?: Uint8Array;
+    }>;
 }

package/src/internal/photos/shares.ts

@@ -34,7 +34,7 @@ export class PhotoSharesManager {
         this.sharesService = sharesService;
     }
 
-    async getOwnVolumeIDs(): Promise<VolumeShareNodeIDs> {
+    async getRootIDs(): Promise<VolumeShareNodeIDs> {
         if (this.photoRootIds) {
             return this.photoRootIds;
         }
@@ -113,7 +113,7 @@ export class PhotoSharesManager {
     }
 
     async isOwnVolume(volumeId: string): Promise<boolean> {
-        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        const { volumeId: myVolumeId } = await this.getRootIDs();
         if (volumeId === myVolumeId) {
             return true;
         }
@@ -121,7 +121,7 @@ export class PhotoSharesManager {
     }
 
     async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
-        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        const { volumeId: myVolumeId } = await this.getRootIDs();
         if (volumeId === myVolumeId) {
             return MetricVolumeType.OwnVolume;
         }

package/src/internal/photos/timeline.test.ts

@@ -0,0 +1,116 @@
+import { getMockLogger } from '../../tests/logger';
+import { DriveCrypto } from '../../crypto';
+import { makeNodeUid } from '../uids';
+import { PhotosAPIService } from './apiService';
+import { NodesService } from './interface';
+import { PhotoSharesManager } from './shares';
+import { PhotosTimeline } from './timeline';
+
+describe('PhotosTimeline', () => {
+    let logger: ReturnType<typeof getMockLogger>;
+    let apiService: PhotosAPIService;
+    let driveCrypto: DriveCrypto;
+    let photoShares: PhotoSharesManager;
+    let nodesService: NodesService;
+    let timeline: PhotosTimeline;
+
+    const volumeId = 'volumeId';
+    const rootNodeId = 'rootNodeId';
+    const rootNodeUid = makeNodeUid(volumeId, rootNodeId);
+    const hashKey = new Uint8Array([1, 2, 3]);
+    const name = 'photo.jpg';
+    const nameHash = 'nameHash123';
+    const sha1 = 'sha1Hash123';
+    const contentHash = 'contentHash123';
+
+    beforeEach(() => {
+        logger = getMockLogger();
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {
+            checkPhotoDuplicates: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        driveCrypto = {
+            generateLookupHash: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        photoShares = {
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId, rootNodeId }),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesService = {
+            getNodeKeys: jest.fn().mockResolvedValue({ hashKey }),
+        };
+
+        timeline = new PhotosTimeline(logger, apiService, driveCrypto, photoShares, nodesService);
+    });
+
+    describe('isDuplicatePhoto', () => {
+        it('should not call sha1 callback when there is no name hash match', async () => {
+            const generateSha1 = jest.fn();
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue([]);
+            driveCrypto.generateLookupHash = jest.fn().mockResolvedValue(nameHash);
+
+            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+
+            expect(result).toBe(false);
+            expect(generateSha1).not.toHaveBeenCalled();
+            expect(photoShares.getRootIDs).toHaveBeenCalled();
+            expect(nodesService.getNodeKeys).toHaveBeenCalledWith(rootNodeUid);
+            expect(driveCrypto.generateLookupHash).toHaveBeenCalledWith(name, hashKey);
+            expect(apiService.checkPhotoDuplicates).toHaveBeenCalledWith(volumeId, [nameHash], undefined);
+        });
+
+        it('should call sha1 callback and not logger when name hash match but content hash does not', async () => {
+            const generateSha1 = jest.fn().mockResolvedValue(sha1);
+            const duplicates = [
+                {
+                    nameHash: nameHash,
+                    contentHash: 'differentContentHash',
+                    nodeUid: 'volumeId~node1',
+                },
+            ];
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue(duplicates);
+            driveCrypto.generateLookupHash = jest
+                .fn()
+                .mockResolvedValueOnce(nameHash)
+                .mockResolvedValueOnce(contentHash);
+
+            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+
+            expect(result).toBe(false);
+            expect(generateSha1).toHaveBeenCalledTimes(1);
+            expect(driveCrypto.generateLookupHash).toHaveBeenCalledTimes(2);
+            expect(driveCrypto.generateLookupHash).toHaveBeenNthCalledWith(1, name, hashKey);
+            expect(driveCrypto.generateLookupHash).toHaveBeenNthCalledWith(2, sha1, hashKey);
+            expect(logger.debug).not.toHaveBeenCalled();
+        });
+
+        it('should call sha1 and logger when name and content hashes match', async () => {
+            const generateSha1 = jest.fn().mockResolvedValue(sha1);
+            const nodeUid1 = 'volumeId~node1';
+            const duplicates = [
+                {
+                    nameHash: nameHash,
+                    contentHash: contentHash,
+                    nodeUid: nodeUid1,
+                },
+            ];
+            apiService.checkPhotoDuplicates = jest.fn().mockResolvedValue(duplicates);
+            driveCrypto.generateLookupHash = jest
+                .fn()
+                .mockResolvedValueOnce(nameHash)
+                .mockResolvedValueOnce(contentHash);
+
+            const result = await timeline.isDuplicatePhoto(name, generateSha1);
+
+            expect(result).toBe(true);
+            expect(generateSha1).toHaveBeenCalledTimes(1);
+            expect(logger.debug).toHaveBeenCalledTimes(1);
+            expect(logger.debug).toHaveBeenCalledWith(
+                `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUid1}`,
+            );
+        });
+    });
+});
+

package/src/internal/photos/timeline.ts

@@ -1,4 +1,8 @@
+import { DriveCrypto } from '../../crypto';
+import { Logger } from '../../interface';
+import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
+import { NodesService } from './interface';
 import { PhotoSharesManager } from './shares';
 
 /**
@@ -6,19 +10,60 @@ import { PhotoSharesManager } from './shares';
  */
 export class PhotosTimeline {
     constructor(
+        private logger: Logger,
         private apiService: PhotosAPIService,
+        private driveCrypto: DriveCrypto,
         private photoShares: PhotoSharesManager,
+        private nodesService: NodesService,
     ) {
+        this.logger = logger;
         this.apiService = apiService;
+        this.driveCrypto = driveCrypto;
         this.photoShares = photoShares;
+        this.nodesService = nodesService;
     }
 
-    async* iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
+    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
         nodeUid: string;
         captureTime: Date;
         tags: number[];
     }> {
-        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+        const { volumeId } = await this.photoShares.getRootIDs();
         yield* this.apiService.iterateTimeline(volumeId, signal);
     }
+
+    async isDuplicatePhoto(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<boolean> {
+        const { volumeId, rootNodeId } = await this.photoShares.getRootIDs();
+        const rootNodeUid = makeNodeUid(volumeId, rootNodeId);
+        const { hashKey } = await this.nodesService.getNodeKeys(rootNodeUid);
+        if (!hashKey) {
+            throw new Error('Hash key of photo root node not found');
+        }
+
+        const nameHash = await this.driveCrypto.generateLookupHash(name, hashKey);
+        const duplicates = await this.apiService.checkPhotoDuplicates(volumeId, [nameHash], signal);
+
+        if (duplicates.length === 0) {
+            return false;
+        }
+
+        // Generate the SHA1 only when there is any matching node hash to avoid
+        // computing it for every node as in most cases there is no match.
+        const sha1 = await generateSha1();
+        const contentHash = await this.driveCrypto.generateLookupHash(sha1, hashKey);
+
+        const matchingDuplicates = duplicates.filter(
+            (duplicate) => duplicate.nameHash === nameHash && duplicate.contentHash === contentHash,
+        );
+
+        if (matchingDuplicates.length === 0) {
+            return false;
+        }
+
+        const nodeUids = matchingDuplicates.map((duplicate) => duplicate.nodeUid);
+        this.logger.debug(
+            `Duplicate photo found: name hash: ${nameHash}, content hash: ${contentHash}, node uids: ${nodeUids}`,
+        );
+        return true;
+    }
 }

package/src/internal/shares/cryptoService.ts

@@ -9,7 +9,7 @@ import {
     MetricVolumeType,
 } from '../../interface';
 import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
-import { getVerificationMessage } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from '../errors';
 import {
     EncryptedRootShare,
     DecryptedRootShare,
@@ -119,6 +119,10 @@ export class SharesCryptoService {
     }
 
     private reportDecryptionError(share: EncryptedRootShare, error?: unknown) {
+        if (isNotApplicationError(error)) {
+            return;
+        }
+
         if (this.reportedDecryptionErrors.has(share.shareId)) {
             return;
         }

package/src/internal/shares/index.ts

@@ -12,6 +12,7 @@ import { SharesCache } from './cache';
 import { SharesCryptoService } from './cryptoService';
 import { SharesManager } from './manager';
 
+export { ShareTargetType } from './interface';
 export type { EncryptedShare } from './interface';
 
 /**

package/src/internal/shares/interface.ts

@@ -1,6 +1,15 @@
 import { PrivateKey, SessionKey } from '../../crypto';
 import { Result, UnverifiedAuthorError } from '../../interface';
 
+export enum ShareTargetType {
+    Root = 0,
+    Folder = 1,
+    File = 2,
+    Album = 3,
+    Photo = 4,
+    ProtonVendor = 5,
+}
+
 /**
  * Internal interface providing basic identification of volume and its root
  * share and node.

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

@@ -50,7 +50,7 @@ describe('SharesManager', () => {
         manager = new SharesManager(getMockLogger(), apiService, cache, cryptoCache, cryptoService, account);
     });
 
-    describe('getOwnVolumeIDs', () => {
+    describe('getRootIDs', () => {
         const myFilesShare = {
             shareId: 'myFilesShareId',
             volumeId: 'myFilesVolumeId',
@@ -71,8 +71,8 @@ describe('SharesManager', () => {
             cryptoService.decryptRootShare = jest.fn().mockResolvedValue({ share: myFilesShare, key });
 
             // Calling twice to check if it loads only once.
-            await manager.getOwnVolumeIDs();
-            const result = await manager.getOwnVolumeIDs();
+            await manager.getRootIDs();
+            const result = await manager.getRootIDs();
 
             expect(result).toStrictEqual(myFilesShare);
             expect(apiService.getMyFiles).toHaveBeenCalledTimes(1);
@@ -103,7 +103,7 @@ describe('SharesManager', () => {
             });
             apiService.createVolume = jest.fn().mockResolvedValue(myFilesShare);
 
-            const result = await manager.getOwnVolumeIDs();
+            const result = await manager.getRootIDs();
 
             expect(result).toStrictEqual(myFilesShare);
             expect(cryptoService.decryptRootShare).not.toHaveBeenCalled();
@@ -113,7 +113,7 @@ describe('SharesManager', () => {
         it('should throw on unknown error', async () => {
             apiService.getMyFiles = jest.fn().mockRejectedValue(new Error('Some error'));
 
-            await expect(manager.getOwnVolumeIDs()).rejects.toThrow('Some error');
+            await expect(manager.getRootIDs()).rejects.toThrow('Some error');
             expect(cryptoService.decryptRootShare).not.toHaveBeenCalled();
             expect(apiService.createVolume).not.toHaveBeenCalled();
         });
@@ -142,7 +142,7 @@ describe('SharesManager', () => {
 
     describe('getMyFilesShareMemberEmailKey', () => {
         it('should return cached volume email key', async () => {
-            jest.spyOn(manager, 'getOwnVolumeIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
+            jest.spyOn(manager, 'getRootIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
             cache.getVolume = jest.fn().mockResolvedValue({ addressId: 'addressId' });
             account.getOwnAddress = jest
                 .fn()
@@ -158,7 +158,7 @@ describe('SharesManager', () => {
         });
 
         it('should load volume email key if not in cache', async () => {
-            jest.spyOn(manager, 'getOwnVolumeIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
+            jest.spyOn(manager, 'getRootIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
             const share = {
                 volumeId: 'volumeId',
                 shareId: 'shareId',

package/src/internal/shares/manager.ts

@@ -46,7 +46,7 @@ export class SharesManager {
      *
      * If the default volume or My files section doesn't exist, it creates it.
      */
-    async getOwnVolumeIDs(): Promise<VolumeShareNodeIDs> {
+    async getRootIDs(): Promise<VolumeShareNodeIDs> {
         if (this.myFilesIds) {
             return this.myFilesIds;
         }
@@ -140,7 +140,7 @@ export class SharesManager {
         addressKey: PrivateKey;
         addressKeyId: string;
     }> {
-        const { volumeId } = await this.getOwnVolumeIDs();
+        const { volumeId } = await this.getRootIDs();
 
         try {
             const { addressId } = await this.cache.getVolume(volumeId);
@@ -196,11 +196,11 @@ export class SharesManager {
     }
 
     async isOwnVolume(volumeId: string): Promise<boolean> {
-        return (await this.getOwnVolumeIDs()).volumeId === volumeId;
+        return (await this.getRootIDs()).volumeId === volumeId;
     }
 
     async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
-        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        const { volumeId: myVolumeId } = await this.getRootIDs();
 
         // SDK doesn't support public sharing yet, also public sharing
         // doesn't use a volume but shareURL, thus we can simplify and

package/src/internal/sharing/apiService.ts

@@ -7,6 +7,7 @@ import {
     permissionsToMemberRole,
     memberRoleToPermission,
 } from '../apiService';
+import { ShareTargetType } from '../shares';
 import {
     makeNodeUid,
     splitNodeUid,
@@ -119,14 +120,6 @@ type PutShareUrlRequest = Extract<
 type PutShareUrlResponse =
     drivePaths['/drive/shares/{shareID}/urls/{urlID}']['put']['responses']['200']['content']['application/json'];
 
-// We do not support photos and albums yet.
-const SUPPORTED_SHARE_TARGET_TYPES = [
-    0, // Root
-    1, // Folder
-    2, // File
-    5, // Proton vendor (documents and sheets)
-];
-
 /**
  * Provides API communication for fetching and managing sharing.
  *
@@ -137,9 +130,11 @@ export class SharingAPIService {
     constructor(
         private logger: Logger,
         private apiService: DriveAPIService,
+        private shareTargetTypes: ShareTargetType[],
     ) {
         this.logger = logger;
         this.apiService = apiService;
+        this.shareTargetTypes = shareTargetTypes;
     }
 
     async *iterateSharedNodeUids(volumeId: string, signal?: AbortSignal): AsyncGenerator<string> {
@@ -163,6 +158,7 @@ export class SharingAPIService {
     async *iterateSharedWithMeNodeUids(signal?: AbortSignal): AsyncGenerator<string> {
         let anchor = '';
         while (true) {
+            // TODO: Use ShareTargetTypes filter when it is supported by the API.
             const response = await this.apiService.get<GetSharedWithMeNodesResponse>(
                 `drive/v2/sharedwithme?${anchor ? `AnchorID=${anchor}` : ''}`,
                 signal,
@@ -170,8 +166,8 @@ export class SharingAPIService {
             for (const link of response.Links) {
                 const nodeUid = makeNodeUid(link.VolumeID, link.LinkID);
 
-                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(link.ShareTargetType)) {
-                    this.logger.warn(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
+                if (!this.shareTargetTypes.includes(link.ShareTargetType)) {
+                    this.logger.debug(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
                     continue;
                 }
 
@@ -188,14 +184,21 @@ export class SharingAPIService {
     async *iterateInvitationUids(signal?: AbortSignal): AsyncGenerator<string> {
         let anchor = '';
         while (true) {
+            const params = new URLSearchParams();
+            this.shareTargetTypes.forEach((type) => {
+                params.append('ShareTargetTypes[]', type.toString());
+            });
+            if (anchor) {
+                params.append('AnchorID', anchor);
+            }
             const response = await this.apiService.get<GetInvitationsResponse>(
-                `drive/v2/shares/invitations?${anchor ? `AnchorID=${anchor}` : ''}`,
+                `drive/v2/shares/invitations?${params.toString()}`,
                 signal,
             );
             for (const invitation of response.Invitations) {
                 const invitationUid = makeInvitationUid(invitation.ShareID, invitation.InvitationID);
 
-                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(invitation.ShareTargetType)) {
+                if (!this.shareTargetTypes.includes(invitation.ShareTargetType)) {
                     this.logger.warn(
                         `Unsupported share target type ${invitation.ShareTargetType} for invitation ${invitationUid}`,
                     );

package/src/internal/sharing/index.ts

@@ -1,6 +1,7 @@
 import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from '../../interface';
 import { DriveCrypto } from '../../crypto';
 import { DriveAPIService } from '../apiService';
+import { ShareTargetType } from '../shares';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
@@ -9,6 +10,10 @@ import { SharingManagement } from './sharingManagement';
 import { SharesService, NodesService } from './interface';
 import { SharingEventHandler } from './events';
 
+// Root shares are not allowed to be shared.
+// Photos and Albums are not supported in main volume (core Drive).
+const DEFAULT_SHARE_TARGET_TYPES = [ShareTargetType.Folder, ShareTargetType.File, ShareTargetType.ProtonVendor];
+
 /**
  * Provides facade for the whole sharing module.
  *
@@ -24,8 +29,9 @@ export function initSharingModule(
     crypto: DriveCrypto,
     sharesService: SharesService,
     nodesService: NodesService,
+    shareTargetTypes: ShareTargetType[] = DEFAULT_SHARE_TARGET_TYPES,
 ) {
-    const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService);
+    const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService, shareTargetTypes);
     const cache = new SharingCache(driveEntitiesCache);
     const cryptoService = new SharingCryptoService(telemetry, crypto, account, sharesService);
     const sharingAccess = new SharingAccess(api, cache, cryptoService, sharesService, nodesService);

package/src/internal/sharing/interface.ts

@@ -142,7 +142,7 @@ export interface PublicLinkWithCreatorEmail extends PublicLink {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string }>;
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;

package/src/internal/sharing/sharingAccess.test.ts

@@ -93,7 +93,7 @@ describe('SharingAccess', () => {
 
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             loadEncryptedShare: jest.fn().mockResolvedValue({
                 id: 'shareId',
                 membership: { memberUid: 'memberUid' },

package/src/internal/sharing/sharingAccess.ts

@@ -40,7 +40,7 @@ export class SharingAccess {
             const nodeUids = await this.cache.getSharedByMeNodeUids();
             yield* this.iterateSharedNodesFromCache(nodeUids, signal);
         } catch {
-            const { volumeId } = await this.sharesService.getOwnVolumeIDs();
+            const { volumeId } = await this.sharesService.getRootIDs();
             const nodeUidsIterator = this.apiService.iterateSharedNodeUids(volumeId, signal);
             yield* this.iterateSharedNodesFromAPI(
                 nodeUidsIterator,