@protontech/drive-sdk 0.3.2 → 0.4.1

package/src/internal/photos/upload.ts

@@ -0,0 +1,209 @@
+import { DriveCrypto } from '../../crypto';
+import { ProtonDriveTelemetry, UploadMetadata, Thumbnail } from '../../interface';
+import { DriveAPIService, drivePaths } from '../apiService';
+import { generateFileExtendedAttributes } from '../nodes';
+import { splitNodeRevisionUid } from '../uids';
+import { UploadAPIService } from '../upload/apiService';
+import { BlockVerifier } from '../upload/blockVerifier';
+import { UploadCryptoService } from '../upload/cryptoService';
+import { FileUploader } from '../upload/fileUploader';
+import { NodeRevisionDraft, NodesService } from '../upload/interface';
+import { UploadManager } from '../upload/manager';
+import { StreamUploader } from '../upload/streamUploader';
+import { UploadTelemetry } from '../upload/telemetry';
+
+type PostCommitRevisionRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCommitRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['responses']['200']['content']['application/json'];
+
+export type PhotoUploadMetadata = UploadMetadata & {
+    captureTime?: Date;
+    mainPhotoLinkID?: string;
+    // TODO: handle tags enum in the SDK
+    tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+};
+
+export class PhotoFileUploader extends FileUploader {
+    private photoApiService: PhotoUploadAPIService;
+    private photoManager: PhotoUploadManager;
+    private photoMetadata: PhotoUploadMetadata;
+
+    constructor(
+        telemetry: UploadTelemetry,
+        apiService: PhotoUploadAPIService,
+        cryptoService: UploadCryptoService,
+        manager: PhotoUploadManager,
+        parentFolderUid: string,
+        name: string,
+        metadata: PhotoUploadMetadata,
+        onFinish: () => void,
+        signal?: AbortSignal,
+    ) {
+        super(telemetry, apiService, cryptoService, manager, parentFolderUid, name, metadata, onFinish, signal);
+        this.photoApiService = apiService;
+        this.photoManager = manager;
+        this.photoMetadata = metadata;
+    }
+
+    protected async newStreamUploader(
+        blockVerifier: BlockVerifier,
+        revisionDraft: NodeRevisionDraft,
+        onFinish: (failure: boolean) => Promise<void>,
+    ): Promise<StreamUploader> {
+        return new PhotoStreamUploader(
+            this.telemetry,
+            this.photoApiService,
+            this.cryptoService,
+            this.photoManager,
+            blockVerifier,
+            revisionDraft,
+            this.photoMetadata,
+            onFinish,
+            this.signal,
+        );
+    }
+}
+
+export class PhotoStreamUploader extends StreamUploader {
+    private photoUploadManager: PhotoUploadManager;
+    private photoMetadata: PhotoUploadMetadata;
+
+    constructor(
+        telemetry: UploadTelemetry,
+        apiService: PhotoUploadAPIService,
+        cryptoService: UploadCryptoService,
+        uploadManager: PhotoUploadManager,
+        blockVerifier: BlockVerifier,
+        revisionDraft: NodeRevisionDraft,
+        metadata: PhotoUploadMetadata,
+        onFinish: (failure: boolean) => Promise<void>,
+        signal?: AbortSignal,
+    ) {
+        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, signal);
+        this.photoUploadManager = uploadManager;
+        this.photoMetadata = metadata;
+    }
+
+    async commitFile(thumbnails: Thumbnail[]) {
+        this.verifyIntegrity(thumbnails);
+
+        const extendedAttributes = {
+            modificationTime: this.metadata.modificationTime,
+            size: this.metadata.expectedSize,
+            blockSizes: this.uploadedBlockSizes,
+            digests: this.digests.digests(),
+        };
+
+        await this.photoUploadManager.commitDraftPhoto(this.revisionDraft, this.manifest, extendedAttributes, this.photoMetadata);
+    }
+}
+
+export class PhotoUploadManager extends UploadManager {
+    private photoApiService: PhotoUploadAPIService;
+    private photoCryptoService: PhotoUploadCryptoService;
+
+    constructor(
+        telemetry: ProtonDriveTelemetry,
+        apiService: PhotoUploadAPIService,
+        cryptoService: PhotoUploadCryptoService,
+        nodesService: NodesService,
+        clientUid: string | undefined,
+    ) {
+        super(telemetry, apiService, cryptoService, nodesService, clientUid);
+        this.photoApiService = apiService;
+        this.photoCryptoService = cryptoService;
+    }
+
+    async commitDraftPhoto(
+        nodeRevisionDraft: NodeRevisionDraft,
+        manifest: Uint8Array,
+        extendedAttributes: {
+            modificationTime?: Date;
+            size: number;
+            blockSizes: number[];
+            digests: {
+                sha1: string;
+            };
+        },
+        uploadMetadata: PhotoUploadMetadata,
+    ): Promise<void> {
+        if (!nodeRevisionDraft.parentNodeKeys) {
+            throw new Error('Parent node keys are required for photo upload');
+        }
+
+        // TODO: handle photo extended attributes in the SDK - now it must be passed from the client
+        const generatedExtendedAttributes = generateFileExtendedAttributes(extendedAttributes, uploadMetadata.additionalMetadata);
+        const nodeCommitCrypto = await this.cryptoService.commitFile(
+            nodeRevisionDraft.nodeKeys,
+            manifest,
+            generatedExtendedAttributes,
+        );
+
+        const sha1 = extendedAttributes.digests.sha1;
+        const contentHash = await this.photoCryptoService.generateContentHash(sha1, nodeRevisionDraft.parentNodeKeys?.hashKey);
+        const photo = {
+            contentHash,
+            captureTime: uploadMetadata.captureTime || extendedAttributes.modificationTime,
+            mainPhotoLinkID: uploadMetadata.mainPhotoLinkID,
+            tags: uploadMetadata.tags,
+        }
+        await this.photoApiService.commitDraftPhoto(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto, photo);
+        await this.notifyNodeUploaded(nodeRevisionDraft);
+    }
+}
+
+export class PhotoUploadCryptoService extends UploadCryptoService {
+    constructor(
+        driveCrypto: DriveCrypto,
+        nodesService: NodesService,
+    ) {
+        super(driveCrypto, nodesService);
+    }
+
+    async generateContentHash(sha1: string, parentHashKey: Uint8Array): Promise<string> {
+        return this.driveCrypto.generateLookupHash(sha1, parentHashKey);
+    }
+}
+
+export class PhotoUploadAPIService extends UploadAPIService {
+    constructor(apiService: DriveAPIService, clientUid: string | undefined) {
+        super(apiService, clientUid);
+    }
+
+    async commitDraftPhoto(
+        draftNodeRevisionUid: string,
+        options: {
+            armoredManifestSignature: string;
+            signatureEmail: string;
+            armoredExtendedAttributes?: string;
+        },
+        photo: {
+            contentHash: string;
+            captureTime?: Date;
+            mainPhotoLinkID?: string;
+            // TODO: handle tags enum in the SDK
+            tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+        },
+    ): Promise<void> {
+        const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
+        await this.apiService.put<
+            // TODO: Deprected fields but not properly marked in the types.
+            Omit<PostCommitRevisionRequest, 'BlockNumber' | 'BlockList' | 'ThumbnailToken' | 'State'>,
+            PostCommitRevisionResponse
+        >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`, {
+            ManifestSignature: options.armoredManifestSignature,
+            SignatureAddress: options.signatureEmail,
+            XAttr: options.armoredExtendedAttributes || null,
+            Photo: {
+                ContentHash: photo.contentHash,
+                CaptureTime: photo.captureTime?.getTime() || 0,
+                MainPhotoLinkID: photo.mainPhotoLinkID || null,
+                Tags: photo.tags || [],
+                Exif: null, // Deprecated field, not used.
+            },
+        });
+    }
+}

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/internal/sharingPublic/apiService.ts

@@ -76,6 +76,7 @@ function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token
         creationTime: new Date(), // TODO
 
         isShared: false,
+        isSharedPublicly: false,
         directRole: MemberRole.Viewer, // TODO
     };
 
@@ -133,6 +134,7 @@ function linkToEncryptedNode(
         totalStorageSize: link.TotalSize,
 
         isShared: false,
+        isSharedPublicly: false,
         directRole: MemberRole.Viewer, // TODO
     };
 

package/src/internal/upload/apiService.ts

@@ -53,8 +53,8 @@ type PostDeleteNodesResponse =
 
 export class UploadAPIService {
     constructor(
-        private apiService: DriveAPIService,
-        private clientUid: string | undefined,
+        protected apiService: DriveAPIService,
+        protected clientUid: string | undefined,
     ) {
         this.apiService = apiService;
         this.clientUid = clientUid;
@@ -252,7 +252,7 @@ export class UploadAPIService {
             ManifestSignature: options.armoredManifestSignature,
             SignatureAddress: options.signatureEmail,
             XAttr: options.armoredExtendedAttributes || null,
-            Photo: null, // TODO
+            Photo: null, // Only used for photos in the Photo volume.
         });
     }
 

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

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

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

@@ -147,19 +147,24 @@ describe('StreamUploader', () => {
 
             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();

package/src/internal/upload/streamUploader.ts

@@ -55,36 +55,36 @@ 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 signal?: AbortSignal,
     ) {
         this.telemetry = telemetry;
         this.logger = telemetry.getLoggerForRevision(revisionDraft.nodeRevisionUid);
@@ -205,19 +205,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 +516,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 +551,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 = [