@protontech/drive-sdk 0.0.13 → 0.1.0

package/src/internal/sharing/sharingManagement.test.ts

@@ -2,7 +2,7 @@ import { getMockLogger } from "../../tests/logger";
 import { Member, MemberRole, NonProtonInvitation, NonProtonInvitationState, ProtonDriveAccount, ProtonInvitation, PublicLink, resultOk } from "../../interface";
 import { SharingAPIService } from "./apiService";
 import { SharingCryptoService } from "./cryptoService";
-import { SharesService, NodesService, NodesEvents } from "./interface";
+import { SharesService, NodesService } from "./interface";
 import { SharingManagement } from "./sharingManagement";
 
 describe("SharingManagement", () => {
@@ -11,7 +11,6 @@ describe("SharingManagement", () => {
     let accountService: ProtonDriveAccount;
     let sharesService: SharesService;
     let nodesService: NodesService;
-    let nodesEvents: NodesEvents;
 
     let sharingManagement: SharingManagement;
 
@@ -82,12 +81,10 @@ describe("SharingManagement", () => {
             getNodeKeys: jest.fn().mockImplementation((nodeUid) => ({ key: "node-key" })),
             getNodePrivateAndSessionKeys: jest.fn().mockImplementation((nodeUid) => ({})),
             getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: "volume-email", addressKey: "volume-key" }),
-        }
-        nodesEvents = {
-            nodeUpdated: jest.fn(),
+            notifyNodeChanged: jest.fn(),
         }
 
-        sharingManagement = new SharingManagement(getMockLogger(), apiService, cryptoService, accountService, sharesService, nodesService, nodesEvents);
+        sharingManagement = new SharingManagement(getMockLogger(), apiService, cryptoService, accountService, sharesService, nodesService);
     });
 
     describe("getSharingInfo", () => {
@@ -175,6 +172,7 @@ describe("SharingManagement", () => {
 
         it("should create share if no exists", async () => {
             nodesService.getNode = jest.fn().mockImplementation((nodeUid) => ({ nodeUid, parentUid: 'parentUid', name: { ok: true, value: "name" } }));
+            nodesService.notifyNodeChanged = jest.fn();
 
             const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ["email"] });
 
@@ -191,11 +189,7 @@ describe("SharingManagement", () => {
             });
             expect(apiService.updateInvitation).not.toHaveBeenCalled();
             expect(apiService.inviteProtonUser).toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: nodeUid,
-                shareId: "newShareId",
-                isShared: true,
-            });
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith(nodeUid);
         });
     })
 
@@ -264,7 +258,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should share node with proton email with specific role", async () => {
@@ -283,7 +276,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should update existing role", async () => {
@@ -300,7 +292,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateInvitation).toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should be no-op if no change", async () => {
@@ -314,7 +305,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
 
@@ -340,7 +330,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should share node with external email with specific role", async () => {
@@ -360,7 +349,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should update existing role", async () => {
@@ -377,7 +365,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateExternalInvitation).toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should be no-op if no change", async () => {
@@ -391,7 +378,6 @@ describe("SharingManagement", () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
 
@@ -429,7 +415,6 @@ describe("SharingManagement", () => {
                 expect(apiService.inviteExternalUser).toHaveBeenCalledWith("shareId", expect.objectContaining({
                     inviteeEmail: "email2",
                 }), expect.anything());
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
 
@@ -449,7 +434,6 @@ describe("SharingManagement", () => {
                 expect(apiService.updateMember).toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should be no-op if no change via proton user", async () => {
@@ -464,7 +448,6 @@ describe("SharingManagement", () => {
                 expect(apiService.updateMember).not.toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should update member via non-proton user", async () => {
@@ -482,7 +465,6 @@ describe("SharingManagement", () => {
                 expect(apiService.updateMember).toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
 
             it("should be no-op if no change via non-proton user", async () => {
@@ -497,7 +479,6 @@ describe("SharingManagement", () => {
                 expect(apiService.updateMember).not.toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
-                expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
             });
         });
 
@@ -526,6 +507,7 @@ describe("SharingManagement", () => {
                         expirationTime: undefined,
                         customPassword: undefined,
                         creatorEmail: "volume-email",
+                        numberOfInitializedDownloads: 0,
                     },
                 });
                 expect(cryptoService.generatePublicLinkPassword).toHaveBeenCalled();
@@ -563,6 +545,7 @@ describe("SharingManagement", () => {
                         expirationTime: new Date('2025-01-02'),
                         customPassword: "customPassword",
                         creatorEmail: "volume-email",
+                        numberOfInitializedDownloads: 0,
                     },
                 });
                 expect(cryptoService.generatePublicLinkPassword).toHaveBeenCalled();
@@ -661,7 +644,7 @@ describe("SharingManagement", () => {
         });
     });
 
-    describe("unsahreNode", () => {
+    describe("unshareNode", () => {
         const nodeUid = "volumeId~nodeUid";
 
         let invitation: ProtonInvitation;
@@ -697,6 +680,7 @@ describe("SharingManagement", () => {
                 creationTime: new Date(),
                 role: MemberRole.Viewer,
                 url: "url",
+                numberOfInitializedDownloads: 0,
             }
 
             apiService.getShareInvitations = jest.fn().mockResolvedValue([
@@ -725,7 +709,6 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
 
         it("should delete external invitation", async () => {
@@ -742,7 +725,6 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
 
         it("should remove member", async () => {
@@ -759,7 +741,6 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
 
         it("should be no-op if not shared with email", async () => {
@@ -776,7 +757,6 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
 
         it("should remove public link", async () => {
@@ -793,7 +773,6 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).not.toHaveBeenCalled();
         });
 
         it("should remove share if all is removed", async () => {
@@ -805,11 +784,7 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: nodeUid,
-                shareId: undefined,
-                isShared: false,
-            });
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalled();
         });
 
         it("should remove share if everything is manually removed", async () => {
@@ -824,11 +799,6 @@ describe("SharingManagement", () => {
             expect(apiService.deleteExternalInvitation).toHaveBeenCalled();
             expect(apiService.removeMember).toHaveBeenCalled();
             expect(apiService.removePublicLink).toHaveBeenCalled();
-            expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith({
-                uid: nodeUid,
-                shareId: undefined,
-                isShared: false,
-            });
         });
     });
 

package/src/internal/sharing/sharingManagement.ts

@@ -7,7 +7,7 @@ import { splitNodeUid } from "../uids";
 import { getErrorMessage } from '../errors';
 import { SharingAPIService } from "./apiService";
 import { PUBLIC_LINK_GENERATED_PASSWORD_LENGTH, SharingCryptoService } from "./cryptoService";
-import { SharesService, NodesService, NodesEvents, ShareResultWithCreatorEmail, PublicLinkWithCreatorEmail } from "./interface";
+import { SharesService, NodesService, ShareResultWithCreatorEmail, PublicLinkWithCreatorEmail } from "./interface";
 
 interface InternalShareResult extends ShareResultWithCreatorEmail {
     share: Share;
@@ -40,7 +40,6 @@ export class SharingManagement {
         private account: ProtonDriveAccount,
         private sharesService: SharesService,
         private nodesService: NodesService,
-        private nodesEvents: NodesEvents,
     ) {
         this.logger = logger;
         this.apiService = apiService;
@@ -48,7 +47,6 @@ export class SharingManagement {
         this.account = account;
         this.sharesService = sharesService;
         this.nodesService = nodesService;
-        this.nodesEvents = nodesEvents;
     }
 
     async getSharingInfo(nodeUid: string): Promise<ShareResultWithCreatorEmail | undefined> {
@@ -239,7 +237,7 @@ export class SharingManagement {
 
         if (!settings) {
             this.logger.info(`Unsharing node ${nodeUid}`);
-            await this.deleteShare(nodeUid, currentSharing.share.shareId);
+            await this.deleteShare(currentSharing.share.shareId, nodeUid);
             return;
         }
 
@@ -293,7 +291,7 @@ export class SharingManagement {
             // update local state immediately.
             this.logger.info(`Deleting share ${currentSharing.share.shareId} for node ${nodeUid}`);
             try {
-                await this.deleteShare(nodeUid, currentSharing.share.shareId);
+                await this.deleteShare(currentSharing.share.shareId, nodeUid);
             } catch (error: unknown) {
                 // If deleting the share fails, we don't want to throw an error
                 // as it might be a race condition that other client updated
@@ -359,9 +357,7 @@ export class SharingManagement {
                 base64NameKeyPacket: keys.base64NameKeyPacket,
             },
         );
-
-        await this.nodesEvents.nodeUpdated({ uid: nodeUid, shareId, isShared: true });
-
+        await this.nodesService.notifyNodeChanged(nodeUid);
         return {
             volumeId,
             shareId,
@@ -370,10 +366,9 @@ export class SharingManagement {
         }
     }
 
-    private async deleteShare(nodeUid: string, shareId: string): Promise<void> {
+    private async deleteShare(shareId: string, nodeUid: string): Promise<void> {
         await this.apiService.deleteShare(shareId);
-
-        await this.nodesEvents.nodeUpdated({ uid: nodeUid, shareId: undefined, isShared: false });
+        await this.nodesService.notifyNodeChanged(nodeUid);
     }
 
     private async inviteProtonUser(share: Share, inviteeEmail: string, role: MemberRole, emailOptions: EmailOptions): Promise<ProtonInvitation> {
@@ -486,6 +481,7 @@ export class SharingManagement {
             url: `${publicLink.publicUrl}#${generatedPassword}`,
             customPassword: options.customPassword,
             expirationTime: options.expiration,
+            numberOfInitializedDownloads: 0,
             creatorEmail,
         }
     }

package/src/internal/upload/apiService.ts

@@ -27,8 +27,9 @@ type PostDeleteNodesRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/d
 type PostDeleteNodesResponse = drivePaths['/drive/v2/volumes/{volumeID}/delete_multiple']['post']['responses']['200']['content']['application/json'];
 
 export class UploadAPIService {
-    constructor(private apiService: DriveAPIService) {
+    constructor(private apiService: DriveAPIService, private clientUid: string | undefined) {
         this.apiService = apiService;
+        this.clientUid = clientUid;
     }
 
     async checkAvailableHashes(parentNodeUid: string, hashes: string[]): Promise<{
@@ -46,7 +47,7 @@ export class UploadAPIService {
             PostCheckAvailableHashesResponse
         >(`drive/v2/volumes/${volumeId}/links/${parentNodeId}/checkAvailableHashes`, {
             Hashes: hashes,
-            ClientUID: null,
+            ClientUID: this.clientUid ? [this.clientUid] : null,
         });
 
         return {
@@ -64,7 +65,6 @@ export class UploadAPIService {
         armoredEncryptedName: string,
         hash: string,
         mediaType: string,
-        clientUID?: string,
         intendedUploadSize?: number,
         armoredNodeKey: string,
         armoredNodePassphrase: string,
@@ -85,7 +85,7 @@ export class UploadAPIService {
             Name: node.armoredEncryptedName,
             Hash: node.hash,
             MIMEType: node.mediaType,
-            ClientUID: node.clientUID || null,
+            ClientUID: this.clientUid || null,
             IntendedUploadSize: node.intendedUploadSize || null,
             NodeKey: node.armoredNodeKey,
             NodePassphrase: node.armoredNodePassphrase,
@@ -103,7 +103,6 @@ export class UploadAPIService {
 
     async createDraftRevision(nodeUid: string, revision: {
         currentRevisionUid: string,
-        clientUID?: string,
         intendedUploadSize?: number,
     }): Promise<{
         nodeRevisionUid: string,
@@ -116,7 +115,7 @@ export class UploadAPIService {
             PostCreateDraftRevisionResponse
         >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions`, {
             CurrentRevisionID: currentRevisionId,
-            ClientUID: revision.clientUID || null,
+            ClientUID: this.clientUid || null,
             IntendedUploadSize: revision.intendedUploadSize || null,
         });
 

package/src/internal/upload/index.ts

@@ -4,14 +4,14 @@ import { DriveCrypto } from "../../crypto";
 import { UploadAPIService } from "./apiService";
 import { UploadCryptoService } from "./cryptoService";
 import { FileUploader, FileRevisionUploader } from "./fileUploader";
-import { NodesService, NodesEvents, SharesService } from "./interface";
+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();
 

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", () => {
@@ -145,7 +147,7 @@ describe("UploadManager", () => {
                     throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS, {
                         ConflictLinkID: "existingLinkId",
                         ConflictDraftRevisionID: "existingDraftRevisionId",
-                        ConflictDraftClientUID: "existingDraftClientUid",
+                        ConflictDraftClientUID: clientUid,
                     });
                 }
                 return {
@@ -156,7 +158,6 @@ describe("UploadManager", () => {
 
             const result = await manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
 
-            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
             expect(result).toEqual({
                 nodeUid: "newNode:nodeUid",
                 nodeRevisionUid: "newNode:nodeRevisionUid",
@@ -174,9 +175,69 @@ describe("UploadManager", () => {
                     hash: "newNode:hash",
                 },
             });
+            expect(apiService.deleteDraft).toHaveBeenCalledTimes(1);
             expect(apiService.deleteDraft).toHaveBeenCalledWith("volumeId~existingLinkId");
         });
 
+        it("should not delete existing draft if client UID does not match", async () => {
+            let firstCall = true;
+            apiService.createDraft = jest.fn().mockImplementation(() => {
+                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",
+                };
+            });
+
+            const promise = manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
+
+            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 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 (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",
+                };
+            });
+
+            const promise = manager.createDraftNode("volumeId~parentUid", "name", {} as UploadMetadata);
+
+            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 error when deleting existing draft", async () => {
             let firstCall = true;
             apiService.createDraft = jest.fn().mockImplementation(() => {
@@ -185,7 +246,7 @@ describe("UploadManager", () => {
                     throw new ValidationError("Draft already exists", ErrorCode.ALREADY_EXISTS, {
                         ConflictLinkID: "existingLinkId",
                         ConflictDraftRevisionID: "existingDraftRevisionId",
-                        ConflictDraftClientUID: "existingDraftClientUid",
+                        ConflictDraftClientUID: clientUid,
                     });
                 }
                 return {
@@ -280,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 () => {
@@ -320,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");
         });
     });
 });