@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/upload/manager.ts

@@ -1,13 +1,13 @@
-import { c } from "ttag";
+import { c } from 'ttag';
 
-import { Logger, MemberRole, NodeType, ProtonDriveTelemetry, resultOk, Revision, RevisionState, UploadMetadata } from "../../interface";
-import { ValidationError, NodeAlreadyExistsValidationError } from "../../errors";
-import { ErrorCode } from "../apiService";
-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";
+import { Logger, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
+import { ValidationError, NodeAlreadyExistsValidationError } from '../../errors';
+import { ErrorCode } from '../apiService';
+import { generateFileExtendedAttributes } from '../nodes';
+import { UploadAPIService } from './apiService';
+import { UploadCryptoService } from './cryptoService';
+import { NodeRevisionDraft, NodesService, NodeCrypto } from './interface';
+import { makeNodeUid, splitNodeUid } from '../uids';
 
 /**
  * UploadManager is responsible for creating and deleting draft nodes
@@ -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> {
@@ -74,8 +75,8 @@ export class UploadManager {
         metadata: UploadMetadata,
         generatedNodeCrypto: NodeCrypto,
     ): Promise<{
-        nodeUid: string,
-        nodeRevisionUid: string,
+        nodeUid: string;
+        nodeRevisionUid: string;
     }> {
         try {
             const result = await this.apiService.createDraft(parentFolderUid, {
@@ -87,9 +88,9 @@ export class UploadManager {
                 armoredNodePassphrase: generatedNodeCrypto.nodeKeys.encrypted.armoredPassphrase,
                 armoredNodePassphraseSignature: generatedNodeCrypto.nodeKeys.encrypted.armoredPassphraseSignature,
                 base64ContentKeyPacket: generatedNodeCrypto.contentKey.encrypted.base64ContentKeyPacket,
-                armoredContentKeyPacketSignature: generatedNodeCrypto.contentKey.encrypted.armoredContentKeyPacketSignature,
+                armoredContentKeyPacketSignature:
+                    generatedNodeCrypto.contentKey.encrypted.armoredContentKeyPacketSignature,
                 signatureEmail: generatedNodeCrypto.signatureAddress.email,
-                // FIXME: client UID
             });
             return result;
         } catch (error: unknown) {
@@ -97,22 +98,39 @@ export class UploadManager {
                 if (error.code === ErrorCode.ALREADY_EXISTS) {
                     this.logger.info(`Node with given name already exists`);
 
-                    const typedDetails = error.details as {
-                        ConflictLinkID: string,
-                        ConflictRevisionID?: string,
-                        ConflictDraftRevisionID?: string,
-                        ConflictDraftClientUID?: string,
-                    } | undefined;
+                    const typedDetails = error.details as
+                        | {
+                              ConflictLinkID: string;
+                              ConflictRevisionID?: string;
+                              ConflictDraftRevisionID?: string;
+                              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) {
-                        const existingDraftNodeUid = makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID);
+                    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.
@@ -120,11 +138,25 @@ export class UploadManager {
                             this.logger.error('Failed to delete existing draft node', deleteDraftError);
                         }
                         if (!deleteFailed) {
-                            return this.createDraftOnAPI(parentFolderUid, parentHashKey, name, metadata, generatedNodeCrypto);
+                            return this.createDraftOnAPI(
+                                parentFolderUid,
+                                parentHashKey,
+                                name,
+                                metadata,
+                                generatedNodeCrypto,
+                            );
                         }
                     }
 
-                    const existingNodeUid = typedDetails ? makeNodeUid(splitNodeUid(parentFolderUid).volumeId, typedDetails.ConflictLinkID) : undefined;
+                    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
                     // that includes the available name the client can use.
@@ -132,6 +164,7 @@ export class UploadManager {
                         error.message,
                         error.code,
                         existingNodeUid,
+                        !!typedDetails?.ConflictDraftRevisionID,
                     );
                 }
             }
@@ -210,7 +243,7 @@ export class UploadManager {
                 contentKeyPacketSessionKey: nodeKeys.contentKeyPacketSessionKey,
                 signatureAddress: signatureAddress,
             },
-        }
+        };
     }
 
     async deleteDraftRevision(nodeRevisionUid: string): Promise<void> {
@@ -227,65 +260,26 @@ export class UploadManager {
     async commitDraft(
         nodeRevisionDraft: NodeRevisionDraft,
         manifest: Uint8Array,
-        metadata: UploadMetadata,
+        _metadata: UploadMetadata,
         extendedAttributes: {
-            modificationTime?: Date,
-            size?: number,
-            blockSizes?: number[],
+            modificationTime?: Date;
+            size?: number;
+            blockSizes?: number[];
             digests?: {
-                sha1?: string,
-            },
+                sha1?: string;
+            };
         },
-        encryptedSize: number,
     ): Promise<void> {
         const generatedExtendedAttributes = generateFileExtendedAttributes(extendedAttributes);
-        const nodeCommitCrypto = await this.cryptoService.commitFile(nodeRevisionDraft.nodeKeys, manifest, generatedExtendedAttributes);
+        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);
         }
     }
 }
@@ -299,7 +293,7 @@ function splitExtension(filename = ''): [string, string] {
         return [filename, ''];
     }
     return [filename.slice(0, endIdx), filename.slice(endIdx + 1)];
-};
+}
 
 /**
  * Join a filename into `name (index).extension`

package/src/internal/upload/queue.ts

@@ -2,13 +2,13 @@ import { waitForCondition } from '../wait';
 
 /**
  * A queue that limits the number of concurrent uploads.
- * 
+ *
  * This is used to limit the number of concurrent uploads to avoid
  * overloading the server, or get rate limited.
- * 
+ *
  * Each file upload consumes memory and is limited by the number of
  * concurrent block uploads for each file.
- * 
+ *
  * This queue is straitforward and does not have any priority mechanism
  * or other features, such as limiting total number of blocks being
  * uploaded. That is something we want to add in the future to be

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

@@ -12,7 +12,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,
@@ -25,7 +30,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);
 }
 
@@ -137,23 +147,19 @@ describe('StreamUploader', () => {
 
             const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
             expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
-            expect(uploadManager.commitDraft).toHaveBeenCalledWith(
-                revisionDraft,
-                expect.anything(),
-                metadata,
-                {
-                    size: metadata.expectedSize,
-                    blockSizes: metadata.expectedSize ? [
-                        ...Array(numberOfExpectedBlocks - 1).fill(FILE_CHUNK_SIZE),
-                        metadata.expectedSize % FILE_CHUNK_SIZE
-                    ] : [],
-                    modificationTime: undefined,
-                    digests: {
-                        sha1: expect.anything(),
-                    }
+            expect(uploadManager.commitDraft).toHaveBeenCalledWith(revisionDraft, expect.anything(), metadata, {
+                size: metadata.expectedSize,
+                blockSizes: metadata.expectedSize
+                    ? [
+                          ...Array(numberOfExpectedBlocks - 1).fill(FILE_CHUNK_SIZE),
+                          metadata.expectedSize % FILE_CHUNK_SIZE,
+                      ]
+                    : [],
+                modificationTime: undefined,
+                digests: {
+                    sha1: expect.anything(),
                 },
-                metadata.expectedSize + numberOfExpectedBlocks * BLOCK_ENCRYPTION_OVERHEAD,
-            );
+            });
             expect(telemetry.uploadFinished).toHaveBeenCalledTimes(1);
             expect(telemetry.uploadFinished).toHaveBeenCalledWith('revisionUid', metadata.expectedSize + thumbnailSize);
             expect(telemetry.uploadFailed).not.toHaveBeenCalled();
@@ -161,7 +167,11 @@ describe('StreamUploader', () => {
             expect(onFinish).toHaveBeenCalledWith(false);
         };
 
-        const verifyFailure = async (error: string, uploadedBytes: number | undefined, expectedSize = metadata.expectedSize) => {
+        const verifyFailure = async (
+            error: string,
+            uploadedBytes: number | undefined,
+            expectedSize = metadata.expectedSize,
+        ) => {
             const promise = uploader.start(stream, thumbnails, onProgress);
             await expect(promise).rejects.toThrow(error);
 
@@ -190,7 +200,7 @@ describe('StreamUploader', () => {
                 {
                     type: ThumbnailType.Type1,
                     thumbnail: new Uint8Array(1024),
-                }
+                },
             ];
             thumbnailSize = thumbnails.reduce((acc, thumbnail) => acc + thumbnail.thumbnail.length, 0);
             stream = new ReadableStream({
@@ -205,7 +215,7 @@ describe('StreamUploader', () => {
             });
         });
 
-        it("should upload successfully", async () => {
+        it('should upload successfully', async () => {
             await verifySuccess();
             expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(1);
             expect(apiService.uploadBlock).toHaveBeenCalledTimes(4); // 3 blocks + 1 thumbnail
@@ -214,7 +224,7 @@ describe('StreamUploader', () => {
             await verifyOnProgress([thumbnailSize, 4 * 1024 * 1024, 4 * 1024 * 1024, 2 * 1024 * 1024]);
         });
 
-        it("should upload successfully empty file without thumbnail", async () => {
+        it('should upload successfully empty file without thumbnail', async () => {
             metadata = {
                 expectedSize: 0,
             } as UploadMetadata;
@@ -243,7 +253,7 @@ describe('StreamUploader', () => {
             await verifyOnProgress([]);
         });
 
-        it("should upload successfully empty file with thumbnail", async () => {
+        it('should upload successfully empty file with thumbnail', async () => {
             metadata = {
                 expectedSize: 0,
             } as UploadMetadata;
@@ -396,7 +406,7 @@ describe('StreamUploader', () => {
                             hash: 'blockHash',
                             armoredSignature: 'signature',
                             verificationToken: 'verificationToken',
-                        }
+                        },
                     ],
                 },
             );
@@ -421,9 +431,12 @@ describe('StreamUploader', () => {
             });
 
             it('should report block verification error when retry helped', async () => {
-                blockVerifier.verifyBlock = jest.fn().mockRejectedValueOnce(new IntegrityError('Block verification error')).mockResolvedValue({
-                    verificationToken: new Uint8Array(),
-                });
+                blockVerifier.verifyBlock = jest
+                    .fn()
+                    .mockRejectedValueOnce(new IntegrityError('Block verification error'))
+                    .mockResolvedValue({
+                        verificationToken: new Uint8Array(),
+                    });
                 await verifySuccess();
                 expect(telemetry.logBlockVerificationError).toHaveBeenCalledWith(true);
             });