@protontech/drive-sdk 0.3.2 → 0.4.0

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/interface.ts

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

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 = {
-            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getOwnVolumeIDs: 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.getMyFilesIDs();
+            const { volumeId } = await this.sharesService.getOwnVolumeIDs();
             const nodeUidsIterator = this.apiService.iterateSharedNodeUids(volumeId, signal);
             yield* this.iterateSharedNodesFromAPI(
                 nodeUidsIterator,

package/src/protonDriveClient.ts

@@ -27,6 +27,7 @@ import {
     ThumbnailType,
     ThumbnailResult,
     SDKEvent,
+    NodeType,
 } from './interface';
 import {
     getUid,
@@ -252,7 +253,7 @@ export class ProtonDriveClient {
     }
 
     /**
-     * Subscribes to sharing updates.
+     * Subscribes to the remote general data updates.
      *
      * Only one instance of the SDK should subscribe to updates.
      */
@@ -285,7 +286,7 @@ export class ProtonDriveClient {
      */
     async getMyFilesRootFolder(): Promise<MaybeNode> {
         this.logger.info('Getting my files root folder');
-        return convertInternalNodePromise(this.nodes.access.getMyFilesRootFolder());
+        return convertInternalNodePromise(this.nodes.access.getVolumeRootFolder());
     }
 
     /**
@@ -297,9 +298,14 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the children of the given parent node.
      */
-    async *iterateFolderChildren(parentNodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateFolderChildren(
+        parentNodeUid: NodeOrUid,
+        filterOptions?: { type?: NodeType },
+        signal?: AbortSignal,
+    ): AsyncGenerator<MaybeNode> {
         this.logger.info(`Iterating children of ${getUid(parentNodeUid)}`);
-        yield* convertInternalNodeIterator(this.nodes.access.iterateFolderChildren(getUid(parentNodeUid), signal));
+        const iterator = this.nodes.access.iterateFolderChildren(getUid(parentNodeUid), filterOptions, signal);
+        yield* convertInternalNodeIterator(iterator);
     }
 
     /**
@@ -384,6 +390,29 @@ export class ProtonDriveClient {
         yield* this.nodes.management.moveNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
     }
 
+    /**
+     * Copy the nodes to a new parent node.
+     *
+     * The operation is performed node by node and the results are yielded
+     * as they are available. Order of the results is not guaranteed.
+     *
+     * If one of the nodes fails to copy, the operation continues with the
+     * rest of the nodes. Use `NodeResult` to check the status of the action.
+     *
+     * @param nodeUids - List of node entities or their UIDs.
+     * @param newParentNodeUid - Node entity or its UID string.
+     * @param signal - Signal to abort the operation.
+     * @returns An async generator of the results of the copy operation
+     */
+    async *copyNodes(
+        nodeUids: NodeOrUid[],
+        newParentNodeUid: NodeOrUid,
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResult> {
+        this.logger.info(`Copying ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
+        yield* this.nodes.management.copyNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
+    }
+
     /**
      * Trash the nodes.
      *

package/src/protonDrivePhotosClient.ts

@@ -1,19 +1,56 @@
-import { DriveAPIService } from './internal/apiService';
-import { DriveListener, ProtonDriveClientContructorParameters } from './interface';
+import {
+    Logger,
+    ProtonDriveClientContructorParameters,
+    NodeOrUid,
+    MaybeMissingNode,
+    UploadMetadata,
+    FileDownloader,
+    FileUploader,
+    SDKEvent,
+    MaybeNode,
+} from './interface';
+import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
-import { initSharesModule } from './internal/shares';
+import { Telemetry } from './telemetry';
+import { convertInternalMissingNodeIterator, convertInternalNodeIterator, getUid, getUids } from './transformers';
+import { DriveAPIService } from './internal/apiService';
+import { initDownloadModule } from './internal/download';
+import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import { initNodesModule } from './internal/nodes';
-import { initPhotosModule } from './internal/photos';
-import { DriveEventsService } from './internal/events';
+import { initPhotoSharesModule, initPhotosModule } from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
-import { getConfig } from './config';
-import { Telemetry } from './telemetry';
+import { initSharesModule } from './internal/shares';
+import { initSharingModule } from './internal/sharing';
+import { initUploadModule } from './internal/upload';
 
-// TODO: this is only example, on background it use drive internals, but it exposes nice interface for photos
+/**
+ * ProtonDrivePhotosClient is the interface to access Photos functionality.
+ *
+ * The client provides high-level operations for managing photos, albums, sharing,
+ * and downloading/uploading photos.
+ *
+ * @deprecated This is an experimental feature that might change without a warning.
+ */
 export class ProtonDrivePhotosClient {
+    private logger: Logger;
+    private sdkEvents: SDKEvents;
+    private events: DriveEventsService;
+    private photoShares: ReturnType<typeof initPhotoSharesModule>;
     private nodes: ReturnType<typeof initNodesModule>;
+    private sharing: ReturnType<typeof initSharingModule>;
+    private download: ReturnType<typeof initDownloadModule>;
+    private upload: ReturnType<typeof initUploadModule>;
     private photos: ReturnType<typeof initPhotosModule>;
 
+    public experimental: {
+        /**
+         * Experimental feature to return the URL of the node.
+         *
+         * See `ProtonDriveClient.experimental.getNodeUrl` for more information.
+         */
+        getNodeUrl: (nodeUid: NodeOrUid) => Promise<string>;
+    };
+
     constructor({
         httpClient,
         entitiesCache,
@@ -23,41 +60,183 @@ export class ProtonDrivePhotosClient {
         srpModule,
         config,
         telemetry,
+        latestEventIdProvider,
     }: ProtonDriveClientContructorParameters) {
         if (!telemetry) {
             telemetry = new Telemetry();
         }
+        this.logger = telemetry.getLogger('interface');
 
         const fullConfig = getConfig(config);
-        const sdkEvents = new SDKEvents(telemetry);
+        this.sdkEvents = new SDKEvents(telemetry);
         const cryptoModule = new DriveCrypto(openPGPCryptoModule, srpModule);
         const apiService = new DriveAPIService(
             telemetry,
-            sdkEvents,
+            this.sdkEvents,
             httpClient,
             fullConfig.baseUrl,
             fullConfig.language,
         );
-        const shares = initSharesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule);
-        this.nodes = initNodesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule, shares);
-        const cacheEventListeners: DriveListener[] = [this.nodes.eventHandler.updateNodesCacheOnEvent];
-        new DriveEventsService(telemetry, apiService, shares, cacheEventListeners);
-        this.photos = initPhotosModule(apiService, entitiesCache, this.nodes.access);
-    }
-
-    // Timeline or album view
-    iterateTimelinePhotos() {} // returns only UIDs and dates - used to show grid and scrolling
-    iterateAlbumPhotos() {} // same as above but for album
-    iterateThumbnails() {} // returns thumbnails for passed photos that are visible in the UI
-    getPhoto() {} // returns full photo details
-
-    // Album management
-    createAlbum(albumName: string) {
-        return this.photos.albums.createAlbum(albumName);
-    }
-    renameAlbum() {}
-    shareAlbum() {}
-    deleteAlbum() {}
-    iterateAlbums() {}
-    addPhotosToAlbum() {}
+        const coreShares = initSharesModule(telemetry, apiService, entitiesCache, cryptoCache, account, cryptoModule);
+        this.photoShares = initPhotoSharesModule(
+            telemetry,
+            apiService,
+            entitiesCache,
+            cryptoCache,
+            account,
+            cryptoModule,
+            coreShares,
+        );
+        this.nodes = initNodesModule(
+            telemetry,
+            apiService,
+            entitiesCache,
+            cryptoCache,
+            account,
+            cryptoModule,
+            this.photoShares,
+        );
+        this.photos = initPhotosModule(apiService, this.photoShares, this.nodes.access);
+        this.sharing = initSharingModule(
+            telemetry,
+            apiService,
+            entitiesCache,
+            account,
+            cryptoModule,
+            this.photoShares,
+            this.nodes.access,
+        );
+        this.download = initDownloadModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            account,
+            this.photoShares,
+            this.nodes.access,
+            this.nodes.revisions,
+        );
+        this.upload = initUploadModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            this.photoShares,
+            this.nodes.access,
+            fullConfig.clientUid,
+        );
+
+        // These are used to keep the internal cache up to date
+        const cacheEventListeners: DriveListener[] = [
+            this.nodes.eventHandler.updateNodesCacheOnEvent.bind(this.nodes.eventHandler),
+            this.sharing.eventHandler.handleDriveEvent.bind(this.sharing.eventHandler),
+        ];
+        this.events = new DriveEventsService(
+            telemetry,
+            apiService,
+            this.photoShares,
+            cacheEventListeners,
+            latestEventIdProvider,
+        );
+
+        this.experimental = {
+            getNodeUrl: async (nodeUid: NodeOrUid) => {
+                this.logger.debug(`Getting node URL for ${getUid(nodeUid)}`);
+                return this.nodes.access.getNodeUrl(getUid(nodeUid));
+            },
+        };
+    }
+
+    /**
+     * Subscribes to the general SDK events.
+     *
+     * See `ProtonDriveClient.onMessage` for more information.
+     */
+    onMessage(eventName: SDKEvent, callback: () => void): () => void {
+        this.logger.debug(`Subscribing to event ${eventName}`);
+        return this.sdkEvents.addListener(eventName, callback);
+    }
+
+    /**
+     * Subscribes to the remote data updates for all files in a tree.
+     *
+     * See `ProtonDriveClient.subscribeToTreeEvents` for more information.
+     */
+    async subscribeToTreeEvents(treeEventScopeId: string, callback: DriveListener): Promise<EventSubscription> {
+        this.logger.debug('Subscribing to node updates');
+        return this.events.subscribeToTreeEvents(treeEventScopeId, callback);
+    }
+
+    /**
+     * Subscribes to the remote general data updates.
+     *
+     * See `ProtonDriveClient.subscribeToDriveEvents` for more information.
+     */
+    async subscribeToDriveEvents(callback: DriveListener): Promise<EventSubscription> {
+        this.logger.debug('Subscribing to core updates');
+        return this.events.subscribeToCoreEvents(callback);
+    }
+
+    /**
+     * Iterates all the photos for the timeline view.
+     *
+     * The output includes only necessary information to quickly prepare
+     * the whole timeline view with the break-down per month/year and fast
+     * scrollbar.
+     *
+     * Individual photos details must be loaded separately based on what
+     * is visible in the UI.
+     *
+     * The output is sorted by the capture time, starting from the
+     * the most recent photos.
+     */
+    async *iterateTimeline(signal?: AbortSignal): AsyncGenerator<{
+        nodeUid: string;
+        captureTime: Date;
+        tags: number[];
+    }> {
+        // TODO: expose better type
+        yield* this.photos.timeline.iterateTimeline(signal);
+    }
+
+    /**
+     * Iterates the nodes by their UIDs.
+     *
+     * See `ProtonDriveClient.iterateNodes` for more information.
+     */
+    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingNode> {
+        this.logger.info(`Iterating ${nodeUids.length} nodes`);
+        // TODO: expose photo type
+        yield* convertInternalMissingNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
+    }
+
+    /**
+     * Iterates the albums.
+     *
+     * The output is not sorted and the order of the nodes is not guaranteed.
+     */
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating albums');
+        // TODO: expose album type
+        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    }
+
+    /**
+     * Get the file downloader to download the node content.
+     *
+     * See `ProtonDriveClient.getFileDownloader` for more information.
+     */
+    async getFileDownloader(nodeUid: NodeOrUid, signal?: AbortSignal): Promise<FileDownloader> {
+        this.logger.info(`Getting file downloader for ${getUid(nodeUid)}`);
+        return this.download.getFileDownloader(getUid(nodeUid), signal);
+    }
+
+    /**
+     * Get the file uploader to upload a new file.
+     *
+     * See `ProtonDriveClient.getFileUploader` for more information.
+     */
+    async getFileUploader(name: string, metadata: UploadMetadata, signal?: AbortSignal): Promise<FileUploader> {
+        this.logger.info(`Getting file uploader`);
+        const parentFolderUid = await this.nodes.access.getVolumeRootFolder();
+        return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
+    }
 }

package/dist/internal/photos/cache.d.ts

@@ -1,6 +0,0 @@
-import { ProtonDriveEntitiesCache } from '../../interface';
-export declare class PhotosCache {
-    private driveCache;
-    constructor(driveCache: ProtonDriveEntitiesCache);
-    setAlbum(album: any): Promise<void>;
-}

package/dist/internal/photos/cache.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhotosCache = void 0;
-class PhotosCache {
-    driveCache;
-    constructor(driveCache) {
-        this.driveCache = driveCache;
-        this.driveCache = driveCache;
-    }
-    async setAlbum(album) {
-        await this.driveCache.setEntity(album.uid, album);
-    }
-}
-exports.PhotosCache = PhotosCache;
-//# sourceMappingURL=cache.js.map

package/dist/internal/photos/cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../../src/internal/photos/cache.ts"],"names":[],"mappings":";;;AAEA,MAAa,WAAW;IACA;IAApB,YAAoB,UAAoC;QAApC,eAAU,GAAV,UAAU,CAA0B;QACpD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,KAAU;QACrB,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;CACJ;AARD,kCAQC"}

package/dist/internal/photos/photosTimeline.d.ts

@@ -1,10 +0,0 @@
-import { PhotosAPIService } from './apiService';
-import { PhotosCache } from './cache';
-import { NodesService } from './interface';
-export declare class PhotosTimeline {
-    private apiService;
-    private cache;
-    private nodesService;
-    constructor(apiService: PhotosAPIService, cache: PhotosCache, nodesService: NodesService);
-    getTimelineStructure(): Promise<void>;
-}