@protontech/drive-sdk 0.0.12 → 0.1.0

package/src/internal/upload/index.ts

@@ -3,16 +3,15 @@ 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 { NodesService, NodesEvents, SharesService } from "./interface";
-import { Fileuploader } from "./fileUploader";
 import { UploadTelemetry } from "./telemetry";
-import { UploadManager } from "./manager";
-import { BlockVerifier } from "./blockVerifier";
 
 /**
  * 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.
@@ -23,95 +22,72 @@ 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();
 
+    /**
+     * Returns a FileUploader instance that can be used to upload a file to
+     * a parent folder.
+     *
+     * This operation does not call the API, it only returns a FileUploader
+     * instance when the upload queue has capacity.
+     */
     async function getFileUploader(
         parentFolderUid: string,
         name: string,
         metadata: UploadMetadata,
         signal?: AbortSignal,
-    ): Promise<Fileuploader> {
+    ): Promise<FileUploader> {
         await queue.waitForCapacity(signal);
 
-        let revisionDraft, blockVerifier;
-        try {
-            revisionDraft = await manager.createDraftNode(parentFolderUid, name, metadata);
-
-            blockVerifier = new BlockVerifier(api, cryptoService, revisionDraft.nodeKeys.key, revisionDraft.nodeRevisionUid);
-            await blockVerifier.loadVerificationData();
-        } catch (error: unknown) {
-            queue.releaseCapacity();
-            if (revisionDraft) {
-                await manager.deleteDraftNode(revisionDraft.nodeUid);
-            }
-            void uploadTelemetry.uploadInitFailed(parentFolderUid, error, metadata.expectedSize);
-            throw error;
-        }
-
-        const onFinish = async (failure: boolean) => {
+        const onFinish = () => {
             queue.releaseCapacity();
-            if (failure) {
-                await manager.deleteDraftNode(revisionDraft.nodeUid);
-            }
         }
 
-        return new Fileuploader(
+        return new FileUploader(
             uploadTelemetry,
             api,
             cryptoService,
             manager,
-            blockVerifier,
-            revisionDraft,
+            parentFolderUid,
+            name,
             metadata,
             onFinish,
             signal,
         );
     }
 
+    /**
+     * Returns a FileUploader instance that can be used to upload a new
+     * revision of a file.
+     *
+     * This operation does not call the API, it only returns a
+     * FileRevisionUploader instance when the upload queue has capacity.
+     */
     async function getFileRevisionUploader(
         nodeUid: string,
         metadata: UploadMetadata,
         signal?: AbortSignal,
-    ): Promise<Fileuploader> {
+    ): Promise<FileRevisionUploader> {
         await queue.waitForCapacity(signal);
 
-        let revisionDraft, blockVerifier;
-        try {
-            revisionDraft = await manager.createDraftRevision(nodeUid, metadata);
-
-            blockVerifier = new BlockVerifier(api, cryptoService, revisionDraft.nodeKeys.key, revisionDraft.nodeRevisionUid);
-            await blockVerifier.loadVerificationData();
-        } catch (error: unknown) {
-            queue.releaseCapacity();
-            if (revisionDraft) {
-                await manager.deleteDraftRevision(revisionDraft.nodeRevisionUid);
-            }
-            void uploadTelemetry.uploadInitFailed(nodeUid, error, metadata.expectedSize);
-            throw error;
-        }
-
-        const onFinish = async (failure: boolean) => {
+        const onFinish = () => {
             queue.releaseCapacity();
-            if (failure) {
-                await manager.deleteDraftNode(revisionDraft.nodeUid);
-            }
         }
 
-        return new Fileuploader(
+        return new FileRevisionUploader(
             uploadTelemetry,
             api,
             cryptoService,
             manager,
-            blockVerifier,
-            revisionDraft,
+            nodeUid,
             metadata,
             onFinish,
             signal,

package/src/internal/upload/interface.ts

@@ -105,6 +105,7 @@ export interface NodesService {
         addressKey: PrivateKey,
         addressKeyId: string,
     }>,
+    notifyChildCreated(nodeUid: string): Promise<void>;
 }
 
 /**
@@ -117,6 +118,7 @@ export interface NodesEvents {
 
 export interface NodesServiceNode {
     uid: string,
+    parentUid?: string,
     activeRevision?: Result<Revision, Error>,
 }
 

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

@@ -1,10 +1,10 @@
 import { ValidationError } from "../../errors";
-import { NodeType, ProtonDriveTelemetry, RevisionState, UploadMetadata } from "../../interface";
+import { ProtonDriveTelemetry, UploadMetadata } from "../../interface";
 import { getMockTelemetry } from "../../tests/telemetry";
 import { ErrorCode } from "../apiService";
 import { UploadAPIService } from "./apiService";
 import { UploadCryptoService } from "./cryptoService";
-import { NodesService, NodesEvents } from "./interface";
+import { NodesService } from "./interface";
 import { UploadManager } from './manager';
 
 describe("UploadManager", () => {
@@ -12,10 +12,11 @@ describe("UploadManager", () => {
     let apiService: UploadAPIService;
     let cryptoService: UploadCryptoService;
     let nodesService: NodesService;
-    let nodesEvents: NodesEvents;
 
     let manager: UploadManager;
 
+    const clientUid = 'clientUid';
+
     beforeEach(() => {
         telemetry = getMockTelemetry();
         // @ts-expect-error No need to implement all methods for mocking
@@ -73,8 +74,12 @@ describe("UploadManager", () => {
                 armoredExtendedAttributes: "newNode:armoredExtendedAttributes",
             }),
         }
-        // @ts-expect-error No need to implement all methods for mocking
         nodesService = {
+            getNode: jest.fn(async (nodeUid: string) => ({
+                uid: nodeUid,
+                parentUid: 'parentUid',
+
+            })),
             getNodeKeys: jest.fn().mockResolvedValue({
                 hashKey: 'parentNode:hashKey',
                 key: 'parentNode:nodekey',
@@ -83,13 +88,10 @@ describe("UploadManager", () => {
                 email: "signatureEmail",
                 addressId: "addressId",
             }),
-        }
-        nodesEvents = {
-            nodeCreated: jest.fn(),
-            nodeUpdated: jest.fn(),
+            notifyChildCreated: jest.fn(async (nodeUid: string) => { return }),
         }
 
-        manager = new UploadManager(telemetry, apiService, cryptoService, nodesService, nodesEvents);
+        manager = new UploadManager(telemetry, apiService, cryptoService, nodesService, clientUid);
     });
 
     describe("createDraftNode", () => {
@@ -135,14 +137,18 @@ describe("UploadManager", () => {
                 armoredContentKeyPacketSignature: "newNode:armoredContentKeyPacketSignature",
                 signatureEmail: "signatureEmail",
             });
-            expect(apiService.checkAvailableHashes).not.toHaveBeenCalled();
         });
 
-        it("should handle existing draft by deleting and trying again", async () => {
-            let hashChecked = false;
+        it("should delete existing draft and trying again", async () => {
+            let firstCall = true;
             apiService.createDraft = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS);
+                if (firstCall) {
+                    firstCall = false;
+                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS, {
+                        ConflictLinkID: "existingLinkId",
+                        ConflictDraftRevisionID: "existingDraftRevisionId",
+                        ConflictDraftClientUID: clientUid,
+                    });
                 }
                 return {
                     nodeUid: "newNode:nodeUid",
@@ -150,27 +156,8 @@ describe("UploadManager", () => {
                 };
             });
 
-            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    hashChecked = true;
-                    return {
-                        availalbleHashes: ["name1Hash"],
-                        pendingHashes: [{
-                            hash: "newNode:hash",
-                            nodeUid: "nodeUidToDelete"
-                        }],
-                    }
-                }
-                return {
-                    availalbleHashes: ["name1Hash"],
-                    pendingHashes: [],
-                }
-            });
-
-            const result = await manager.createDraftNode("parentUid", "name", {} as UploadMetadata);
+            const result = await manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
 
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
-            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
             expect(result).toEqual({
                 nodeUid: "newNode:nodeUid",
                 nodeRevisionUid: "newNode:nodeRevisionUid",
@@ -182,60 +169,57 @@ describe("UploadManager", () => {
                     },
                 },
                 newNodeInfo: {
-                    parentUid: "parentUid",
+                    parentUid: "volumeId~parentUid",
                     name: "name",
                     encryptedName: "newNode:encryptedName",
                     hash: "newNode:hash",
                 },
             });
-            expect(apiService.deleteDraft).toHaveBeenCalledWith("nodeUidToDelete");
+            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
+            expect(apiService.deleteDraft).toHaveBeenCalledWith("volumeId~existingLinkId");
         });
 
-        it("should handle error when deleting existing draft", async () => {
-            let hashChecked = false;
+        it("should not delete existing draft if client UID does not match", async () => {
+            let firstCall = true;
             apiService.createDraft = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS);
+                if (firstCall) {
+                    firstCall = false;
+                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS, {
+                        ConflictLinkID: "existingLinkId",
+                        ConflictDraftRevisionID: "existingDraftRevisionId",
+                        ConflictDraftClientUID: "anotherClientUid",
+                    });
                 }
                 return {
                     nodeUid: "newNode:nodeUid",
                     nodeRevisionUid: "newNode:nodeRevisionUid",
                 };
             });
-            apiService.deleteDraft = jest.fn().mockImplementation(() => {
-                throw new Error("Failed to delete draft");
-            });
 
-            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    hashChecked = true;
-                    return {
-                        availalbleHashes: ["name1Hash"],
-                        pendingHashes: [{
-                            hash: "newNode:hash",
-                            nodeUid: "nodeUidToDelete"
-                        }],
-                    }
-                }
-                return {
-                    availalbleHashes: ["name1Hash"],
-                    pendingHashes: [],
-                }
-            });
+            const promise = manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
 
-            const result = manager.createDraftNode("parentUid", "name", {} as UploadMetadata);
-
-            await expect(result).rejects.toThrow("Draft already exists");
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
-            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
+            try {
+                await promise;
+            } catch (error: any) {
+                expect(error.message).toBe("Draft already exists");
+                expect(error.ongoingUploadByOtherClient).toBe(true);
+            }
+            expect(apiService.deleteDraft).not.toHaveBeenCalled();
         });
 
-        it("should handle existing name by providing available name", async () => {
-            let count = 0;
+        it("should not delete existing draft if client UID is not set", async () => {
+            const clientUid = undefined;
+            manager = new UploadManager(telemetry, apiService, cryptoService, nodesService, clientUid);
+
+            let firstCall = true;
             apiService.createDraft = jest.fn().mockImplementation(() => {
-                if (count === 0) {
-                    count++;
-                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS);
+                if (firstCall) {
+                    firstCall = false;
+                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS, {
+                        ConflictLinkID: "existingLinkId",
+                        ConflictDraftRevisionID: "existingDraftRevisionId",
+                        ConflictDraftClientUID: clientUid,
+                    });
                 }
                 return {
                     nodeUid: "newNode:nodeUid",
@@ -243,33 +227,69 @@ describe("UploadManager", () => {
                 };
             });
 
-            const result = manager.createDraftNode("parentUid", "name", {} as UploadMetadata);
-
-            await expect(result).rejects.toThrow("Draft already exists");
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
+            const promise = manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
 
             try {
-                await result;
+                await promise;
             } catch (error: any) {
-                expect(error.availableName).toBe("name1");
+                expect(error.message).toBe("Draft already exists");
+                expect(error.ongoingUploadByOtherClient).toBe(true);
             }
+            expect(apiService.deleteDraft).not.toHaveBeenCalled();
         });
 
-        it("should handle existing name by providing available name when there is too many conflicts", async () => {
-            let hashChecked = false;
+        it("should handle error when deleting existing draft", async () => {
+            let firstCall = true;
             apiService.createDraft = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS);
+                if (firstCall) {
+                    firstCall = false;
+                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS, {
+                        ConflictLinkID: "existingLinkId",
+                        ConflictDraftRevisionID: "existingDraftRevisionId",
+                        ConflictDraftClientUID: clientUid,
+                    });
                 }
                 return {
                     nodeUid: "newNode:nodeUid",
                     nodeRevisionUid: "newNode:nodeRevisionUid",
                 };
             });
+            apiService.deleteDraft = jest.fn().mockImplementation(() => {
+                throw new Error("Failed to delete draft");
+            });
+
+            const result = manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
 
+            try {
+                await result;
+            } catch (error: any) {
+                expect(error.message).toBe("Draft already exists");
+                expect(error.existingNodeUid).toBe("volumeId~existingLinkId");
+            }
+            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe("findAvailableName", () => {
+        it("should find available name", async () => {
             apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    hashChecked = true;
+                return {
+                    availalbleHashes: ["name3Hash"],
+                    pendingHashes: [],
+                }
+            });
+
+            const result = await manager.findAvailableName("parentUid", "name");
+            expect(result).toBe("name3");
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith("parentUid", ["name1Hash", "name2Hash", "name3Hash"]);
+        });
+
+        it("should find available name with multiple pages", async () => {
+            let firstCall = false;
+            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
+                if (!firstCall) {
+                    firstCall = true;
                     return {
                         // First page has no available hashes
                         availalbleHashes: [],
@@ -282,16 +302,10 @@ describe("UploadManager", () => {
                 }
             });
 
-            const result = manager.createDraftNode("parentUid", "name", {} as UploadMetadata);
-
-            await expect(result).rejects.toThrow("Draft already exists");
+            const result = await manager.findAvailableName("parentUid", "name");
+            expect(result).toBe("name3");
             expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(2);
-
-            try {
-                await result;
-            } catch (error: any) {
-                expect(error.availableName).toBe("name3");
-            }
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith("parentUid", ["name1Hash", "name2Hash", "name3Hash"]);
         });
     });
 
@@ -300,7 +314,7 @@ describe("UploadManager", () => {
             nodeUid: "newNode:nodeUid",
             nodeRevisionUid: "newNode:nodeRevisionUid",
             nodeKeys: {
-                key: {_idx: 32321},
+                key: { _idx: 32321 },
                 contentKeyPacketSessionKey: "newNode:contentKeyPacketSessionKey",
                 signatureAddress: {
                     email: "signatureEmail",
@@ -327,29 +341,11 @@ describe("UploadManager", () => {
                 manifest,
                 metadata,
                 extendedAttributes,
-                1234567,
             );
 
             expect(cryptoService.commitFile).toHaveBeenCalledWith(nodeRevisionDraft.nodeKeys, manifest, expect.anything());
             expect(apiService.commitDraftRevision).toHaveBeenCalledWith(nodeRevisionDraft.nodeRevisionUid, expect.anything());
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: "newNode:nodeUid",
-                activeRevision: {
-                    ok: true,
-                    value: {
-                        uid: "newNode:nodeRevisionUid",
-                        state: RevisionState.Active,
-                        creationTime: expect.any(Date),
-                        contentAuthor: { ok: true, value: "signatureEmail" },
-                        storageSize: 1234567,
-                        claimedSize: 123456,
-                        claimedModificationTime: extendedAttributes.modificationTime,
-                        claimedDigests: {
-                            sha1: "sha1",
-                        },
-                    },
-                },
-            });
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith("parentUid");
         })
 
         it("should commit node draft", async () => {
@@ -367,24 +363,11 @@ describe("UploadManager", () => {
                 manifest,
                 metadata,
                 extendedAttributes,
-                1234567,
             );
 
             expect(cryptoService.commitFile).toHaveBeenCalledWith(nodeRevisionDraft.nodeKeys, manifest, expect.anything());
             expect(apiService.commitDraftRevision).toHaveBeenCalledWith(nodeRevisionDraft.nodeRevisionUid, expect.anything());
-            expect(nodesEvents.nodeCreated).toHaveBeenCalledWith(expect.objectContaining({
-                uid: "newNode:nodeUid",
-                parentUid: "parentUid",
-                type: NodeType.File,
-                totalStorageSize: 1234567,
-                activeRevision: {
-                    ok: true,
-                    value: expect.objectContaining({
-                        uid: "newNode:nodeRevisionUid",
-                        storageSize: 1234567,
-                    }),
-                },
-            }));
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith("parentUid");
         });
     });
 });