@protontech/drive-sdk 0.3.1 → 0.4.0

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>;

package/src/internal/photos/shares.ts

@@ -0,0 +1,134 @@
+import { PrivateKey } from '../../crypto';
+import { Logger, MetricVolumeType } from '../../interface';
+import { NotFoundAPIError } from '../apiService';
+import { SharesCache } from '../shares/cache';
+import { SharesCryptoCache } from '../shares/cryptoCache';
+import { SharesCryptoService } from '../shares/cryptoService';
+import { EncryptedShare, VolumeShareNodeIDs } from '../shares/interface';
+import { PhotosAPIService } from './apiService';
+import { SharesService } from './interface';
+
+/**
+ * Provides high-level actions for managing photo share.
+ *
+ * The photo share manager wraps the core share service, 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 class PhotoSharesManager {
+    private photoRootIds?: VolumeShareNodeIDs;
+
+    constructor(
+        private logger: Logger,
+        private apiService: PhotosAPIService,
+        private cache: SharesCache,
+        private cryptoCache: SharesCryptoCache,
+        private cryptoService: SharesCryptoService,
+        private sharesService: SharesService,
+    ) {
+        this.logger = logger;
+        this.apiService = apiService;
+        this.cache = cache;
+        this.cryptoCache = cryptoCache;
+        this.cryptoService = cryptoService;
+        this.sharesService = sharesService;
+    }
+
+    async getOwnVolumeIDs(): Promise<VolumeShareNodeIDs> {
+        if (this.photoRootIds) {
+            return this.photoRootIds;
+        }
+
+        try {
+            const encryptedShare = await this.apiService.getPhotoShare();
+
+            // Once any place needs IDs for My files, it will most likely
+            // need also the keys for decrypting the tree. It is better to
+            // decrypt the share here right away.
+            const { share: myFilesShare, key } = await this.cryptoService.decryptRootShare(encryptedShare);
+            await this.cryptoCache.setShareKey(myFilesShare.shareId, key);
+            await this.cache.setVolume({
+                volumeId: myFilesShare.volumeId,
+                shareId: myFilesShare.shareId,
+                rootNodeId: myFilesShare.rootNodeId,
+                creatorEmail: encryptedShare.creatorEmail,
+                addressId: encryptedShare.addressId,
+            });
+
+            this.photoRootIds = {
+                volumeId: myFilesShare.volumeId,
+                shareId: myFilesShare.shareId,
+                rootNodeId: myFilesShare.rootNodeId,
+            };
+            return this.photoRootIds;
+        } catch (error: unknown) {
+            if (error instanceof NotFoundAPIError) {
+                this.logger.warn('Active photo volume not found, creating a new one');
+                return this.createVolume();
+            }
+            this.logger.error('Failed to get active photo volume', error);
+            throw error;
+        }
+    }
+
+    private async createVolume(): Promise<VolumeShareNodeIDs> {
+        const address = await this.sharesService.getMyFilesShareMemberEmailKey();
+        const bootstrap = await this.cryptoService.generateVolumeBootstrap(address.addressKey);
+        const photoRootIds = await this.apiService.createPhotoVolume(
+            {
+                addressId: address.addressId,
+                addressKeyId: address.addressKeyId,
+                ...bootstrap.shareKey.encrypted,
+            },
+            {
+                ...bootstrap.rootNode.key.encrypted,
+                encryptedName: bootstrap.rootNode.encryptedName,
+                armoredHashKey: bootstrap.rootNode.armoredHashKey,
+            },
+        );
+        await this.cryptoCache.setShareKey(photoRootIds.shareId, bootstrap.shareKey.decrypted);
+        return photoRootIds;
+    }
+
+    async getSharePrivateKey(shareId: string): Promise<PrivateKey> {
+        return this.sharesService.getSharePrivateKey(shareId);
+    }
+
+    async getMyFilesShareMemberEmailKey(): Promise<{
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }> {
+        return this.sharesService.getMyFilesShareMemberEmailKey();
+    }
+
+    async getContextShareMemberEmailKey(shareId: string): Promise<{
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }> {
+        return this.sharesService.getContextShareMemberEmailKey(shareId);
+    }
+
+    async isOwnVolume(volumeId: string): Promise<boolean> {
+        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        if (volumeId === myVolumeId) {
+            return true;
+        }
+        return this.sharesService.isOwnVolume(volumeId);
+    }
+
+    async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
+        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        if (volumeId === myVolumeId) {
+            return MetricVolumeType.OwnVolume;
+        }
+        return this.sharesService.getVolumeMetricContext(volumeId);
+    }
+
+    async loadEncryptedShare(shareId: string): Promise<EncryptedShare> {
+        return this.sharesService.loadEncryptedShare(shareId);
+    }
+}

package/src/internal/photos/timeline.ts

@@ -0,0 +1,24 @@
+import { PhotosAPIService } from './apiService';
+import { PhotoSharesManager } from './shares';
+
+/**
+ * Provides access to the photo timeline.
+ */
+export class PhotosTimeline {
+    constructor(
+        private apiService: PhotosAPIService,
+        private photoShares: PhotoSharesManager,
+    ) {
+        this.apiService = apiService;
+        this.photoShares = photoShares;
+    }
+
+    async* iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
+        nodeUid: string;
+        captureTime: Date;
+        tags: number[];
+    }> {
+        const { volumeId } = await this.photoShares.getOwnVolumeIDs();
+        yield* this.apiService.iterateTimeline(volumeId, signal);
+    }
+}

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

@@ -50,7 +50,7 @@ describe('SharesManager', () => {
         manager = new SharesManager(getMockLogger(), apiService, cache, cryptoCache, cryptoService, account);
     });
 
-    describe('getMyFilesIDs', () => {
+    describe('getOwnVolumeIDs', () => {
         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.getMyFilesIDs();
-            const result = await manager.getMyFilesIDs();
+            await manager.getOwnVolumeIDs();
+            const result = await manager.getOwnVolumeIDs();
 
             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.getMyFilesIDs();
+            const result = await manager.getOwnVolumeIDs();
 
             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.getMyFilesIDs()).rejects.toThrow('Some error');
+            await expect(manager.getOwnVolumeIDs()).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, 'getMyFilesIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
+            jest.spyOn(manager, 'getOwnVolumeIDs').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, 'getMyFilesIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
+            jest.spyOn(manager, 'getOwnVolumeIDs').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 getMyFilesIDs(): Promise<VolumeShareNodeIDs> {
+    async getOwnVolumeIDs(): Promise<VolumeShareNodeIDs> {
         if (this.myFilesIds) {
             return this.myFilesIds;
         }
@@ -140,7 +140,7 @@ export class SharesManager {
         addressKey: PrivateKey;
         addressKeyId: string;
     }> {
-        const { volumeId } = await this.getMyFilesIDs();
+        const { volumeId } = await this.getOwnVolumeIDs();
 
         try {
             const { addressId } = await this.cache.getVolume(volumeId);
@@ -196,11 +196,11 @@ export class SharesManager {
     }
 
     async isOwnVolume(volumeId: string): Promise<boolean> {
-        return (await this.getMyFilesIDs()).volumeId === volumeId;
+        return (await this.getOwnVolumeIDs()).volumeId === volumeId;
     }
 
     async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
-        const { volumeId: myVolumeId } = await this.getMyFilesIDs();
+        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
 
         // 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/cache.ts

@@ -44,11 +44,28 @@ export class SharingCache {
     }
 
     async getSharedWithMeNodeUids(): Promise<string[]> {
-        return this.getNodeUids(SharingType.sharedWithMe);
+        return this.getNodeUids(SharingType.SharedWithMe);
+    }
+
+    async hasSharedWithMeNodeUidsLoaded(): Promise<boolean> {
+        try {
+            await this.getNodeUids(SharingType.SharedWithMe);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async addSharedWithMeNodeUid(nodeUid: string): Promise<void> {
+        return this.addNodeUid(SharingType.SharedWithMe, nodeUid);
+    }
+
+    async removeSharedWithMeNodeUid(nodeUid: string): Promise<void> {
+        return this.removeNodeUid(SharingType.SharedWithMe, nodeUid);
     }
 
     async setSharedWithMeNodeUids(nodeUids: string[] | undefined): Promise<void> {
-        return this.setNodeUids(SharingType.sharedWithMe, nodeUids);
+        return this.setNodeUids(SharingType.SharedWithMe, nodeUids);
     }
 
     /**

package/src/internal/sharing/interface.ts

@@ -5,7 +5,7 @@ import { DecryptedNode } from '../nodes';
 
 export enum SharingType {
     SharedByMe = 'sharedByMe',
-    sharedWithMe = 'sharedWithMe',
+    SharedWithMe = 'sharedWithMe',
 }
 
 /**
@@ -142,7 +142,7 @@ export interface PublicLinkWithCreatorEmail extends PublicLink {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string }>;
+    getOwnVolumeIDs(): Promise<{ volumeId: string }>;
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;