@protontech/drive-sdk 0.3.2 → 0.4.1

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,130 @@
 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 { NodesService as UploadNodesService } from '../upload/interface';
+import { UploadTelemetry } from '../upload/telemetry';
+import { UploadQueue } from '../upload/queue';
 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';
+import {
+    PhotoFileUploader,
+    PhotoUploadAPIService,
+    PhotoUploadCryptoService,
+    PhotoUploadManager,
+    PhotoUploadMetadata,
+} from './upload';
 
+/**
+ * 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,
+    );
+}
+
+/**
+ * Provides facade for the photo upload module.
+ *
+ * The photo upload wraps the core upload module and adds photo specific metadata.
+ * It provides the same interface so it can be used in the same way.
+ */
+export function initPhotoUploadModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveCrypto: DriveCrypto,
+    sharesService: SharesService,
+    nodesService: UploadNodesService,
+    clientUid?: string,
+) {
+    const api = new PhotoUploadAPIService(apiService, clientUid);
+    const cryptoService = new PhotoUploadCryptoService(driveCrypto, nodesService);
+
+    const uploadTelemetry = new UploadTelemetry(telemetry, sharesService);
+    const manager = new PhotoUploadManager(telemetry, api, cryptoService, nodesService, clientUid);
+
+    const queue = new UploadQueue();
+
+    async function getFileUploader(
+        parentFolderUid: string,
+        name: string,
+        metadata: PhotoUploadMetadata,
+        signal?: AbortSignal,
+    ): Promise<PhotoFileUploader> {
+        await queue.waitForCapacity(signal);
+
+        const onFinish = () => {
+            queue.releaseCapacity();
+        };
+
+        return new PhotoFileUploader(
+            uploadTelemetry,
+            api,
+            cryptoService,
+            manager,
+            parentFolderUid,
+            name,
+            metadata,
+            onFinish,
+            signal,
+        );
+    }
+
+    return {
+        getFileUploader,
+    };
+}

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);
+    }
+}