@protontech/drive-sdk 0.4.0 → 0.5.0

package/src/internal/upload/controller.ts

@@ -2,7 +2,7 @@ import { waitForCondition } from '../wait';
 
 export class UploadController {
     private paused = false;
-    public promise?: Promise<string>;
+    public promise?: Promise<{ nodeRevisionUid: string, nodeUid: string }>;
 
     async waitIfPaused(): Promise<void> {
         await waitForCondition(() => !this.paused);
@@ -16,7 +16,7 @@ export class UploadController {
         this.paused = false;
     }
 
-    async completion(): Promise<string> {
+    async completion(): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         if (!this.promise) {
             throw new Error('UploadController.completion() called before upload started');
         }

package/src/internal/upload/cryptoService.ts

@@ -7,8 +7,8 @@ import { EncryptedBlock, EncryptedThumbnail, NodeCrypto, NodeRevisionDraftKeys,
 
 export class UploadCryptoService {
     constructor(
-        private driveCrypto: DriveCrypto,
-        private nodesService: NodesService,
+        protected driveCrypto: DriveCrypto,
+        protected nodesService: NodesService,
     ) {
         this.driveCrypto = driveCrypto;
         this.nodesService = nodesService;

package/src/internal/upload/fileUploader.test.ts

@@ -108,6 +108,7 @@ describe('FileUploader', () => {
 
         revisionDraft = {
             nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid',
             nodeKeys: {
                 signatureAddress: { addressId: 'addressId' },
             },
@@ -131,10 +132,13 @@ describe('FileUploader', () => {
             abortController.signal,
         );
 
-        startUploadSpy = jest.spyOn(uploader as any, 'startUpload').mockReturnValue(Promise.resolve('revisionUid'));
+        startUploadSpy = jest.spyOn(uploader as any, 'startUpload').mockReturnValue(Promise.resolve({
+            nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid'
+        }));
     });
 
-    describe('writeFile', () => {
+    describe('uploadFromFile', () => {
         // @ts-expect-error Ignore mocking File
         const file = {
             type: 'image/png',
@@ -146,50 +150,60 @@ describe('FileUploader', () => {
         const onProgress = jest.fn();
 
         it('should set media type if not set', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
             expect(metadata.mediaType).toEqual('image/png');
             expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
         it('should set expected size if not set', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
             expect(metadata.expectedSize).toEqual(file.size);
             expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
         it('should set modification time if not set', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
             expect(metadata.modificationTime).toEqual(new Date(123456789));
             expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
         it('should throw an error if upload already started', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
-            await expect(uploader.writeFile(file, thumbnails, onProgress)).rejects.toThrow('Upload already started');
+            await expect(uploader.uploadFromFile(file, thumbnails, onProgress)).rejects.toThrow('Upload already started');
         });
     });
 
-    describe('writeStream', () => {
+    describe('uploadFromStream', () => {
         const stream = new ReadableStream();
         const thumbnails: Thumbnail[] = [];
         const onProgress = jest.fn();
 
         it('should start the upload process', async () => {
-            await uploader.writeStream(stream, thumbnails, onProgress);
+            await uploader.uploadFromStream(stream, thumbnails, onProgress);
 
             expect(startUploadSpy).toHaveBeenCalledWith(stream, thumbnails, onProgress);
         });
 
         it('should throw an error if upload already started', async () => {
-            await uploader.writeStream(stream, thumbnails, onProgress);
+            await uploader.uploadFromStream(stream, thumbnails, onProgress);
 
-            await expect(uploader.writeStream(stream, thumbnails, onProgress)).rejects.toThrow(
+            await expect(uploader.uploadFromStream(stream, thumbnails, onProgress)).rejects.toThrow(
                 'Upload already started',
             );
         });
+
+        it('should return correct nodeUid and nodeRevisionUid via controller completion', async () => {
+            const controller = await uploader.uploadFromStream(stream, thumbnails, onProgress);
+            const result = await controller.completion();
+
+            expect(result).toEqual({
+                nodeRevisionUid: 'revisionUid',
+                nodeUid: 'nodeUid'
+            });
+        });
     });
 });

package/src/internal/upload/fileUploader.ts

@@ -46,7 +46,7 @@ class Uploader {
         this.controller = new UploadController();
     }
 
-    async writeFile(
+    async uploadFromFile(
         fileObject: File,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -67,7 +67,7 @@ class Uploader {
         return this.controller;
     }
 
-    async writeStream(
+    async uploadFromStream(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -83,7 +83,7 @@ class Uploader {
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
-    ): Promise<string> {
+    ): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         const uploader = await this.initStreamUploader();
         return uploader.start(stream, thumbnails, onProgress);
     }
@@ -98,6 +98,18 @@ class Uploader {
             }
         };
 
+        return this.newStreamUploader(
+            blockVerifier,
+            revisionDraft,
+            onFinish,
+        );
+    }
+
+    protected async newStreamUploader(
+        blockVerifier: BlockVerifier,
+        revisionDraft: NodeRevisionDraft,
+        onFinish: (failure: boolean) => Promise<void>,
+    ): Promise<StreamUploader> {
         return new StreamUploader(
             this.telemetry,
             this.apiService,
@@ -107,6 +119,7 @@ class Uploader {
             revisionDraft,
             this.metadata,
             onFinish,
+            this.controller,
             this.signal,
         );
     }

package/src/internal/upload/interface.ts

@@ -7,6 +7,9 @@ export type NodeRevisionDraft = {
     nodeUid: string;
     nodeRevisionUid: string;
     nodeKeys: NodeRevisionDraftKeys;
+    parentNodeKeys?: {
+        hashKey: Uint8Array;
+    };
     // newNodeInfo is set only when revision is created with the new node.
     newNodeInfo?: {
         parentUid: string;

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

@@ -122,6 +122,9 @@ describe('UploadManager', () => {
                         email: 'signatureEmail',
                     },
                 },
+                parentNodeKeys: {
+                    hashKey: 'parentNode:hashKey',
+                },
                 newNodeInfo: {
                     parentUid: 'parentUid',
                     name: 'name',
@@ -172,6 +175,9 @@ describe('UploadManager', () => {
                         email: 'signatureEmail',
                     },
                 },
+                parentNodeKeys: {
+                    hashKey: 'parentNode:hashKey',
+                },
                 newNodeInfo: {
                     parentUid: 'volumeId~parentUid',
                     name: 'name',
@@ -338,6 +344,8 @@ describe('UploadManager', () => {
         const manifest = new Uint8Array([1, 2, 3]);
         const extendedAttributes = {
             modificationTime: new Date(),
+            size: 123,
+            blockSizes: [100, 20, 3],
             digests: {
                 sha1: 'sha1',
             },

package/src/internal/upload/manager.ts

@@ -15,14 +15,14 @@ import { makeNodeUid, splitNodeUid } from '../uids';
  * generating the necessary cryptographic keys and metadata.
  */
 export class UploadManager {
-    private logger: Logger;
+    protected logger: Logger;
 
     constructor(
         telemetry: ProtonDriveTelemetry,
-        private apiService: UploadAPIService,
-        private cryptoService: UploadCryptoService,
-        private nodesService: NodesService,
-        private clientUid: string | undefined,
+        protected apiService: UploadAPIService,
+        protected cryptoService: UploadCryptoService,
+        protected nodesService: NodesService,
+        protected clientUid: string | undefined,
     ) {
         this.logger = telemetry.getLogger('upload');
         this.apiService = apiService;
@@ -59,6 +59,9 @@ export class UploadManager {
                 contentKeyPacketSessionKey: generatedNodeCrypto.contentKey.decrypted.contentKeyPacketSessionKey,
                 signatureAddress: generatedNodeCrypto.signatureAddress,
             },
+            parentNodeKeys: {
+                hashKey: parentKeys.hashKey,
+            },
             newNodeInfo: {
                 parentUid: parentFolderUid,
                 name,
@@ -260,21 +263,28 @@ export class UploadManager {
         manifest: Uint8Array,
         extendedAttributes: {
             modificationTime?: Date;
-            size?: number;
-            blockSizes?: number[];
-            digests?: {
-                sha1?: string;
+            size: number;
+            blockSizes: number[];
+            digests: {
+                sha1: string;
             };
         },
+        additionalExtendedAttributes?: object,
     ): Promise<void> {
-        const generatedExtendedAttributes = generateFileExtendedAttributes(extendedAttributes);
+        const generatedExtendedAttributes = generateFileExtendedAttributes(
+            extendedAttributes,
+            additionalExtendedAttributes,
+        );
         const nodeCommitCrypto = await this.cryptoService.commitFile(
             nodeRevisionDraft.nodeKeys,
             manifest,
             generatedExtendedAttributes,
         );
         await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
+        await this.notifyNodeUploaded(nodeRevisionDraft);
+    }
 
+    protected async notifyNodeUploaded(nodeRevisionDraft: NodeRevisionDraft): Promise<void> {
         // If new revision to existing node was created, invalidate the node.
         // Otherwise notify about the new child in the parent.
         if (nodeRevisionDraft.newNodeInfo) {

package/src/internal/upload/streamUploader.test.ts

@@ -108,6 +108,7 @@ describe('StreamUploader', () => {
 
         revisionDraft = {
             nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid',
             nodeKeys: {
                 signatureAddress: { addressId: 'addressId' },
             },
@@ -131,6 +132,7 @@ describe('StreamUploader', () => {
             revisionDraft,
             metadata,
             onFinish,
+            controller,
             abortController.signal,
         );
     });
@@ -143,23 +145,33 @@ describe('StreamUploader', () => {
         let stream: ReadableStream<Uint8Array>;
 
         const verifySuccess = async () => {
-            await uploader.start(stream, thumbnails, onProgress);
+            const result = await uploader.start(stream, thumbnails, onProgress);
+            
+            expect(result).toEqual({
+                nodeRevisionUid: 'revisionUid',
+                nodeUid: 'nodeUid'
+            });
 
             const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
             expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
-            expect(uploadManager.commitDraft).toHaveBeenCalledWith(revisionDraft, expect.anything(), {
-                size: metadata.expectedSize,
-                blockSizes: metadata.expectedSize
-                    ? [
-                          ...Array(numberOfExpectedBlocks - 1).fill(FILE_CHUNK_SIZE),
-                          metadata.expectedSize % FILE_CHUNK_SIZE,
-                      ]
-                    : [],
-                modificationTime: undefined,
-                digests: {
-                    sha1: expect.anything(),
+            expect(uploadManager.commitDraft).toHaveBeenCalledWith(
+                revisionDraft,
+                expect.anything(),
+                {
+                    size: metadata.expectedSize,
+                    blockSizes: metadata.expectedSize
+                        ? [
+                              ...Array(numberOfExpectedBlocks - 1).fill(FILE_CHUNK_SIZE),
+                              metadata.expectedSize % FILE_CHUNK_SIZE,
+                          ]
+                        : [],
+                    modificationTime: undefined,
+                    digests: {
+                        sha1: expect.anything(),
+                    },
                 },
-            });
+                metadata.additionalMetadata,
+            );
             expect(telemetry.uploadFinished).toHaveBeenCalledTimes(1);
             expect(telemetry.uploadFinished).toHaveBeenCalledWith('revisionUid', metadata.expectedSize + thumbnailSize);
             expect(telemetry.uploadFailed).not.toHaveBeenCalled();
@@ -246,6 +258,8 @@ describe('StreamUploader', () => {
                 revisionDraft,
                 metadata,
                 onFinish,
+                controller,
+                abortController.signal,
             );
 
             await verifySuccess();
@@ -273,6 +287,8 @@ describe('StreamUploader', () => {
                 revisionDraft,
                 metadata,
                 onFinish,
+                controller,
+                abortController.signal,
             );
 
             await verifySuccess();
@@ -454,9 +470,10 @@ describe('StreamUploader', () => {
                     {
                         // Fake expected size to break verification
                         expectedSize: 1 * 1024 * 1024 + 1024,
-                        mediaType: '',
-                    },
+                    } as UploadMetadata,
                     onFinish,
+                    controller,
+                    abortController.signal,
                 );
 
                 await verifyFailure(

package/src/internal/upload/streamUploader.ts

@@ -55,36 +55,37 @@ const MAX_BLOCK_UPLOAD_RETRIES = 3;
  * that the upload process is efficient and does not overload the server.
  */
 export class StreamUploader {
-    private logger: Logger;
+    protected logger: Logger;
 
-    private digests: UploadDigests;
-    private controller: UploadController;
-    private abortController: AbortController;
+    protected digests: UploadDigests;
+    protected controller: UploadController;
+    protected abortController: AbortController;
 
-    private encryptedThumbnails = new Map<ThumbnailType, EncryptedThumbnail>();
-    private encryptedBlocks = new Map<number, EncryptedBlock>();
-    private encryptionFinished = false;
+    protected encryptedThumbnails = new Map<ThumbnailType, EncryptedThumbnail>();
+    protected encryptedBlocks = new Map<number, EncryptedBlock>();
+    protected encryptionFinished = false;
 
-    private ongoingUploads = new Map<
+    protected ongoingUploads = new Map<
         string,
         {
             uploadPromise: Promise<void>;
             encryptedBlock: EncryptedBlock | EncryptedThumbnail;
         }
     >();
-    private uploadedThumbnails: ({ type: ThumbnailType } & EncryptedBlockMetadata)[] = [];
-    private uploadedBlocks: ({ index: number } & EncryptedBlockMetadata)[] = [];
+    protected uploadedThumbnails: ({ type: ThumbnailType } & EncryptedBlockMetadata)[] = [];
+    protected uploadedBlocks: ({ index: number } & EncryptedBlockMetadata)[] = [];
 
     constructor(
-        private telemetry: UploadTelemetry,
-        private apiService: UploadAPIService,
-        private cryptoService: UploadCryptoService,
-        private uploadManager: UploadManager,
-        private blockVerifier: BlockVerifier,
-        private revisionDraft: NodeRevisionDraft,
-        private metadata: UploadMetadata,
-        private onFinish: (failure: boolean) => Promise<void>,
-        private signal?: AbortSignal,
+        protected telemetry: UploadTelemetry,
+        protected apiService: UploadAPIService,
+        protected cryptoService: UploadCryptoService,
+        protected uploadManager: UploadManager,
+        protected blockVerifier: BlockVerifier,
+        protected revisionDraft: NodeRevisionDraft,
+        protected metadata: UploadMetadata,
+        protected onFinish: (failure: boolean) => Promise<void>,
+        protected uploadController: UploadController,
+        protected signal?: AbortSignal,
     ) {
         this.telemetry = telemetry;
         this.logger = telemetry.getLoggerForRevision(revisionDraft.nodeRevisionUid);
@@ -104,14 +105,14 @@ export class StreamUploader {
         }
 
         this.digests = new UploadDigests();
-        this.controller = new UploadController();
+        this.controller = uploadController;
     }
 
     async start(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
-    ): Promise<string> {
+    ): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         let failure = false;
 
         // File progress is tracked for telemetry - to track at what
@@ -154,7 +155,11 @@ export class StreamUploader {
             await this.onFinish(failure);
         }
 
-        return this.revisionDraft.nodeRevisionUid;
+        return {
+            nodeRevisionUid: this.revisionDraft.nodeRevisionUid,
+            nodeUid: this.revisionDraft.nodeUid
+        }
+
     }
 
     private async encryptAndUploadBlocks(
@@ -205,19 +210,21 @@ export class StreamUploader {
         await Promise.all(this.ongoingUploads.values().map(({ uploadPromise }) => uploadPromise));
     }
 
-    private async commitFile(thumbnails: Thumbnail[]) {
+    protected async commitFile(thumbnails: Thumbnail[]) {
         this.verifyIntegrity(thumbnails);
 
-        const uploadedBlocks = Array.from(this.uploadedBlocks.values());
-        uploadedBlocks.sort((a, b) => a.index - b.index);
-
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
             size: this.metadata.expectedSize,
-            blockSizes: uploadedBlocks.map((block) => block.originalSize),
+            blockSizes: this.uploadedBlockSizes,
             digests: this.digests.digests(),
         };
-        await this.uploadManager.commitDraft(this.revisionDraft, this.manifest, extendedAttributes);
+        await this.uploadManager.commitDraft(
+            this.revisionDraft,
+            this.manifest,
+            extendedAttributes,
+            this.metadata.additionalMetadata,
+        );
     }
 
     private async encryptThumbnails(thumbnails: Thumbnail[]) {
@@ -514,7 +521,7 @@ export class StreamUploader {
         await waitForCondition(() => this.encryptedBlocks.size > 0 || this.encryptionFinished);
     }
 
-    private verifyIntegrity(thumbnails: Thumbnail[]) {
+    protected verifyIntegrity(thumbnails: Thumbnail[]) {
         const expectedBlockCount =
             Math.ceil(this.metadata.expectedSize / FILE_CHUNK_SIZE) + (thumbnails ? thumbnails?.length : 0);
         if (this.uploadedBlockCount !== expectedBlockCount) {
@@ -549,7 +556,13 @@ export class StreamUploader {
         return this.uploadedBlocks.reduce((sum, { originalSize }) => sum + originalSize, 0);
     }
 
-    private get manifest(): Uint8Array {
+    protected get uploadedBlockSizes(): number[] {
+        const uploadedBlocks = Array.from(this.uploadedBlocks.values());
+        uploadedBlocks.sort((a, b) => a.index - b.index);
+        return uploadedBlocks.map((block) => block.originalSize);
+    }
+
+    protected get manifest(): Uint8Array {
         this.uploadedThumbnails.sort((a, b) => a.type - b.type);
         this.uploadedBlocks.sort((a, b) => a.index - b.index);
         const hashes = [

package/src/protonDriveClient.ts

@@ -208,12 +208,12 @@ export class ProtonDriveClient {
                 const { httpClient, token, password } = await this.sessionManager.auth(url, customPassword);
                 return new ProtonDrivePublicLinkClient({
                     httpClient,
-                    cryptoCache,
                     account,
                     openPGPCryptoModule,
                     srpModule,
                     config,
                     telemetry,
+                    url,
                     token,
                     password,
                 });
@@ -726,7 +726,7 @@ export class ProtonDriveClient {
      * ```typescript
      * const downloader = await client.getFileDownloader(nodeUid, signal);
      * const claimedSize = fileDownloader.getClaimedSizeInBytes();
-     * const downloadController = fileDownloader.writeToStream(stream, (downloadedBytes) => { ... });
+     * const downloadController = fileDownloader.downloadToStream(stream, (downloadedBytes) => { ... });
      *
      * signalController.abort(); // to cancel
      * downloadController.pause(); // to pause
@@ -786,12 +786,12 @@ export class ProtonDriveClient {
      *
      * ```typescript
      * const uploader = await client.getFileUploader(parentFolderUid, name, metadata, signal);
-     * const uploadController = await uploader.writeStream(stream, thumbnails, (uploadedBytes) => { ... });
+     * const uploadController = await uploader.uploadFromStream(stream, thumbnails, (uploadedBytes) => { ... });
      *
      * signalController.abort(); // to cancel
      * uploadController.pause(); // to pause
      * uploadController.resume(); // to resume
-     * const nodeUid = await uploadController.completion(); // to await completion
+     * const { nodeUid, nodeRevisionUid } = await uploadController.completion(); // to await completion
      * ```
      */
     async getFileUploader(

package/src/protonDrivePhotosClient.ts

@@ -8,20 +8,27 @@ import {
     FileUploader,
     SDKEvent,
     MaybeNode,
+    ThumbnailType,
+    ThumbnailResult,
 } from './interface';
 import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { Telemetry } from './telemetry';
-import { convertInternalMissingNodeIterator, convertInternalNodeIterator, getUid, getUids } from './transformers';
+import {
+    convertInternalMissingNodeIterator,
+    convertInternalNodeIterator,
+    convertInternalNodePromise,
+    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 { initPhotoSharesModule, initPhotosModule } from './internal/photos';
+import { initPhotosModule, initPhotoSharesModule, initPhotoUploadModule } from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
 import { initSharingModule } from './internal/sharing';
-import { initUploadModule } from './internal/upload';
 
 /**
  * ProtonDrivePhotosClient is the interface to access Photos functionality.
@@ -39,7 +46,7 @@ export class ProtonDrivePhotosClient {
     private nodes: ReturnType<typeof initNodesModule>;
     private sharing: ReturnType<typeof initSharingModule>;
     private download: ReturnType<typeof initDownloadModule>;
-    private upload: ReturnType<typeof initUploadModule>;
+    private upload: ReturnType<typeof initPhotoUploadModule>;
     private photos: ReturnType<typeof initPhotosModule>;
 
     public experimental: {
@@ -115,7 +122,7 @@ export class ProtonDrivePhotosClient {
             this.nodes.access,
             this.nodes.revisions,
         );
-        this.upload = initUploadModule(
+        this.upload = initPhotoUploadModule(
             telemetry,
             apiService,
             cryptoModule,
@@ -208,6 +215,16 @@ export class ProtonDrivePhotosClient {
         yield* convertInternalMissingNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
     }
 
+    /**
+     * Get the node by its UID.
+     *
+     * See `ProtonDriveClient.getNode` for more information.
+     */
+    async getNode(nodeUid: NodeOrUid): Promise<MaybeNode> {
+        this.logger.info(`Getting node ${getUid(nodeUid)}`);
+        return convertInternalNodePromise(this.nodes.access.getNode(getUid(nodeUid)));
+    }
+
     /**
      * Iterates the albums.
      *
@@ -229,12 +246,35 @@ export class ProtonDrivePhotosClient {
         return this.download.getFileDownloader(getUid(nodeUid), signal);
     }
 
+    /**
+     * Iterates the thumbnails of the given nodes.
+     *
+     * See `ProtonDriveClient.iterateThumbnails` for more information.
+     */
+    async *iterateThumbnails(
+        nodeUids: NodeOrUid[],
+        thumbnailType?: ThumbnailType,
+        signal?: AbortSignal,
+    ): AsyncGenerator<ThumbnailResult> {
+        this.logger.info(`Iterating ${nodeUids.length} thumbnails`);
+        yield* this.download.iterateThumbnails(getUids(nodeUids), thumbnailType, 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> {
+    async getFileUploader(
+        name: string,
+        metadata: UploadMetadata & {
+            captureTime?: Date;
+            mainPhotoLinkID?: string;
+            // TODO: handle tags enum in the SDK
+            tags?: (0 | 3 | 1 | 2 | 7 | 4 | 5 | 6 | 8 | 9)[];
+        },
+        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);