@protontech/drive-sdk 0.3.2 → 0.4.0

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

@@ -5,6 +5,7 @@ import { NodesAccess } from './nodesAccess';
 import { DecryptedNode } from './interface';
 import { NodesManagement } from './nodesManagement';
 import { NodeResult } from '../../interface';
+import { NodeOutOfSyncError } from './errors';
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;
@@ -49,6 +50,7 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
+            copyNode: jest.fn(),
             trashNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
@@ -71,7 +73,7 @@ describe('NodesManagement', () => {
                 armoredNodeName: 'newArmoredNodeName',
                 hash: 'newHash',
             }),
-            moveNode: jest.fn(),
+            encryptNodeWithNewParent: jest.fn(),
             createFolder: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
@@ -100,6 +102,7 @@ describe('NodesManagement', () => {
             getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'root-email', addressKey: 'root-key' }),
             notifyNodeChanged: jest.fn(),
             notifyNodeDeleted: jest.fn(),
+            notifyChildCreated: jest.fn(),
         };
 
         management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess);
@@ -130,6 +133,15 @@ describe('NodesManagement', () => {
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
     });
 
+    it('renameNode refreshes cache if node is out of sync', async () => {
+        const error = new NodeOutOfSyncError('Node is out of sync');
+        apiService.renameNode = jest.fn().mockRejectedValue(error);
+
+        await expect(management.renameNode('nodeUid', 'new name')).rejects.toThrow(error);
+
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
+    });
+
     it('moveNode manages move and updates cache', async () => {
         const encryptedCrypto = {
             encryptedName: 'movedArmoredNodeName',
@@ -139,7 +151,7 @@ describe('NodesManagement', () => {
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
         };
-        cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('nodeUid', 'newParentNodeUid');
 
@@ -152,7 +164,7 @@ describe('NodesManagement', () => {
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
         });
         expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
-        expect(cryptoService.moveNode).toHaveBeenCalledWith(
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
             nodes.nodeUid,
             expect.objectContaining({
                 key: 'nodeUid-key',
@@ -188,11 +200,11 @@ describe('NodesManagement', () => {
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
         };
-        cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('anonymousNodeUid', 'newParentNodeUid');
 
-        expect(cryptoService.moveNode).toHaveBeenCalledWith(
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
             nodes.anonymousNodeUid,
             expect.objectContaining({
                 key: 'anonymousNodeUid-key',
@@ -224,6 +236,89 @@ describe('NodesManagement', () => {
         );
     });
 
+    it('copyNode manages copy and updates cache', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            armoredNodePassphrase: 'copiedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'copiedArmoredNodePassphraseSignature',
+            signatureEmail: 'copiedSignatureEmail',
+            nameSignatureEmail: 'copiedNameSignatureEmail',
+        };
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newNode = await management.copyNode('nodeUid', 'newParentNodeUid');
+
+        expect(newNode).toEqual({
+            ...nodes.nodeUid,
+            parentUid: 'newParentNodeUid',
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            keyAuthor: { ok: true, value: 'copiedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'copiedNameSignatureEmail' },
+        });
+        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
+            nodes.nodeUid,
+            expect.objectContaining({
+                key: 'nodeUid-key',
+                passphrase: 'nodeUid-passphrase',
+                passphraseSessionKey: 'nodeUid-passphraseSessionKey',
+                contentKeyPacketSessionKey: 'nodeUid-contentKeyPacketSessionKey',
+                nameSessionKey: 'nodeUid-nameSessionKey',
+            }),
+            expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
+            { email: 'root-email', addressKey: 'root-key' },
+        );
+        expect(apiService.copyNode).toHaveBeenCalledWith('nodeUid', {
+            parentUid: 'newParentNodeUid',
+            ...encryptedCrypto,
+            armoredNodePassphraseSignature: undefined,
+            signatureEmail: undefined,
+        });
+        expect(nodesAccess.notifyNodeChanged).not.toHaveBeenCalledWith();
+        expect(nodesAccess.notifyChildCreated).toHaveBeenCalledWith('newParentNodeUid');
+    });
+
+    it('copyNode manages copy of anonymous node', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            armoredNodePassphrase: 'copiedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'copiedArmoredNodePassphraseSignature',
+            signatureEmail: 'copiedSignatureEmail',
+            nameSignatureEmail: 'copiedNameSignatureEmail',
+        };
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newNode = await management.copyNode('anonymousNodeUid', 'newParentNodeUid');
+
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
+            nodes.anonymousNodeUid,
+            expect.objectContaining({
+                key: 'anonymousNodeUid-key',
+                passphrase: 'anonymousNodeUid-passphrase',
+                passphraseSessionKey: 'anonymousNodeUid-passphraseSessionKey',
+                contentKeyPacketSessionKey: 'anonymousNodeUid-contentKeyPacketSessionKey',
+                nameSessionKey: 'anonymousNodeUid-nameSessionKey',
+            }),
+            expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
+            { email: 'root-email', addressKey: 'root-key' },
+        );
+        expect(newNode).toEqual({
+            ...nodes.anonymousNodeUid,
+            parentUid: 'newParentNodeUid',
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            keyAuthor: { ok: true, value: 'copiedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'copiedNameSignatureEmail' },
+        });
+        expect(apiService.copyNode).toHaveBeenCalledWith('anonymousNodeUid', {
+            parentUid: 'newParentNodeUid',
+            ...encryptedCrypto,
+        });
+    });
+
     it('trashes node and updates cache', async () => {
         const uids = ['v1~n1', 'v1~n2'];
         const trashed = new Set();

package/src/internal/nodes/nodesManagement.ts

@@ -3,14 +3,15 @@ import { c } from 'ttag';
 import { MemberRole, NodeType, NodeResult, resultOk } from '../../interface';
 import { AbortError, ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
+import { splitNodeUid } from '../uids';
 import { NodeAPIService } from './apiService';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { NodeOutOfSyncError } from './errors';
 import { DecryptedNode } from './interface';
 import { NodesAccess } from './nodesAccess';
 import { validateNodeName } from './validations';
 import { generateFolderExtendedAttributes } from './extendedAttributes';
-import { splitNodeUid } from '../uids';
 
 /**
  * Provides high-level actions for managing nodes.
@@ -63,17 +64,28 @@ export class NodesManagement {
             throw new Error('Node hash not generated');
         }
 
-        await this.apiService.renameNode(
-            nodeUid,
-            {
-                hash: node.hash,
-            },
-            {
-                encryptedName: armoredNodeName,
-                nameSignatureEmail: signatureEmail,
-                hash: hash,
-            },
-        );
+        try {
+            await this.apiService.renameNode(
+                nodeUid,
+                {
+                    hash: node.hash,
+                },
+                {
+                    encryptedName: armoredNodeName,
+                    nameSignatureEmail: signatureEmail,
+                    hash: hash,
+                },
+            );
+        } catch (error: unknown) {
+            // If node is out of sync, we notify cache to refresh it before next usage.
+            // We let the code still throw the error as it must bubble to the user
+            // so user can re-open the node to ensure they still want to rename it.
+            if (error instanceof NodeOutOfSyncError) {
+                await this.nodesAccess.notifyNodeChanged(nodeUid);
+            }
+            throw error;
+        }
+
         await this.nodesAccess.notifyNodeChanged(nodeUid);
         const newNode: DecryptedNode = {
             ...node,
@@ -125,7 +137,7 @@ export class NodesManagement {
             throw new ValidationError(c('Error').t`Moving item to a non-folder is not allowed`);
         }
 
-        const encryptedCrypto = await this.cryptoService.moveNode(
+        const encryptedCrypto = await this.cryptoService.encryptNodeWithNewParent(
             node,
             keys,
             { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
@@ -170,6 +182,81 @@ export class NodesManagement {
         return newNode;
     }
 
+    // Improvement requested: copy nodes in parallel
+    async *copyNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        for (const nodeUid of nodeUids) {
+            if (signal?.aborted) {
+                throw new AbortError(c('Error').t`Copy operation aborted`);
+            }
+            try {
+                await this.copyNode(nodeUid, newParentNodeUid);
+                yield {
+                    uid: nodeUid,
+                    ok: true,
+                };
+            } catch (error: unknown) {
+                yield {
+                    uid: nodeUid,
+                    ok: false,
+                    error: getErrorMessage(error),
+                };
+            }
+        }
+    }
+
+    async copyNode(nodeUid: string, newParentUid: string): Promise<DecryptedNode> {
+        const [node, address] = await Promise.all([
+            this.nodesAccess.getNode(nodeUid),
+            this.nodesAccess.getRootNodeEmailKey(newParentUid),
+        ]);
+
+        const [keys, newParentKeys] = await Promise.all([
+            this.nodesAccess.getNodePrivateAndSessionKeys(nodeUid),
+            this.nodesAccess.getNodeKeys(newParentUid),
+        ]);
+
+        if (!newParentKeys.hashKey) {
+            throw new ValidationError(c('Error').t`Copying item to a non-folder is not allowed`);
+        }
+
+        const encryptedCrypto = await this.cryptoService.encryptNodeWithNewParent(
+            node,
+            keys,
+            { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
+            address,
+        );
+
+        // Node could be uploaded or renamed by anonymous user and thus have
+        // missing signatures that must be added to the copy request.
+        // Node passphrase and signature email must be passed if and only if
+        // the the signatures are missing (key author is null).
+        const anonymousKey = node.keyAuthor.ok && node.keyAuthor.value === null;
+        const keySignatureProperties = !anonymousKey
+            ? {}
+            : {
+                  signatureEmail: encryptedCrypto.signatureEmail,
+                  armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
+              };
+        await this.apiService.copyNode(nodeUid, {
+            ...keySignatureProperties,
+            parentUid: newParentUid,
+            armoredNodePassphrase: encryptedCrypto.armoredNodePassphrase,
+            encryptedName: encryptedCrypto.encryptedName,
+            nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
+            hash: encryptedCrypto.hash,
+        });
+        const newNode: DecryptedNode = {
+            ...node,
+            encryptedName: encryptedCrypto.encryptedName,
+            parentUid: newParentUid,
+            hash: encryptedCrypto.hash,
+            keyAuthor: resultOk(encryptedCrypto.signatureEmail),
+            nameAuthor: resultOk(encryptedCrypto.nameSignatureEmail),
+        };
+        await this.nodesAccess.notifyChildCreated(newParentUid);
+        return newNode;
+    }
+
     async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for await (const result of this.apiService.trashNodes(nodeUids, signal)) {
             if (result.ok) {

package/src/internal/photos/albums.ts

@@ -1,29 +1,48 @@
+import { BatchLoading } from '../batchLoading';
+import { DecryptedNode } from '../nodes';
 import { PhotosAPIService } from './apiService';
-import { PhotosCache } from './cache';
 import { NodesService } from './interface';
+import { PhotoSharesManager } from './shares';
 
+const BATCH_LOADING_SIZE = 10;
+
+/**
+ * Provides access and high-level actions for managing albums.
+ */
 export class Albums {
     constructor(
         private apiService: PhotosAPIService,
-        private cache: PhotosCache,
+        private photoShares: PhotoSharesManager,
         private nodesService: NodesService,
     ) {
         this.apiService = apiService;
-        this.cache = cache;
+        this.photoShares = photoShares;
         this.nodesService = nodesService;
     }
 
-    async *iterateAlbums() {
-        for await (const album of this.apiService.iterateAlbums()) {
-            const node = await this.nodesService.getNode(album.uid);
-            yield {
-                node,
-            };
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+
+        const batchLoading = new BatchLoading<string, DecryptedNode>({
+            iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),
+            batchSize: BATCH_LOADING_SIZE,
+        });
+        for await (const album of this.apiService.iterateAlbums(volumeId, signal)) {
+            yield* batchLoading.load(album.albumUid);
         }
+        yield* batchLoading.loadRest();
     }
 
-    async createAlbum(albumName: string) {
-        const albumdUid = this.apiService.createAlbum(albumName);
-        await this.cache.setAlbum(albumdUid);
+    private async *iterateNodesAndIgnoreMissingOnes(
+        nodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
+        const nodeGenerator = this.nodesService.iterateNodes(nodeUids, signal);
+        for await (const node of nodeGenerator) {
+            if ('missingUid' in node) {
+                continue;
+            }
+            yield node;
+        }
     }
 }

package/src/internal/photos/apiService.ts

@@ -1,13 +1,168 @@
-import { DriveAPIService } from '../apiService';
+import { c } from 'ttag';
 
+import { DriveAPIService, drivePaths, NotFoundAPIError } from '../apiService';
+import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
+import { makeNodeUid } from '../uids';
+
+type GetVolumesResponse = drivePaths['/drive/volumes']['get']['responses']['200']['content']['application/json'];
+
+type GetShareResponse = drivePaths['/drive/shares/{shareID}']['get']['responses']['200']['content']['application/json'];
+
+type PostCreateVolumeRequest = Extract<
+    drivePaths['/drive/photos/volumes']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateVolumeResponse =
+    drivePaths['/drive/photos/volumes']['post']['responses']['200']['content']['application/json'];
+
+type GetTimelineResponse =
+    drivePaths['/drive/volumes/{volumeID}/photos']['get']['responses']['200']['content']['application/json'];
+
+type GetAlbumsResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/albums']['get']['responses']['200']['content']['application/json'];
+
+/**
+ * Provides API communication for fetching and manipulating photos and albums
+ * metadata.
+ *
+ * The service is responsible for transforming local objects to API payloads
+ * and vice versa. It should not contain any business logic.
+ */
 export class PhotosAPIService {
     constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
     }
 
-    async *iterateTimeline(): AsyncGenerator<any> {}
+    async getPhotoShare(): Promise<EncryptedRootShare> {
+        // TODO: Switch to drive/v2/shares/photos once available.
+
+        const volumesResponse = await this.apiService.get<GetVolumesResponse>('drive/volumes');
+
+        const photoVolume = volumesResponse.Volumes.find((volume) => volume.Type === 2);
+
+        if (!photoVolume) {
+            throw new NotFoundAPIError(c('Error').t`Photo volume not found`);
+        }
+
+        const response = await this.apiService.get<GetShareResponse>(`drive/shares/${photoVolume.Share.ShareID}`);
 
-    async *iterateAlbums(): AsyncGenerator<any> {}
+        if (!response.AddressID) {
+            throw new Error('Photo root share has not address ID set');
+        }
 
-    async createAlbum(object: any): Promise<any> {}
+        return {
+            volumeId: response.VolumeID,
+            shareId: response.ShareID,
+            rootNodeId: response.LinkID,
+            creatorEmail: response.Creator,
+            encryptedCrypto: {
+                armoredKey: response.Key,
+                armoredPassphrase: response.Passphrase,
+                armoredPassphraseSignature: response.PassphraseSignature,
+            },
+            addressId: response.AddressID,
+            type: ShareType.Photo,
+        };
+    }
+
+    async createPhotoVolume(
+        share: {
+            addressId: string;
+            addressKeyId: string;
+        } & EncryptedShareCrypto,
+        node: {
+            encryptedName: string;
+            armoredKey: string;
+            armoredPassphrase: string;
+            armoredPassphraseSignature: string;
+            armoredHashKey: string;
+        },
+    ): Promise<{ volumeId: string; shareId: string; rootNodeId: string }> {
+        const response = await this.apiService.post<PostCreateVolumeRequest, PostCreateVolumeResponse>(
+            'drive/photos/volumes',
+            {
+                Share: {
+                    AddressID: share.addressId,
+                    AddressKeyID: share.addressKeyId,
+                    Key: share.armoredKey,
+                    Passphrase: share.armoredPassphrase,
+                    PassphraseSignature: share.armoredPassphraseSignature,
+                },
+                Link: {
+                    Name: node.encryptedName,
+                    NodeKey: node.armoredKey,
+                    NodePassphrase: node.armoredPassphrase,
+                    NodePassphraseSignature: node.armoredPassphraseSignature,
+                    NodeHashKey: node.armoredHashKey,
+                },
+            },
+        );
+        return {
+            volumeId: response.Volume.VolumeID,
+            shareId: response.Volume.Share.ShareID,
+            rootNodeId: response.Volume.Share.LinkID,
+        };
+    }
+
+    async *iterateTimeline(
+        volumeId: string,
+        signal?: AbortSignal,
+    ): AsyncGenerator<{
+        nodeUid: string;
+        captureTime: Date;
+        tags: number[];
+    }> {
+        let anchor = '';
+        while (true) {
+            const response = await this.apiService.get<GetTimelineResponse>(
+                `drive/volumes/${volumeId}/photos?${anchor ? `PreviousPageLastLinkID=${anchor}` : ''}`,
+                signal,
+            );
+            for (const photo of response.Photos) {
+                const nodeUid = makeNodeUid(volumeId, photo.LinkID);
+                yield {
+                    nodeUid,
+                    captureTime: new Date(photo.CaptureTime * 1000),
+                    tags: photo.Tags,
+                };
+            }
+
+            if (!response.Photos.length) {
+                break;
+            }
+            anchor = response.Photos[response.Photos.length - 1].LinkID;
+        }
+    }
+
+    async *iterateAlbums(
+        volumeId: string,
+        signal?: AbortSignal,
+    ): AsyncGenerator<{
+        albumUid: string;
+        coverNodeUid?: string;
+        photoCount: number;
+        lastActivityTime: Date;
+    }> {
+        let anchor = '';
+        while (true) {
+            const response = await this.apiService.get<GetAlbumsResponse>(
+                `drive/photos/volumes/${volumeId}/albums?${anchor ? `AnchorID=${anchor}` : ''}`,
+                signal,
+            );
+            for (const album of response.Albums) {
+                const albumUid = makeNodeUid(volumeId, album.LinkID);
+                yield {
+                    albumUid,
+                    coverNodeUid: album.CoverLinkID ? makeNodeUid(volumeId, album.CoverLinkID) : undefined,
+                    photoCount: album.PhotoCount,
+                    lastActivityTime: new Date(album.LastActivityTime * 1000),
+                };
+            }
+
+            if (!response.More || !response.AnchorID) {
+                break;
+            }
+            anchor = response.AnchorID;
+        }
+    }
 }

package/src/internal/photos/index.ts

@@ -1,23 +1,68 @@
 import { DriveAPIService } from '../apiService';
-import { ProtonDriveEntitiesCache } from '../../interface';
-import { PhotosAPIService } from './apiService';
-import { PhotosCache } from './cache';
-import { PhotosTimeline } from './photosTimeline';
+import { DriveCrypto } from '../../crypto';
+import {
+    ProtonDriveAccount,
+    ProtonDriveCryptoCache,
+    ProtonDriveEntitiesCache,
+    ProtonDriveTelemetry,
+} from '../../interface';
+import { SharesCache } from '../shares/cache';
+import { SharesCryptoCache } from '../shares/cryptoCache';
+import { SharesCryptoService } from '../shares/cryptoService';
 import { Albums } from './albums';
-import { NodesService } from './interface';
+import { PhotosAPIService } from './apiService';
+import { NodesService, SharesService } from './interface';
+import { PhotoSharesManager } from './shares';
+import { PhotosTimeline } from './timeline';
 
+/**
+ * Provides facade for the whole photos module.
+ *
+ * The photos module is responsible for handling photos and albums metadata,
+ * including API communication, crypto, caching, and event handling.
+ */
 export function initPhotosModule(
     apiService: DriveAPIService,
-    driveEntitiesCache: ProtonDriveEntitiesCache,
+    photoShares: PhotoSharesManager,
     nodesService: NodesService,
 ) {
     const api = new PhotosAPIService(apiService);
-    const cache = new PhotosCache(driveEntitiesCache);
-    const timeline = new PhotosTimeline(api, cache, nodesService);
-    const albums = new Albums(api, cache, nodesService);
+    const timeline = new PhotosTimeline(api, photoShares);
+    const albums = new Albums(api, photoShares, nodesService);
 
     return {
         timeline,
         albums,
     };
 }
+
+/**
+ * Provides facade for the photo share module.
+ *
+ * The photo share wraps the core share module, but uses photos volume instead
+ * of main volume. It provides the same interface so it can be used in the same
+ * way in various modules that use shares.
+ */
+export function initPhotoSharesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    account: ProtonDriveAccount,
+    crypto: DriveCrypto,
+    sharesService: SharesService,
+) {
+    const api = new PhotosAPIService(apiService);
+    const cache = new SharesCache(telemetry.getLogger('shares-cache'), driveEntitiesCache);
+    const cryptoCache = new SharesCryptoCache(telemetry.getLogger('shares-cache'), driveCryptoCache);
+    const cryptoService = new SharesCryptoService(telemetry, crypto, account);
+
+    return new PhotoSharesManager(
+        telemetry.getLogger('photos-shares'),
+        api,
+        cache,
+        cryptoCache,
+        cryptoService,
+        sharesService,
+    );
+}

package/src/internal/photos/interface.ts

@@ -1,5 +1,27 @@
-import { MissingNode } from '../../interface';
+import { PrivateKey } from '../../crypto';
+import { MissingNode, MetricVolumeType } from '../../interface';
 import { DecryptedNode } from '../nodes';
+import { EncryptedShare } from '../shares';
+
+export interface SharesService {
+    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
+    getSharePrivateKey(shareId: string): Promise<PrivateKey>;
+    getMyFilesShareMemberEmailKey(): Promise<{
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }>;
+    getContextShareMemberEmailKey(shareId: string): Promise<{
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }>;
+    isOwnVolume(volumeId: string): Promise<boolean>;
+    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
+}
 
 export interface NodesService {
     getNode(nodeUid: string): Promise<DecryptedNode>;