@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/internal/upload/manager.ts

@@ -1,13 +1,13 @@
-import { c } from "ttag";
+import { c } from 'ttag';
 
-import { Logger, ProtonDriveTelemetry, UploadMetadata } from "../../interface";
-import { ValidationError, NodeAlreadyExistsValidationError } from "../../errors";
-import { ErrorCode } from "../apiService";
-import { generateFileExtendedAttributes } from "../nodes";
-import { UploadAPIService } from "./apiService";
-import { UploadCryptoService } from "./cryptoService";
-import { NodeRevisionDraft, NodesService, NodeCrypto } from "./interface";
-import { makeNodeUid, splitNodeUid } from "../uids";
+import { Logger, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
+import { ValidationError, NodeAlreadyExistsValidationError } from '../../errors';
+import { ErrorCode } from '../apiService';
+import { generateFileExtendedAttributes } from '../nodes';
+import { UploadAPIService } from './apiService';
+import { UploadCryptoService } from './cryptoService';
+import { NodeRevisionDraft, NodesService, NodeCrypto } from './interface';
+import { makeNodeUid, splitNodeUid } from '../uids';
 
 /**
  * UploadManager is responsible for creating and deleting draft nodes
@@ -75,8 +75,8 @@ export class UploadManager {
         metadata: UploadMetadata,
         generatedNodeCrypto: NodeCrypto,
     ): Promise<{
-        nodeUid: string,
-        nodeRevisionUid: string,
+        nodeUid: string;
+        nodeRevisionUid: string;
     }> {
         try {
             const result = await this.apiService.createDraft(parentFolderUid, {
@@ -88,7 +88,8 @@ export class UploadManager {
                 armoredNodePassphrase: generatedNodeCrypto.nodeKeys.encrypted.armoredPassphrase,
                 armoredNodePassphraseSignature: generatedNodeCrypto.nodeKeys.encrypted.armoredPassphraseSignature,
                 base64ContentKeyPacket: generatedNodeCrypto.contentKey.encrypted.base64ContentKeyPacket,
-                armoredContentKeyPacketSignature: generatedNodeCrypto.contentKey.encrypted.armoredContentKeyPacketSignature,
+                armoredContentKeyPacketSignature:
+                    generatedNodeCrypto.contentKey.encrypted.armoredContentKeyPacketSignature,
                 signatureEmail: generatedNodeCrypto.signatureAddress.email,
             });
             return result;
@@ -97,30 +98,39 @@ export class UploadManager {
                 if (error.code === ErrorCode.ALREADY_EXISTS) {
                     this.logger.info(`Node with given name already exists`);
 
-                    const typedDetails = error.details as {
-                        ConflictLinkID: string,
-                        ConflictRevisionID?: string,
-                        ConflictDraftRevisionID?: string,
-                        ConflictDraftClientUID?: string,
-                    } | undefined;
+                    const typedDetails = error.details as
+                        | {
+                              ConflictLinkID: string;
+                              ConflictRevisionID?: string;
+                              ConflictDraftRevisionID?: string;
+                              ConflictDraftClientUID?: string;
+                          }
+                        | undefined;
 
                     // If the client doesn't specify the client UID, it should
                     // never be considered own draft.
-                    const isOwnDraftConflict = (
+                    const isOwnDraftConflict =
                         typedDetails?.ConflictDraftRevisionID &&
                         this.clientUid &&
-                        typedDetails?.ConflictDraftClientUID === this.clientUid
-                    );
+                        typedDetails?.ConflictDraftClientUID === this.clientUid;
 
                     // If there is existing draft created by this client,
                     // automatically delete it and try to create a new one
                     // with the same name again.
-                    if (typedDetails?.ConflictDraftRevisionID && (isOwnDraftConflict || metadata.overrideExistingDraftByOtherClient)) {
-                        const existingDraftNodeUid = makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID);
+                    if (
+                        typedDetails?.ConflictDraftRevisionID &&
+                        (isOwnDraftConflict || metadata.overrideExistingDraftByOtherClient)
+                    ) {
+                        const existingDraftNodeUid = makeNodeUid(
+                            splitNodeUid(parentFolderUid).volumeId,
+                            typedDetails.ConflictLinkID,
+                        );
 
                         let deleteFailed = false;
                         try {
-                            this.logger.warn(`Deleting existing draft node ${existingDraftNodeUid} by ${typedDetails.ConflictDraftClientUID}`);
+                            this.logger.warn(
+                                `Deleting existing draft node ${existingDraftNodeUid} by ${typedDetails.ConflictDraftClientUID}`,
+                            );
                             await this.apiService.deleteDraft(existingDraftNodeUid);
                         } catch (deleteDraftError: unknown) {
                             // Do not throw, let throw the conflict error.
@@ -128,15 +138,25 @@ export class UploadManager {
                             this.logger.error('Failed to delete existing draft node', deleteDraftError);
                         }
                         if (!deleteFailed) {
-                            return this.createDraftOnAPI(parentFolderUid, parentHashKey, name, metadata, generatedNodeCrypto);
+                            return this.createDraftOnAPI(
+                                parentFolderUid,
+                                parentHashKey,
+                                name,
+                                metadata,
+                                generatedNodeCrypto,
+                            );
                         }
                     }
 
                     if (isOwnDraftConflict) {
-                        this.logger.warn(`Existing draft conflict by another client ${typedDetails.ConflictDraftClientUID}`);
+                        this.logger.warn(
+                            `Existing draft conflict by another client ${typedDetails.ConflictDraftClientUID}`,
+                        );
                     }
 
-                    const existingNodeUid = typedDetails ? makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID) : undefined;
+                    const existingNodeUid = typedDetails
+                        ? makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID)
+                        : undefined;
 
                     // If there is existing node, return special error
                     // that includes the available name the client can use.
@@ -223,7 +243,7 @@ export class UploadManager {
                 contentKeyPacketSessionKey: nodeKeys.contentKeyPacketSessionKey,
                 signatureAddress: signatureAddress,
             },
-        }
+        };
     }
 
     async deleteDraftRevision(nodeRevisionUid: string): Promise<void> {
@@ -240,22 +260,29 @@ export class UploadManager {
     async commitDraft(
         nodeRevisionDraft: NodeRevisionDraft,
         manifest: Uint8Array,
-        _metadata: UploadMetadata,
         extendedAttributes: {
-            modificationTime?: Date,
-            size?: number,
-            blockSizes?: number[],
+            modificationTime?: Date;
+            size?: number;
+            blockSizes?: number[];
             digests?: {
-                sha1?: string,
-            },
+                sha1?: string;
+            };
         },
     ): Promise<void> {
         const generatedExtendedAttributes = generateFileExtendedAttributes(extendedAttributes);
-        const nodeCommitCrypto = await this.cryptoService.commitFile(nodeRevisionDraft.nodeKeys, manifest, generatedExtendedAttributes);
+        const nodeCommitCrypto = await this.cryptoService.commitFile(
+            nodeRevisionDraft.nodeKeys,
+            manifest,
+            generatedExtendedAttributes,
+        );
         await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
-        const node = await this.nodesService.getNode(nodeRevisionDraft.nodeUid);
-        if (node.parentUid) {
-            await this.nodesService.notifyChildCreated(node.parentUid);
+
+        // If new revision to existing node was created, invalidate the node.
+        // Otherwise notify about the new child in the parent.
+        if (nodeRevisionDraft.newNodeInfo) {
+            await this.nodesService.notifyChildCreated(nodeRevisionDraft.newNodeInfo.parentUid);
+        } else {
+            await this.nodesService.notifyNodeChanged(nodeRevisionDraft.nodeUid);
         }
     }
 }
@@ -269,7 +296,7 @@ function splitExtension(filename = ''): [string, string] {
         return [filename, ''];
     }
     return [filename.slice(0, endIdx), filename.slice(endIdx + 1)];
-};
+}
 
 /**
  * Join a filename into `name (index).extension`

package/src/internal/upload/queue.ts

@@ -2,13 +2,13 @@ import { waitForCondition } from '../wait';
 
 /**
  * A queue that limits the number of concurrent uploads.
- * 
+ *
  * This is used to limit the number of concurrent uploads to avoid
  * overloading the server, or get rate limited.
- * 
+ *
  * Each file upload consumes memory and is limited by the number of
  * concurrent block uploads for each file.
- * 
+ *
  * This queue is straitforward and does not have any priority mechanism
  * or other features, such as limiting total number of blocks being
  * uploaded. That is something we want to add in the future to be

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

@@ -12,7 +12,12 @@ import { UploadManager } from './manager';
 
 const BLOCK_ENCRYPTION_OVERHEAD = 10000;
 
-async function mockEncryptBlock(verifyBlock: (block: Uint8Array) => Promise<void>, _: any, block: Uint8Array, index: number) {
+async function mockEncryptBlock(
+    verifyBlock: (block: Uint8Array) => Promise<void>,
+    _: any,
+    block: Uint8Array,
+    index: number,
+) {
     await verifyBlock(block);
     return {
         index,
@@ -25,7 +30,12 @@ async function mockEncryptBlock(verifyBlock: (block: Uint8Array) => Promise<void
     };
 }
 
-function mockUploadBlock(_: string, __: string, encryptedBlock: Uint8Array, onProgress: (uploadedBytes: number) => void) {
+function mockUploadBlock(
+    _: string,
+    __: string,
+    encryptedBlock: Uint8Array,
+    onProgress: (uploadedBytes: number) => void,
+) {
     onProgress(encryptedBlock.length);
 }
 
@@ -137,22 +147,19 @@ describe('StreamUploader', () => {
 
             const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
             expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
-            expect(uploadManager.commitDraft).toHaveBeenCalledWith(
-                revisionDraft,
-                expect.anything(),
-                metadata,
-                {
-                    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(),
                 },
-            );
+            });
             expect(telemetry.uploadFinished).toHaveBeenCalledTimes(1);
             expect(telemetry.uploadFinished).toHaveBeenCalledWith('revisionUid', metadata.expectedSize + thumbnailSize);
             expect(telemetry.uploadFailed).not.toHaveBeenCalled();
@@ -160,7 +167,11 @@ describe('StreamUploader', () => {
             expect(onFinish).toHaveBeenCalledWith(false);
         };
 
-        const verifyFailure = async (error: string, uploadedBytes: number | undefined, expectedSize = metadata.expectedSize) => {
+        const verifyFailure = async (
+            error: string,
+            uploadedBytes: number | undefined,
+            expectedSize = metadata.expectedSize,
+        ) => {
             const promise = uploader.start(stream, thumbnails, onProgress);
             await expect(promise).rejects.toThrow(error);
 
@@ -189,7 +200,7 @@ describe('StreamUploader', () => {
                 {
                     type: ThumbnailType.Type1,
                     thumbnail: new Uint8Array(1024),
-                }
+                },
             ];
             thumbnailSize = thumbnails.reduce((acc, thumbnail) => acc + thumbnail.thumbnail.length, 0);
             stream = new ReadableStream({
@@ -204,7 +215,7 @@ describe('StreamUploader', () => {
             });
         });
 
-        it("should upload successfully", async () => {
+        it('should upload successfully', async () => {
             await verifySuccess();
             expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
             expect(apiService.uploadBlock).toHaveBeenCalledTimes(4); // 3 blocks + 1 thumbnail
@@ -213,7 +224,7 @@ describe('StreamUploader', () => {
             await verifyOnProgress([thumbnailSize, 4 * 1024 * 1024, 4 * 1024 * 1024, 2 * 1024 * 1024]);
         });
 
-        it("should upload successfully empty file without thumbnail", async () => {
+        it('should upload successfully empty file without thumbnail', async () => {
             metadata = {
                 expectedSize: 0,
             } as UploadMetadata;
@@ -242,7 +253,7 @@ describe('StreamUploader', () => {
             await verifyOnProgress([]);
         });
 
-        it("should upload successfully empty file with thumbnail", async () => {
+        it('should upload successfully empty file with thumbnail', async () => {
             metadata = {
                 expectedSize: 0,
             } as UploadMetadata;
@@ -395,7 +406,7 @@ describe('StreamUploader', () => {
                             hash: 'blockHash',
                             armoredSignature: 'signature',
                             verificationToken: 'verificationToken',
-                        }
+                        },
                     ],
                 },
             );
@@ -420,9 +431,12 @@ describe('StreamUploader', () => {
             });
 
             it('should report block verification error when retry helped', async () => {
-                blockVerifier.verifyBlock = jest.fn().mockRejectedValueOnce(new IntegrityError('Block verification error')).mockResolvedValue({
-                    verificationToken: new Uint8Array(),
-                });
+                blockVerifier.verifyBlock = jest
+                    .fn()
+                    .mockRejectedValueOnce(new IntegrityError('Block verification error'))
+                    .mockResolvedValue({
+                        verificationToken: new Uint8Array(),
+                    });
                 await verifySuccess();
                 expect(telemetry.logBlockVerificationError).toHaveBeenCalledWith(true);
             });

package/src/internal/upload/streamUploader.ts

@@ -1,21 +1,21 @@
-import { c } from "ttag";
-
-import { Thumbnail, Logger, ThumbnailType, UploadMetadata } from "../../interface";
-import { IntegrityError } from "../../errors";
-import { LoggerWithPrefix } from "../../telemetry";
-import { APIHTTPError, HTTPErrorCode, NotFoundAPIError } from "../apiService";
-import { getErrorMessage } from "../errors";
-import { mergeUint8Arrays } from "../utils";
+import { c } from 'ttag';
+
+import { Thumbnail, Logger, ThumbnailType, UploadMetadata } from '../../interface';
+import { IntegrityError } from '../../errors';
+import { LoggerWithPrefix } from '../../telemetry';
+import { APIHTTPError, HTTPErrorCode, NotFoundAPIError } from '../apiService';
+import { getErrorMessage } from '../errors';
+import { mergeUint8Arrays } from '../utils';
 import { waitForCondition } from '../wait';
-import { UploadAPIService } from "./apiService";
-import { BlockVerifier } from "./blockVerifier";
+import { UploadAPIService } from './apiService';
+import { BlockVerifier } from './blockVerifier';
 import { UploadController } from './controller';
-import { UploadCryptoService } from "./cryptoService";
-import { UploadDigests } from "./digests";
-import { NodeRevisionDraft, EncryptedBlock, EncryptedThumbnail, EncryptedBlockMetadata } from "./interface";
+import { UploadCryptoService } from './cryptoService';
+import { UploadDigests } from './digests';
+import { NodeRevisionDraft, EncryptedBlock, EncryptedThumbnail, EncryptedBlockMetadata } from './interface';
 import { UploadTelemetry } from './telemetry';
 import { ChunkStreamReader } from './chunkStreamReader';
-import { UploadManager } from "./manager";
+import { UploadManager } from './manager';
 
 /**
  * File chunk size in bytes representing the size of each block.
@@ -65,10 +65,13 @@ export class StreamUploader {
     private encryptedBlocks = new Map<number, EncryptedBlock>();
     private encryptionFinished = false;
 
-    private ongoingUploads = new Map<string, {
-        uploadPromise: Promise<void>,
-        encryptedBlock: EncryptedBlock | EncryptedThumbnail,
-    }>();
+    private ongoingUploads = new Map<
+        string,
+        {
+            uploadPromise: Promise<void>;
+            encryptedBlock: EncryptedBlock | EncryptedThumbnail;
+        }
+    >();
     private uploadedThumbnails: ({ type: ThumbnailType } & EncryptedBlockMetadata)[] = [];
     private uploadedBlocks: ({ index: number } & EncryptedBlockMetadata)[] = [];
 
@@ -104,7 +107,11 @@ export class StreamUploader {
         this.controller = new UploadController();
     }
 
-    async start(stream: ReadableStream, thumbnails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<string> {
+    async start(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<string> {
         let failure = false;
 
         // File progress is tracked for telemetry - to track at what
@@ -116,7 +123,7 @@ export class StreamUploader {
             await this.encryptAndUploadBlocks(stream, thumbnails, (uploadedBytes) => {
                 fileProgress += uploadedBytes;
                 onProgress?.(uploadedBytes);
-            })
+            });
 
             this.logger.debug(`All blocks uploaded, committing`);
             await this.commitFile(thumbnails);
@@ -126,7 +133,12 @@ export class StreamUploader {
         } catch (error: unknown) {
             failure = true;
             this.logger.error(`Upload failed`, error);
-            void this.telemetry.uploadFailed(this.revisionDraft.nodeRevisionUid, error, fileProgress, this.metadata.expectedSize);
+            void this.telemetry.uploadFailed(
+                this.revisionDraft.nodeRevisionUid,
+                error,
+                fileProgress,
+                this.metadata.expectedSize,
+            );
             throw error;
         } finally {
             this.logger.debug(`Upload cleanup`);
@@ -145,7 +157,11 @@ export class StreamUploader {
         return this.revisionDraft.nodeRevisionUid;
     }
 
-    private async encryptAndUploadBlocks(stream: ReadableStream, thumbnails: Thumbnail[], onProgress?: (uploadedBytes: number) => void) {
+    private async encryptAndUploadBlocks(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ) {
         // We await for the encryption of thumbnails to finish before
         // starting the upload. This is because we need to request the
         // upload tokens for the thumbnails with the first blocks.
@@ -198,15 +214,10 @@ export class StreamUploader {
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
             size: this.metadata.expectedSize,
-            blockSizes: uploadedBlocks.map(block => block.originalSize),
+            blockSizes: uploadedBlocks.map((block) => block.originalSize),
             digests: this.digests.digests(),
         };
-        await this.uploadManager.commitDraft(
-            this.revisionDraft,
-            this.manifest,
-            this.metadata,
-            extendedAttributes,
-        );
+        await this.uploadManager.commitDraft(this.revisionDraft, this.manifest, extendedAttributes);
     }
 
     private async encryptThumbnails(thumbnails: Thumbnail[]) {
@@ -216,7 +227,10 @@ export class StreamUploader {
 
         for (const thumbnail of thumbnails) {
             this.logger.debug(`Encrypting thumbnail ${thumbnail.type}`);
-            const encryptedThumbnail = await this.cryptoService.encryptThumbnail(this.revisionDraft.nodeKeys, thumbnail);
+            const encryptedThumbnail = await this.cryptoService.encryptThumbnail(
+                this.revisionDraft.nodeKeys,
+                thumbnail,
+            );
             this.encryptedThumbnails.set(thumbnail.type, encryptedThumbnail);
         }
     }
@@ -256,7 +270,9 @@ export class StreamUploader {
                         }
 
                         if (attempt <= MAX_BLOCK_ENCRYPTION_RETRIES) {
-                            this.logger.warn(`Block encryption failed #${attempt}, retrying: ${getErrorMessage(error)}`);
+                            this.logger.warn(
+                                `Block encryption failed #${attempt}, retrying: ${getErrorMessage(error)}`,
+                            );
                             continue;
                         }
 
@@ -280,18 +296,22 @@ export class StreamUploader {
             this.revisionDraft.nodeRevisionUid,
             this.revisionDraft.nodeKeys.signatureAddress.addressId,
             {
-                contentBlocks: Array.from(this.encryptedBlocks.values().map(block => ({
-                    index: block.index,
-                    encryptedSize: block.encryptedSize,
-                    hash: block.hash,
-                    armoredSignature: block.armoredSignature,
-                    verificationToken: block.verificationToken,
-                }))),
-                thumbnails: Array.from(this.encryptedThumbnails.values().map(block => ({
-                    type: block.type,
-                    encryptedSize: block.encryptedSize,
-                    hash: block.hash,
-                }))),
+                contentBlocks: Array.from(
+                    this.encryptedBlocks.values().map((block) => ({
+                        index: block.index,
+                        encryptedSize: block.encryptedSize,
+                        hash: block.hash,
+                        armoredSignature: block.armoredSignature,
+                        verificationToken: block.verificationToken,
+                    })),
+                ),
+                thumbnails: Array.from(
+                    this.encryptedThumbnails.values().map((block) => ({
+                        type: block.type,
+                        encryptedSize: block.encryptedSize,
+                        hash: block.hash,
+                    })),
+                ),
             },
         );
 
@@ -305,11 +325,7 @@ export class StreamUploader {
 
             const uploadKey = `thumbnail:${thumbnailToken.type}`;
             this.ongoingUploads.set(uploadKey, {
-                uploadPromise: this.uploadThumbnail(
-                    thumbnailToken,
-                    encryptedThumbnail,
-                    onProgress,
-                ).finally(() => {
+                uploadPromise: this.uploadThumbnail(thumbnailToken, encryptedThumbnail, onProgress).finally(() => {
                     this.ongoingUploads.delete(uploadKey);
 
                     // Help the garbage collector to clean up the memory.
@@ -329,11 +345,7 @@ export class StreamUploader {
 
             const uploadKey = `block:${blockToken.index}`;
             this.ongoingUploads.set(uploadKey, {
-                uploadPromise: this.uploadBlock(
-                    blockToken,
-                    encryptedBlock,
-                    onProgress,
-                ).finally(() => {
+                uploadPromise: this.uploadBlock(blockToken, encryptedBlock, onProgress).finally(() => {
                     this.ongoingUploads.delete(uploadKey);
 
                     // Help the garbage collector to clean up the memory.
@@ -345,11 +357,14 @@ export class StreamUploader {
     }
 
     private async uploadThumbnail(
-        uploadToken: { bareUrl: string, token: string },
+        uploadToken: { bareUrl: string; token: string },
         encryptedThumbnail: EncryptedThumbnail,
         onProgress?: (uploadedBytes: number) => void,
     ) {
-        const logger = new LoggerWithPrefix(this.logger, `thumbnail type ${encryptedThumbnail.type} to ${uploadToken.token}`);
+        const logger = new LoggerWithPrefix(
+            this.logger,
+            `thumbnail type ${encryptedThumbnail.type} to ${uploadToken.token}`,
+        );
         logger.info(`Upload started`);
 
         let blockProgress = 0;
@@ -368,13 +383,13 @@ export class StreamUploader {
                         onProgress?.(uploadedBytes);
                     },
                     this.abortController.signal,
-                )
+                );
                 this.uploadedThumbnails.push({
                     type: encryptedThumbnail.type,
                     hash: encryptedThumbnail.hash,
                     encryptedSize: encryptedThumbnail.encryptedSize,
                     originalSize: encryptedThumbnail.originalSize,
-                })
+                });
                 break;
             } catch (error: unknown) {
                 if (blockProgress !== 0) {
@@ -407,7 +422,7 @@ export class StreamUploader {
     }
 
     private async uploadBlock(
-        uploadToken: { index: number, bareUrl: string, token: string },
+        uploadToken: { index: number; bareUrl: string; token: string },
         encryptedBlock: EncryptedBlock,
         onProgress?: (uploadedBytes: number) => void,
     ) {
@@ -430,13 +445,13 @@ export class StreamUploader {
                         onProgress?.(uploadedBytes);
                     },
                     this.abortController.signal,
-                )
+                );
                 this.uploadedBlocks.push({
                     index: encryptedBlock.index,
                     hash: encryptedBlock.hash,
                     encryptedSize: encryptedBlock.encryptedSize,
                     originalSize: encryptedBlock.originalSize,
-                })
+                });
                 break;
             } catch (error: unknown) {
                 if (blockProgress !== 0) {
@@ -446,20 +461,22 @@ export class StreamUploader {
 
                 if (
                     (error instanceof APIHTTPError && error.statusCode === HTTPErrorCode.NOT_FOUND) ||
-                    (error instanceof NotFoundAPIError)
+                    error instanceof NotFoundAPIError
                 ) {
                     logger.warn(`Token expired, fetching new token and retrying`);
                     const uploadTokens = await this.apiService.requestBlockUpload(
                         this.revisionDraft.nodeRevisionUid,
                         this.revisionDraft.nodeKeys.signatureAddress.addressId,
                         {
-                            contentBlocks: [{
-                                index: encryptedBlock.index,
-                                encryptedSize: encryptedBlock.encryptedSize,
-                                hash: encryptedBlock.hash,
-                                armoredSignature: encryptedBlock.armoredSignature,
-                                verificationToken: encryptedBlock.verificationToken,
-                            }],
+                            contentBlocks: [
+                                {
+                                    index: encryptedBlock.index,
+                                    encryptedSize: encryptedBlock.encryptedSize,
+                                    hash: encryptedBlock.hash,
+                                    armoredSignature: encryptedBlock.armoredSignature,
+                                    verificationToken: encryptedBlock.verificationToken,
+                                },
+                            ],
                         },
                     );
                     uploadToken = uploadTokens.blockTokens[0];
@@ -498,7 +515,8 @@ export class StreamUploader {
     }
 
     private verifyIntegrity(thumbnails: Thumbnail[]) {
-        const expectedBlockCount = Math.ceil(this.metadata.expectedSize / FILE_CHUNK_SIZE) + (thumbnails ? thumbnails?.length : 0);
+        const expectedBlockCount =
+            Math.ceil(this.metadata.expectedSize / FILE_CHUNK_SIZE) + (thumbnails ? thumbnails?.length : 0);
         if (this.uploadedBlockCount !== expectedBlockCount) {
             throw new IntegrityError(c('Error').t`Some file parts failed to upload`, {
                 uploadedBlockCount: this.uploadedBlockCount,