@protontech/drive-sdk 0.0.13 → 0.1.0

package/src/internal/upload/manager.ts

@@ -1,12 +1,12 @@
 import { c } from "ttag";
 
-import { Logger, MemberRole, NodeType, ProtonDriveTelemetry, resultOk, Revision, RevisionState, UploadMetadata } from "../../interface";
+import { Logger, ProtonDriveTelemetry, UploadMetadata } from "../../interface";
 import { ValidationError, NodeAlreadyExistsValidationError } from "../../errors";
 import { ErrorCode } from "../apiService";
-import { DecryptedNode, generateFileExtendedAttributes } from "../nodes";
+import { generateFileExtendedAttributes } from "../nodes";
 import { UploadAPIService } from "./apiService";
 import { UploadCryptoService } from "./cryptoService";
-import { NodeRevisionDraft, NodesService, NodesEvents, NodeCrypto } from "./interface";
+import { NodeRevisionDraft, NodesService, NodeCrypto } from "./interface";
 import { makeNodeUid, splitNodeUid } from "../uids";
 
 /**
@@ -22,12 +22,13 @@ export class UploadManager {
         private apiService: UploadAPIService,
         private cryptoService: UploadCryptoService,
         private nodesService: NodesService,
-        private nodesEvents: NodesEvents,
+        private clientUid: string | undefined,
     ) {
         this.logger = telemetry.getLogger('upload');
         this.apiService = apiService;
         this.cryptoService = cryptoService;
         this.nodesService = nodesService;
+        this.clientUid = clientUid;
     }
 
     async createDraftNode(parentFolderUid: string, name: string, metadata: UploadMetadata): Promise<NodeRevisionDraft> {
@@ -89,7 +90,6 @@ export class UploadManager {
                 base64ContentKeyPacket: generatedNodeCrypto.contentKey.encrypted.base64ContentKeyPacket,
                 armoredContentKeyPacketSignature: generatedNodeCrypto.contentKey.encrypted.armoredContentKeyPacketSignature,
                 signatureEmail: generatedNodeCrypto.signatureAddress.email,
-                // FIXME: client UID
             });
             return result;
         } catch (error: unknown) {
@@ -104,15 +104,23 @@ export class UploadManager {
                         ConflictDraftClientUID?: string,
                     } | undefined;
 
+                    // If the client doesn't specify the client UID, it should
+                    // never be considered own draft.
+                    const isOwnDraftConflict = (
+                        typedDetails?.ConflictDraftRevisionID &&
+                        this.clientUid &&
+                        typedDetails?.ConflictDraftClientUID === this.clientUid
+                    );
+
                     // 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 (typedDetails?.ConflictDraftRevisionID) {
+                    if (typedDetails?.ConflictDraftRevisionID && (isOwnDraftConflict || metadata.overrideExistingDraftByOtherClient)) {
                         const existingDraftNodeUid = makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID);
 
                         let deleteFailed = false;
                         try {
-                            this.logger.warn(`Deleting existing draft node ${existingDraftNodeUid}`);
+                            this.logger.warn(`Deleting existing draft node ${existingDraftNodeUid} by ${typedDetails.ConflictDraftClientUID}`);
                             await this.apiService.deleteDraft(existingDraftNodeUid);
                         } catch (deleteDraftError: unknown) {
                             // Do not throw, let throw the conflict error.
@@ -124,6 +132,10 @@ export class UploadManager {
                         }
                     }
 
+                    if (isOwnDraftConflict) {
+                        this.logger.warn(`Existing draft conflict by another client ${typedDetails.ConflictDraftClientUID}`);
+                    }
+
                     const existingNodeUid = typedDetails ? makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID) : undefined;
 
                     // If there is existing node, return special error
@@ -132,6 +144,7 @@ export class UploadManager {
                         error.message,
                         error.code,
                         existingNodeUid,
+                        !!typedDetails?.ConflictDraftRevisionID,
                     );
                 }
             }
@@ -227,7 +240,7 @@ export class UploadManager {
     async commitDraft(
         nodeRevisionDraft: NodeRevisionDraft,
         manifest: Uint8Array,
-        metadata: UploadMetadata,
+        _metadata: UploadMetadata,
         extendedAttributes: {
             modificationTime?: Date,
             size?: number,
@@ -236,56 +249,13 @@ export class UploadManager {
                 sha1?: string,
             },
         },
-        encryptedSize: number,
     ): Promise<void> {
         const generatedExtendedAttributes = generateFileExtendedAttributes(extendedAttributes);
         const nodeCommitCrypto = await this.cryptoService.commitFile(nodeRevisionDraft.nodeKeys, manifest, generatedExtendedAttributes);
         await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
-
-        const activeRevision = resultOk<Revision, Error>({
-            uid: nodeRevisionDraft.nodeRevisionUid,
-            state: RevisionState.Active,
-            creationTime: new Date(),
-            storageSize: encryptedSize,
-            contentAuthor: resultOk(nodeCommitCrypto.signatureEmail),
-            claimedSize: metadata.expectedSize,
-            claimedModificationTime: extendedAttributes.modificationTime,
-            claimedDigests: {
-                sha1: extendedAttributes.digests?.sha1,
-            },
-        });
-        if (nodeRevisionDraft.newNodeInfo) {
-            const node: DecryptedNode = {
-                // Internal metadata
-                hash: nodeRevisionDraft.newNodeInfo.hash,
-                encryptedName: nodeRevisionDraft.newNodeInfo.encryptedName,
-
-                // Basic node metadata
-                uid: nodeRevisionDraft.nodeUid,
-                parentUid: nodeRevisionDraft.newNodeInfo.parentUid,
-                type: NodeType.File,
-                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),
-                nameAuthor: resultOk(nodeRevisionDraft.nodeKeys.signatureAddress.email),
-                name: resultOk(nodeRevisionDraft.newNodeInfo.name),
-
-                activeRevision,
-            }
-            await this.nodesEvents.nodeCreated(node);
-        } else {
-            await this.nodesEvents.nodeUpdated({
-                uid: nodeRevisionDraft.nodeUid,
-                activeRevision,
-            });
+        const node = await this.nodesService.getNode(nodeRevisionDraft.nodeUid);
+        if (node.parentUid) {
+            await this.nodesService.notifyChildCreated(node.parentUid);
         }
     }
 }

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

@@ -152,7 +152,6 @@ describe('StreamUploader', () => {
                         sha1: expect.anything(),
                     }
                 },
-                metadata.expectedSize + numberOfExpectedBlocks * BLOCK_ENCRYPTION_OVERHEAD,
             );
             expect(telemetry.uploadFinished).toHaveBeenCalledTimes(1);
             expect(telemetry.uploadFinished).toHaveBeenCalledWith('revisionUid', metadata.expectedSize + thumbnailSize);

package/src/internal/upload/streamUploader.ts

@@ -201,13 +201,11 @@ export class StreamUploader {
             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,
         );
     }