@protontech/drive-sdk 0.0.11 → 0.0.13

package/src/internal/upload/index.ts

@@ -3,12 +3,11 @@ import { DriveAPIService } from "../apiService";
 import { DriveCrypto } from "../../crypto";
 import { UploadAPIService } from "./apiService";
 import { UploadCryptoService } from "./cryptoService";
-import { UploadQueue } from "./queue";
+import { FileUploader, FileRevisionUploader } from "./fileUploader";
 import { NodesService, NodesEvents, SharesService } from "./interface";
-import { Fileuploader } from "./fileUploader";
-import { UploadTelemetry } from "./telemetry";
 import { UploadManager } from "./manager";
-import { BlockVerifier } from "./blockVerifier";
+import { UploadQueue } from "./queue";
+import { UploadTelemetry } from "./telemetry";
 
 /**
  * Provides facade for the upload module.
@@ -33,85 +32,62 @@ export function initUploadModule(
 
     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/manager.test.ts

@@ -135,14 +135,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: "existingDraftClientUid",
+                    });
                 }
                 return {
                     nodeUid: "newNode:nodeUid",
@@ -150,26 +154,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("volumeId~parentUid", "name", {} as UploadMetadata);
 
-            const result = await manager.createDraftNode("parentUid", "name", {} as UploadMetadata);
-
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
             expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
             expect(result).toEqual({
                 nodeUid: "newNode:nodeUid",
@@ -182,20 +168,25 @@ describe("UploadManager", () => {
                     },
                 },
                 newNodeInfo: {
-                    parentUid: "parentUid",
+                    parentUid: "volumeId~parentUid",
                     name: "name",
                     encryptedName: "newNode:encryptedName",
                     hash: "newNode:hash",
                 },
             });
-            expect(apiService.deleteDraft).toHaveBeenCalledWith("nodeUidToDelete");
+            expect(apiService.deleteDraft).toHaveBeenCalledWith("volumeId~existingLinkId");
         });
 
         it("should handle error when deleting existing draft", async () => {
-            let hashChecked = false;
+            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: "existingDraftClientUid",
+                    });
                 }
                 return {
                     nodeUid: "newNode:nodeUid",
@@ -206,70 +197,38 @@ describe("UploadManager", () => {
                 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 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);
-        });
-
-        it("should handle existing name by providing available name", async () => {
-            let count = 0;
-            apiService.createDraft = jest.fn().mockImplementation(() => {
-                if (count === 0) {
-                    count++;
-                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS);
-                }
-                return {
-                    nodeUid: "newNode:nodeUid",
-                    nodeRevisionUid: "newNode:nodeRevisionUid",
-                };
-            });
-
-            const result = manager.createDraftNode("parentUid", "name", {} as UploadMetadata);
-
-            await expect(result).rejects.toThrow("Draft already exists");
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
+            const result = manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
 
             try {
                 await result;
             } catch (error: any) {
-                expect(error.availableName).toBe("name1");
+                expect(error.message).toBe("Draft already exists");
+                expect(error.existingNodeUid).toBe("volumeId~existingLinkId");
             }
+            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
         });
+    });
 
-        it("should handle existing name by providing available name when there is too many conflicts", async () => {
-            let hashChecked = false;
-            apiService.createDraft = jest.fn().mockImplementation(() => {
-                if (!hashChecked) {
-                    throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS);
-                }
+    describe("findAvailableName", () => {
+        it("should find available name", async () => {
+            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
                 return {
-                    nodeUid: "newNode:nodeUid",
-                    nodeRevisionUid: "newNode:nodeRevisionUid",
-                };
+                    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 (!hashChecked) {
-                    hashChecked = true;
+                if (!firstCall) {
+                    firstCall = true;
                     return {
                         // First page has no available hashes
                         availalbleHashes: [],
@@ -282,16 +241,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 +253,7 @@ describe("UploadManager", () => {
             nodeUid: "newNode:nodeUid",
             nodeRevisionUid: "newNode:nodeRevisionUid",
             nodeKeys: {
-                key: {_idx: 32321},
+                key: { _idx: 32321 },
                 contentKeyPacketSessionKey: "newNode:contentKeyPacketSessionKey",
                 signatureAddress: {
                     email: "signatureEmail",

package/src/internal/upload/manager.ts

@@ -7,6 +7,7 @@ import { DecryptedNode, generateFileExtendedAttributes } from "../nodes";
 import { UploadAPIService } from "./apiService";
 import { UploadCryptoService } from "./cryptoService";
 import { NodeRevisionDraft, NodesService, NodesEvents, NodeCrypto } from "./interface";
+import { makeNodeUid, splitNodeUid } from "../uids";
 
 /**
  * UploadManager is responsible for creating and deleting draft nodes
@@ -95,23 +96,26 @@ export class UploadManager {
             if (error instanceof ValidationError) {
                 if (error.code === ErrorCode.ALREADY_EXISTS) {
                     this.logger.info(`Node with given name already exists`);
-                    const availableName = await this.findAvailableName(
-                        parentFolderUid,
-                        parentHashKey,
-                        name,
-                        generatedNodeCrypto.encryptedNode.hash,
-                    );
+
+                    const typedDetails = error.details as {
+                        ConflictLinkID: string,
+                        ConflictRevisionID?: string,
+                        ConflictDraftRevisionID?: string,
+                        ConflictDraftClientUID?: string,
+                    } | undefined;
 
                     // 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 (availableName.existingDraftNodeUid) {
+                    if (typedDetails?.ConflictDraftRevisionID) {
+                        const existingDraftNodeUid = makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID);
+
                         let deleteFailed = false;
                         try {
-                            this.logger.warn(`Deleting existing draft node ${availableName.existingDraftNodeUid}`);
-                            await this.apiService.deleteDraft(availableName.existingDraftNodeUid);
+                            this.logger.warn(`Deleting existing draft node ${existingDraftNodeUid}`);
+                            await this.apiService.deleteDraft(existingDraftNodeUid);
                         } catch (deleteDraftError: unknown) {
-                            // Do not throw, let return the next available name to the client.
+                            // Do not throw, let throw the conflict error.
                             deleteFailed = true;
                             this.logger.error('Failed to delete existing draft node', deleteDraftError);
                         }
@@ -120,12 +124,14 @@ export class UploadManager {
                         }
                     }
 
+                    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.
                     throw new NodeAlreadyExistsValidationError(
                         error.message,
                         error.code,
-                        availableName.availableName,
+                        existingNodeUid,
                     );
                 }
             }
@@ -133,10 +139,12 @@ export class UploadManager {
         }
     }
 
-    private async findAvailableName(parentFolderUid: string, parentHashKey: Uint8Array, name: string, nameHash: string): Promise<{
-        availableName: string,
-        existingDraftNodeUid?: string,
-    }> {
+    async findAvailableName(parentFolderUid: string, name: string): Promise<string> {
+        const { hashKey: parentHashKey } = await this.nodesService.getNodeKeys(parentFolderUid);
+        if (!parentHashKey) {
+            throw new ValidationError(c('Error').t`Creating files in non-folders is not allowed`);
+        }
+
         const [namePart, extension] = splitExtension(name);
 
         const batchSize = 10;
@@ -149,14 +157,9 @@ export class UploadManager {
 
             const hashesToCheck = await this.cryptoService.generateNameHashes(parentHashKey, namesToCheck);
 
-            const { pendingHashes, availalbleHashes } = await this.apiService.checkAvailableHashes(
+            const { availalbleHashes } = await this.apiService.checkAvailableHashes(
                 parentFolderUid,
-                [
-                    ...hashesToCheck.map(({ hash }) => hash),
-                    // Adding the current name hash to get the existing draft
-                    // node UID if it exists.
-                    ...startIndex ? [nameHash] : [],
-                ],
+                hashesToCheck.map(({ hash }) => hash),
             );
 
             if (!availalbleHashes.length) {
@@ -169,12 +172,7 @@ export class UploadManager {
                 throw Error('Backend returned unexpected hash');
             }
 
-            // FIXME: use client UID to ensure its own pending draft
-            const ownPendingHash = pendingHashes.find(({ hash }) => hash === nameHash);
-            return {
-                availableName: availableHash.name,
-                existingDraftNodeUid: ownPendingHash?.nodeUid,
-            }
+            return availableHash.name;
         }
     }
 
@@ -261,7 +259,7 @@ export class UploadManager {
                 // Internal metadata
                 hash: nodeRevisionDraft.newNodeInfo.hash,
                 encryptedName: nodeRevisionDraft.newNodeInfo.encryptedName,
-    
+
                 // Basic node metadata
                 uid: nodeRevisionDraft.nodeUid,
                 parentUid: nodeRevisionDraft.newNodeInfo.parentUid,
@@ -269,11 +267,11 @@ export class UploadManager {
                 mediaType: metadata.mediaType,
                 creationTime: new Date(),
                 totalStorageSize: encryptedSize,
-    
+
                 // Share node metadata
                 isShared: false,
                 directMemberRole: MemberRole.Inherited,
-    
+
                 // Decrypted metadata
                 isStale: false,
                 keyAuthor: resultOk(nodeRevisionDraft.nodeKeys.signatureAddress.email),
@@ -297,7 +295,7 @@ export class UploadManager {
  */
 function splitExtension(filename = ''): [string, string] {
     const endIdx = filename.lastIndexOf('.');
-    if (endIdx === -1 || endIdx === filename.length-1) {
+    if (endIdx === -1 || endIdx === filename.length - 1) {
         return [filename, ''];
     }
     return [filename.slice(0, endIdx), filename.slice(endIdx + 1)];