@protontech/drive-sdk 0.0.13 → 0.1.1

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

@@ -10,7 +10,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,
@@ -23,7 +28,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);
 }
 
@@ -177,7 +187,9 @@ describe('FileUploader', () => {
         it('should throw an error if upload already started', async () => {
             await uploader.writeStream(stream, thumbnails, onProgress);
 
-            await expect(uploader.writeStream(stream, thumbnails, onProgress)).rejects.toThrow('Upload already started');
+            await expect(uploader.writeStream(stream, thumbnails, onProgress)).rejects.toThrow(
+                'Upload already started',
+            );
         });
     });
 });

package/src/internal/upload/fileUploader.ts

@@ -1,10 +1,10 @@
-import { Thumbnail, UploadMetadata } from "../../interface";
-import { UploadAPIService } from "./apiService";
-import { BlockVerifier } from "./blockVerifier";
+import { Thumbnail, UploadMetadata } from '../../interface';
+import { UploadAPIService } from './apiService';
+import { BlockVerifier } from './blockVerifier';
 import { UploadController } from './controller';
-import { UploadCryptoService } from "./cryptoService";
-import { NodeRevisionDraft } from "./interface";
-import { UploadManager } from "./manager";
+import { UploadCryptoService } from './cryptoService';
+import { NodeRevisionDraft } from './interface';
+import { UploadManager } from './manager';
 import { StreamUploader } from './streamUploader';
 import { UploadTelemetry } from './telemetry';
 
@@ -46,7 +46,11 @@ class Uploader {
         this.controller = new UploadController();
     }
 
-    async writeFile(fileObject: File, thumbnails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<UploadController> {
+    async writeFile(
+        fileObject: File,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<UploadController> {
         if (this.controller.promise) {
             throw new Error(`Upload already started`);
         }
@@ -63,7 +67,11 @@ class Uploader {
         return this.controller;
     }
 
-    async writeStream(stream: ReadableStream, thumbnails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<UploadController> {
+    async writeStream(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<UploadController> {
         if (this.controller.promise) {
             throw new Error(`Upload already started`);
         }
@@ -71,7 +79,11 @@ class Uploader {
         return this.controller;
     }
 
-    protected async startUpload(stream: ReadableStream, thumbnails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<string> {
+    protected async startUpload(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<string> {
         const uploader = await this.initStreamUploader();
         return uploader.start(stream, thumbnails, onProgress);
     }
@@ -84,7 +96,7 @@ class Uploader {
             if (failure) {
                 await this.manager.deleteDraftNode(revisionDraft.nodeUid);
             }
-        }
+        };
 
         return new StreamUploader(
             this.telemetry,
@@ -99,7 +111,7 @@ class Uploader {
         );
     }
 
-    protected async createRevisionDraft(): Promise<{ revisionDraft: NodeRevisionDraft, blockVerifier: BlockVerifier }> {
+    protected async createRevisionDraft(): Promise<{ revisionDraft: NodeRevisionDraft; blockVerifier: BlockVerifier }> {
         throw new Error('Not implemented');
     }
 }
@@ -125,12 +137,17 @@ export class FileUploader extends Uploader {
         this.name = name;
     }
 
-    protected async createRevisionDraft(): Promise<{ revisionDraft: NodeRevisionDraft, blockVerifier: BlockVerifier }> {
+    protected async createRevisionDraft(): Promise<{ revisionDraft: NodeRevisionDraft; blockVerifier: BlockVerifier }> {
         let revisionDraft, blockVerifier;
         try {
             revisionDraft = await this.manager.createDraftNode(this.parentFolderUid, this.name, this.metadata);
 
-            blockVerifier = new BlockVerifier(this.apiService, this.cryptoService, revisionDraft.nodeKeys.key, revisionDraft.nodeRevisionUid);
+            blockVerifier = new BlockVerifier(
+                this.apiService,
+                this.cryptoService,
+                revisionDraft.nodeKeys.key,
+                revisionDraft.nodeRevisionUid,
+            );
             await blockVerifier.loadVerificationData();
         } catch (error: unknown) {
             this.onFinish();
@@ -144,7 +161,7 @@ export class FileUploader extends Uploader {
         return {
             revisionDraft,
             blockVerifier,
-        }
+        };
     }
 
     async getAvailableName(): Promise<string> {
@@ -172,12 +189,17 @@ export class FileRevisionUploader extends Uploader {
         this.nodeUid = nodeUid;
     }
 
-    protected async createRevisionDraft(): Promise<{ revisionDraft: NodeRevisionDraft, blockVerifier: BlockVerifier }> {
+    protected async createRevisionDraft(): Promise<{ revisionDraft: NodeRevisionDraft; blockVerifier: BlockVerifier }> {
         let revisionDraft, blockVerifier;
         try {
             revisionDraft = await this.manager.createDraftRevision(this.nodeUid, this.metadata);
 
-            blockVerifier = new BlockVerifier(this.apiService, this.cryptoService, revisionDraft.nodeKeys.key, revisionDraft.nodeRevisionUid);
+            blockVerifier = new BlockVerifier(
+                this.apiService,
+                this.cryptoService,
+                revisionDraft.nodeKeys.key,
+                revisionDraft.nodeRevisionUid,
+            );
             await blockVerifier.loadVerificationData();
         } catch (error: unknown) {
             this.onFinish();
@@ -191,6 +213,6 @@ export class FileRevisionUploader extends Uploader {
         return {
             revisionDraft,
             blockVerifier,
-        }
+        };
     }
 }

package/src/internal/upload/index.ts

@@ -1,17 +1,17 @@
-import { ProtonDriveTelemetry, UploadMetadata } from "../../interface";
-import { DriveAPIService } from "../apiService";
-import { DriveCrypto } from "../../crypto";
-import { UploadAPIService } from "./apiService";
-import { UploadCryptoService } from "./cryptoService";
-import { FileUploader, FileRevisionUploader } from "./fileUploader";
-import { NodesService, NodesEvents, SharesService } from "./interface";
-import { UploadManager } from "./manager";
-import { UploadQueue } from "./queue";
-import { UploadTelemetry } from "./telemetry";
+import { ProtonDriveTelemetry, UploadMetadata } from '../../interface';
+import { DriveAPIService } from '../apiService';
+import { DriveCrypto } from '../../crypto';
+import { UploadAPIService } from './apiService';
+import { UploadCryptoService } from './cryptoService';
+import { FileUploader, FileRevisionUploader } from './fileUploader';
+import { NodesService, SharesService } from './interface';
+import { UploadManager } from './manager';
+import { UploadQueue } from './queue';
+import { UploadTelemetry } from './telemetry';
 
 /**
  * Provides facade for the upload module.
- * 
+ *
  * The upload module is responsible for handling file uploads, including
  * metadata generation, content upload, API communication, encryption,
  * and verifications.
@@ -22,13 +22,13 @@ export function initUploadModule(
     driveCrypto: DriveCrypto,
     sharesService: SharesService,
     nodesService: NodesService,
-    nodesEvents: NodesEvents,
+    clientUid?: string,
 ) {
-    const api = new UploadAPIService(apiService);
+    const api = new UploadAPIService(apiService, clientUid);
     const cryptoService = new UploadCryptoService(driveCrypto, nodesService);
 
     const uploadTelemetry = new UploadTelemetry(telemetry, sharesService);
-    const manager = new UploadManager(telemetry, api, cryptoService, nodesService, nodesEvents);
+    const manager = new UploadManager(telemetry, api, cryptoService, nodesService, clientUid);
 
     const queue = new UploadQueue();
 
@@ -49,7 +49,7 @@ export function initUploadModule(
 
         const onFinish = () => {
             queue.releaseCapacity();
-        }
+        };
 
         return new FileUploader(
             uploadTelemetry,
@@ -80,7 +80,7 @@ export function initUploadModule(
 
         const onFinish = () => {
             queue.releaseCapacity();
-        }
+        };
 
         return new FileRevisionUploader(
             uploadTelemetry,
@@ -92,11 +92,10 @@ export function initUploadModule(
             onFinish,
             signal,
         );
-
     }
 
     return {
         getFileUploader,
         getFileRevisionUploader,
-    }
+    };
 }

package/src/internal/upload/interface.ts

@@ -1,128 +1,130 @@
-import { PrivateKey, SessionKey } from "../../crypto";
+import { PrivateKey, SessionKey } from '../../crypto';
 
-import { MetricVolumeType, ThumbnailType, Result, Revision } from "../../interface";
-import { DecryptedNode } from "../nodes";
+import { MetricVolumeType, ThumbnailType, Result, Revision } from '../../interface';
+import { DecryptedNode } from '../nodes';
 
 export type NodeRevisionDraft = {
-    nodeUid: string,
-    nodeRevisionUid: string,
-    nodeKeys: NodeRevisionDraftKeys,
+    nodeUid: string;
+    nodeRevisionUid: string;
+    nodeKeys: NodeRevisionDraftKeys;
     // newNodeInfo is set only when revision is created with the new node.
     newNodeInfo?: {
-        parentUid: string,
-        name: string,
-        encryptedName: string,
-        hash: string,
-    }
-}
+        parentUid: string;
+        name: string;
+        encryptedName: string;
+        hash: string;
+    };
+};
 
 export type NodeRevisionDraftKeys = {
-    key: PrivateKey,
-    contentKeyPacketSessionKey: SessionKey,
-    signatureAddress: NodeCryptoSignatureAddress,
-}
+    key: PrivateKey;
+    contentKeyPacketSessionKey: SessionKey;
+    signatureAddress: NodeCryptoSignatureAddress;
+};
 
 export type NodeCrypto = {
     nodeKeys: {
         encrypted: {
-            armoredKey: string,
-            armoredPassphrase: string,
-            armoredPassphraseSignature: string,
-        },
+            armoredKey: string;
+            armoredPassphrase: string;
+            armoredPassphraseSignature: string;
+        };
         decrypted: {
-            passphrase: string,
-            key: PrivateKey,
-            passphraseSessionKey: SessionKey,
-        },
-    },
+            passphrase: string;
+            key: PrivateKey;
+            passphraseSessionKey: SessionKey;
+        };
+    };
     contentKey: {
         encrypted: {
-            base64ContentKeyPacket: string,
-            armoredContentKeyPacketSignature: string,
-        },
+            base64ContentKeyPacket: string;
+            armoredContentKeyPacketSignature: string;
+        };
         decrypted: {
-            contentKeyPacketSessionKey: SessionKey,
-        },
-    },
+            contentKeyPacketSessionKey: SessionKey;
+        };
+    };
     encryptedNode: {
-        encryptedName: string,
-        hash: string,
-    },
-    signatureAddress: NodeCryptoSignatureAddress,
-}
+        encryptedName: string;
+        hash: string;
+    };
+    signatureAddress: NodeCryptoSignatureAddress;
+};
 
 export type NodeCryptoSignatureAddress = {
-    email: string,
-    addressId: string,
-    addressKey: PrivateKey,
-}
+    email: string;
+    addressId: string;
+    addressKey: PrivateKey;
+};
 
 export type EncryptedBlockMetadata = {
-    encryptedSize: number,
-    originalSize: number,
-    hash: Uint8Array,
-}
+    encryptedSize: number;
+    originalSize: number;
+    hash: Uint8Array;
+};
 
 export type EncryptedBlock = EncryptedBlockMetadata & {
-    index: number,
-    encryptedData: Uint8Array,
-    armoredSignature: string,
-    verificationToken: Uint8Array,
-}
+    index: number;
+    encryptedData: Uint8Array;
+    armoredSignature: string;
+    verificationToken: Uint8Array;
+};
 
 export type EncryptedThumbnail = EncryptedBlockMetadata & {
-    type: ThumbnailType,
-    encryptedData: Uint8Array,
-}
+    type: ThumbnailType;
+    encryptedData: Uint8Array;
+};
 
 export type UploadTokens = {
     blockTokens: {
-        index: number,
-        bareUrl: string,
-        token: string,
-    }[],
+        index: number;
+        bareUrl: string;
+        token: string;
+    }[];
     thumbnailTokens: {
-        type: ThumbnailType,
-        bareUrl: string,
-        token: string,
-    }[],
-}
+        type: ThumbnailType;
+        bareUrl: string;
+        token: string;
+    }[];
+};
 
 /**
  * Interface describing the dependencies to the nodes module.
  */
 export interface NodesService {
-    getNode(nodeUid: string): Promise<NodesServiceNode>,
+    getNode(nodeUid: string): Promise<NodesServiceNode>;
     getNodeKeys(nodeUid: string): Promise<{
-        key: PrivateKey,
-        passphraseSessionKey: SessionKey,
-        contentKeyPacketSessionKey?: SessionKey,
-        hashKey?: Uint8Array,
-    }>,
+        key: PrivateKey;
+        passphraseSessionKey: SessionKey;
+        contentKeyPacketSessionKey?: SessionKey;
+        hashKey?: Uint8Array;
+    }>;
     getRootNodeEmailKey(nodeUid: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
-    }>,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }>;
+    notifyChildCreated(nodeUid: string): Promise<void>;
 }
 
 /**
  * Interface describing the dependencies to the nodes module.
  */
 export interface NodesEvents {
-    nodeCreated(node: DecryptedNode): Promise<void>,
-    nodeUpdated(partialNode: { uid: string, activeRevision: Result<Revision, Error> }): Promise<void>,
+    nodeCreated(node: DecryptedNode): Promise<void>;
+    nodeUpdated(partialNode: { uid: string; activeRevision: Result<Revision, Error> }): Promise<void>;
 }
 
 export interface NodesServiceNode {
-    uid: string,
-    activeRevision?: Result<Revision, Error>,
+    uid: string;
+    parentUid?: string;
+    activeRevision?: Result<Revision, Error>;
 }
 
 /**
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>,
+    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
 }