@protontech/drive-sdk 0.0.13 → 0.1.1

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,17 +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(),
         };
-        const encryptedSize = uploadedBlocks.reduce((sum, block) => sum + block.encryptedSize, 0);
-        await this.uploadManager.commitDraft(
-            this.revisionDraft,
-            this.manifest,
-            this.metadata,
-            extendedAttributes,
-            encryptedSize,
-        );
+        await this.uploadManager.commitDraft(this.revisionDraft, this.manifest, this.metadata, extendedAttributes);
     }
 
     private async encryptThumbnails(thumbnails: Thumbnail[]) {
@@ -218,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);
         }
     }
@@ -258,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;
                         }
 
@@ -282,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,
+                    })),
+                ),
             },
         );
 
@@ -307,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.
@@ -331,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.
@@ -347,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;
@@ -370,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) {
@@ -409,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,
     ) {
@@ -432,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) {
@@ -448,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];
@@ -500,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,

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

@@ -25,7 +25,7 @@ describe('UploadTelemetry', () => {
 
         sharesService = {
             getVolumeMetricContext: jest.fn().mockResolvedValue('own_volume'),
-        }
+        };
 
         uploadTelemetry = new UploadTelemetry(mockTelemetry, sharesService);
     });
@@ -35,11 +35,11 @@ describe('UploadTelemetry', () => {
         await uploadTelemetry.uploadInitFailed(parentNodeUid, error, 1000);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
-            eventName: "upload",
-            volumeType: "own_volume",
+            eventName: 'upload',
+            volumeType: 'own_volume',
             uploadedSize: 0,
             expectedSize: 1000,
-            error: "unknown",
+            error: 'unknown',
             originalError: error,
         });
     });
@@ -49,11 +49,11 @@ describe('UploadTelemetry', () => {
         await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
-            eventName: "upload",
-            volumeType: "own_volume",
+            eventName: 'upload',
+            volumeType: 'own_volume',
             uploadedSize: 500,
             expectedSize: 1000,
-            error: "unknown",
+            error: 'unknown',
             originalError: error,
         });
     });
@@ -62,8 +62,8 @@ describe('UploadTelemetry', () => {
         await uploadTelemetry.uploadFinished(revisionUid, 1000);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
-            eventName: "upload",
-            volumeType: "own_volume",
+            eventName: 'upload',
+            volumeType: 'own_volume',
             uploadedSize: 1000,
             expectedSize: 1000,
         });
@@ -74,7 +74,7 @@ describe('UploadTelemetry', () => {
             expect(mockTelemetry.logEvent).toHaveBeenCalledWith(
                 expect.objectContaining({
                     error,
-                })
+                }),
             );
         };
 
@@ -130,4 +130,4 @@ describe('UploadTelemetry', () => {
             verifyErrorCategory('network_error');
         });
     });
-});
+});

package/src/internal/upload/telemetry.ts

@@ -1,21 +1,24 @@
-import { RateLimitedError, ValidationError, IntegrityError } from "../../errors";
-import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger } from "../../interface";
-import { LoggerWithPrefix } from "../../telemetry";
+import { RateLimitedError, ValidationError, IntegrityError } from '../../errors';
+import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger } from '../../interface';
+import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError } from '../apiService';
-import { splitNodeUid, splitNodeRevisionUid } from "../uids";
-import { SharesService } from "./interface";
+import { splitNodeUid, splitNodeRevisionUid } from '../uids';
+import { SharesService } from './interface';
 
 export class UploadTelemetry {
     private logger: Logger;
 
-    constructor(private telemetry: ProtonDriveTelemetry, private sharesService: SharesService) {
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        private sharesService: SharesService,
+    ) {
         this.telemetry = telemetry;
-        this.logger = this.telemetry.getLogger("download");
+        this.logger = this.telemetry.getLogger('download');
         this.sharesService = sharesService;
     }
 
     getLoggerForRevision(revisionUid: string) {
-        const logger = this.telemetry.getLogger("upload");
+        const logger = this.telemetry.getLogger('upload');
         return new LoggerWithPrefix(logger, `revision ${revisionUid}`);
     }
 
@@ -70,12 +73,15 @@ export class UploadTelemetry {
         });
     }
 
-    private async sendTelemetry(volumeId: string, options: {
-        uploadedSize: number,
-        expectedSize: number,
-        error?: MetricsUploadErrorType,
-        originalError?: unknown,
-    }) {
+    private async sendTelemetry(
+        volumeId: string,
+        options: {
+            uploadedSize: number;
+            expectedSize: number;
+            error?: MetricsUploadErrorType;
+            originalError?: unknown;
+        },
+    ) {
         let volumeType;
         try {
             volumeType = await this.sharesService.getVolumeMetricContext(volumeId);
@@ -113,7 +119,11 @@ function getErrorCategory(error: unknown): MetricsUploadErrorType | undefined {
         if (error.name === 'TimeoutError') {
             return 'server_error';
         }
-        if (error.name === 'OfflineError' || error.name === 'NetworkError' || error.message?.toLowerCase() === 'network error') {
+        if (
+            error.name === 'OfflineError' ||
+            error.name === 'NetworkError' ||
+            error.message?.toLowerCase() === 'network error'
+        ) {
             return 'network_error';
         }
         if (error.name === 'AbortError') {

package/src/internal/wait.test.ts

@@ -1,4 +1,4 @@
-import { waitForCondition } from "./wait";
+import { waitForCondition } from './wait';
 
 describe('waitForCondition', () => {
     it('should resolve immediately if condition is met', async () => {

package/src/internal/wait.ts

@@ -1,4 +1,4 @@
-import { AbortError } from "../errors";
+import { AbortError } from '../errors';
 
 const WAIT_TIME = 50;
 
@@ -17,10 +17,10 @@ export function waitForCondition(callback: () => boolean, signal?: AbortSignal)
     });
 }
 
-export async function waitSeconds(seconds: number){
+export async function waitSeconds(seconds: number) {
     return wait(seconds * 1000);
 }
 
-export async function wait(miliseconds: number){
+export async function wait(miliseconds: number) {
     return new Promise<void>((resolve) => setTimeout(resolve, miliseconds));
 }