@protontech/drive-sdk 0.14.0 → 0.14.2

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

@@ -6,9 +6,10 @@ import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
 import { UploadManager } from './manager';
 import { NodeCrypto } from './interface';
+import { mergeUint8Arrays } from '../utils';
 
-const MOCK_BLOCK_HASH = new Uint8Array(32).fill(1);
-const MOCK_VERIFICATION_TOKEN = new Uint8Array(16).fill(2);
+const MOCK_BLOCK_HASH = new Uint8Array(32).fill(4);
+const MOCK_VERIFICATION_TOKEN = new Uint8Array(16).fill(5);
 
 function createStream(bytes: number[]): ReadableStream<Uint8Array> {
     return new ReadableStream({
@@ -108,7 +109,7 @@ describe('SmallFileUploader', () => {
                 encryptedData: new Uint8Array(thumbnail.thumbnail),
                 originalSize: thumbnail.thumbnail.length,
                 encryptedSize: thumbnail.thumbnail.length + 100,
-                hash: 'thumbnailHash',
+                hashPromise: Promise.resolve(new Uint8Array(32).fill(thumbnail.type)),
             })),
             encryptBlock: jest.fn().mockImplementation(mockEncryptBlock),
             verifyBlock: jest.fn().mockResolvedValue({ verificationToken: MOCK_VERIFICATION_TOKEN }),
@@ -138,7 +139,6 @@ describe('SmallFileUploader', () => {
     function createUploader() {
         return new SmallFileUploader(
             telemetry,
-            apiService,
             cryptoService,
             uploadManager,
             metadata,
@@ -157,24 +157,13 @@ describe('SmallFileUploader', () => {
             const uploader = createUploader();
             const stream = createStream([1, 2, 3]);
 
-            const controller = await uploader.uploadFromStream(stream, thumbnails, onProgress);
-            const result = await controller.completion();
+            const result = await uploader.upload(stream, thumbnails, onProgress);
 
             expect(uploadManager.generateNewFileCrypto).toHaveBeenCalledWith(parentFolderUid, name);
             expect(uploadManager.uploadFile).toHaveBeenCalledTimes(1);
             expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
             expect(onProgress).toHaveBeenCalledWith(metadata.expectedSize);
         });
-
-        it('should throw if upload already started', async () => {
-            const uploader = createUploader();
-            const stream = createStream([1, 2, 3]);
-
-            await uploader.uploadFromStream(stream, thumbnails, onProgress);
-            await expect(uploader.uploadFromStream(stream, thumbnails, onProgress)).rejects.toThrow(
-                'Upload already started',
-            );
-        });
     });
 
     describe('buildPayloads (via upload flow)', () => {
@@ -186,8 +175,7 @@ describe('SmallFileUploader', () => {
                 { type: ThumbnailType.Type2, thumbnail: new Uint8Array([30, 40, 50]) },
             ];
 
-            await uploader.uploadFromStream(stream, thumbnails, undefined);
-            await (uploader as any).controller.completion();
+            await uploader.upload(stream, thumbnails, undefined);
 
             expect(uploadManager.uploadFile).toHaveBeenCalledWith(
                 parentFolderUid,
@@ -203,8 +191,16 @@ describe('SmallFileUploader', () => {
                     verificationToken: MOCK_VERIFICATION_TOKEN,
                 }),
                 [
-                    { type: ThumbnailType.Type1, encryptedData: expect.any(Uint8Array) },
-                    { type: ThumbnailType.Type2, encryptedData: expect.any(Uint8Array) },
+                    {
+                        type: ThumbnailType.Type1,
+                        encryptedData: expect.any(Uint8Array),
+                        blockHash: new Uint8Array(32).fill(ThumbnailType.Type1),
+                    },
+                    {
+                        type: ThumbnailType.Type2,
+                        encryptedData: expect.any(Uint8Array),
+                        blockHash: new Uint8Array(32).fill(ThumbnailType.Type2),
+                    },
                 ],
             );
 
@@ -212,7 +208,11 @@ describe('SmallFileUploader', () => {
             expect(cryptoService.encryptThumbnail).toHaveBeenCalledTimes(2);
             expect(cryptoService.commitFile).toHaveBeenCalledWith(
                 expect.anything(),
-                MOCK_BLOCK_HASH,
+                mergeUint8Arrays([
+                    new Uint8Array(32).fill(ThumbnailType.Type1),
+                    new Uint8Array(32).fill(ThumbnailType.Type2),
+                    MOCK_BLOCK_HASH,
+                ]),
                 expect.any(String),
             );
         });
@@ -223,8 +223,7 @@ describe('SmallFileUploader', () => {
             metadata.expectedSize = content.length;
             const stream = createStream(content);
 
-            await uploader.uploadFromStream(stream, [], undefined);
-            await (uploader as any).controller.completion();
+            await uploader.upload(stream, [], undefined);
 
             expect(cryptoService.encryptBlock).toHaveBeenCalledWith(
                 expect.any(Function),
@@ -241,8 +240,7 @@ describe('SmallFileUploader', () => {
             ];
             const stream = createStream([1, 2, 3]);
 
-            await uploader.uploadFromStream(stream, thumbnails, undefined);
-            await (uploader as any).controller.completion();
+            await uploader.upload(stream, thumbnails, undefined);
 
             expect(cryptoService.encryptThumbnail).toHaveBeenCalledWith(
                 expect.objectContaining({
@@ -259,8 +257,7 @@ describe('SmallFileUploader', () => {
             const uploader = createUploader();
             const stream = createStream([1, 2, 3]);
 
-            await uploader.uploadFromStream(stream, [], undefined);
-            await (uploader as any).controller.completion();
+            await uploader.upload(stream, [], undefined);
 
             const [nodeKeys, manifest, extendedAttributes] = (cryptoService.commitFile as jest.Mock).mock.calls[0];
             expect(manifest).toEqual(MOCK_BLOCK_HASH);
@@ -275,10 +272,10 @@ describe('SmallFileUploader', () => {
             metadata.expectedSize = 5;
             const stream = createStream([1, 2, 3]); // only 3 bytes
 
-            const controller = await uploader.uploadFromStream(stream, [], undefined);
+            const promise = uploader.upload(stream, [], undefined);
 
-            await expect(controller.completion()).rejects.toThrow(IntegrityError);
-            await expect(controller.completion()).rejects.toMatchObject({
+            await expect(promise).rejects.toThrow(IntegrityError);
+            await expect(promise).rejects.toMatchObject({
                 debug: { actual: 3, expected: 5 },
             });
         });
@@ -288,10 +285,10 @@ describe('SmallFileUploader', () => {
             metadata.expectedSha1 = 'a'.repeat(40); // wrong sha1
             const stream = createStream([1, 2, 3]);
 
-            const controller = await uploader.uploadFromStream(stream, [], undefined);
+            const promise = uploader.upload(stream, [], undefined);
 
-            await expect(controller.completion()).rejects.toThrow(IntegrityError);
-            await expect(controller.completion()).rejects.toMatchObject({
+            await expect(promise).rejects.toThrow(IntegrityError);
+            await expect(promise).rejects.toMatchObject({
                 debug: expect.objectContaining({
                     expectedSha1: 'a'.repeat(40),
                 }),
@@ -306,8 +303,7 @@ describe('SmallFileUploader', () => {
             const stream = createStream([]);
             const onProgress = jest.fn();
 
-            const controller = await uploader.uploadFromStream(stream, [], onProgress);
-            const result = await controller.completion();
+            const result = await uploader.upload(stream, [], onProgress);
 
             expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
             expect(cryptoService.encryptBlock).not.toHaveBeenCalled();
@@ -430,7 +426,6 @@ describe('SmallFileRevisionUploader', () => {
     function createUploader() {
         return new SmallFileRevisionUploader(
             telemetry,
-            apiService,
             cryptoService,
             uploadManager,
             metadata,
@@ -444,8 +439,7 @@ describe('SmallFileRevisionUploader', () => {
         const uploader = createUploader();
         const stream = createStream([1, 2, 3]);
 
-        const controller = await uploader.uploadFromStream(stream, [], undefined);
-        const result = await controller.completion();
+        const result = await uploader.upload(stream, [], undefined);
 
         expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
         expect(cryptoService.encryptBlock).toHaveBeenCalledWith(expect.any(Function), expect.anything(), Uint8Array.from([1, 2, 3]), 0);
@@ -471,8 +465,7 @@ describe('SmallFileRevisionUploader', () => {
         const uploader = createUploader();
         const stream = createStream([]);
 
-        const controller = await uploader.uploadFromStream(stream, [], undefined);
-        const result = await controller.completion();
+        const result = await uploader.upload(stream, [], undefined);
 
         expect(result).toEqual({ nodeUid: 'nodeUid', nodeRevisionUid: 'nodeRevisionUid' });
         expect(cryptoService.encryptBlock).not.toHaveBeenCalled();

package/src/internal/upload/smallFileUploader.ts

@@ -3,12 +3,11 @@ import { AbortError, IntegrityError } from '../../errors';
 import { Logger, Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
 import { getErrorMessage } from '../errors';
 import { generateFileExtendedAttributes } from '../nodes';
-import { UploadAPIService } from './apiService';
-import { BlockVerifier, verifyBlockWithContentKey } from './blockVerifier';
+import { mergeUint8Arrays } from '../utils';
+import { verifyBlockWithContentKey } from './blockVerifier';
 import { UploadCryptoService } from './cryptoService';
 import { UploadDigests } from './digests';
-import { Uploader } from './fileUploader';
-import { NodeRevisionDraft, NodeCrypto } from './interface';
+import { NodeCrypto } from './interface';
 import { UploadManager } from './manager';
 import { readStreamToUint8Array } from './streamReader';
 import { MAX_BLOCK_ENCRYPTION_RETRIES } from './streamUploader';
@@ -25,34 +24,23 @@ export type NodeKeys = {
  * Base uploader for small file and small revision uploads.
  * Shares the single-request flow: read content, get node crypto, encrypt, then call API.
  */
-abstract class SmallUploader extends Uploader {
+abstract class SmallUploader {
     protected logger: Logger;
+    protected abortController: AbortController;
 
     constructor(
-        telemetry: UploadTelemetry,
-        apiService: UploadAPIService,
-        cryptoService: UploadCryptoService,
-        manager: UploadManager,
-        metadata: UploadMetadata,
-        onFinish: () => void,
-        signal: AbortSignal | undefined,
+        protected telemetry: UploadTelemetry,
+        protected cryptoService: UploadCryptoService,
+        protected manager: UploadManager,
+        protected metadata: UploadMetadata,
+        protected onFinish: () => void,
+        protected signal: AbortSignal | undefined,
     ) {
-        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
         this.logger = telemetry.getLoggerForSmallUpload();
-    }
-    protected async createRevisionDraft(): Promise<{
-        revisionDraft: NodeRevisionDraft;
-        blockVerifier: BlockVerifier;
-    }> {
-        throw new Error('Small upload does not use revision draft');
+        this.abortController = new AbortController();
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    protected async deleteRevisionDraft(revisionDraft: NodeRevisionDraft): Promise<void> {
-        throw new Error('Small upload does not use revision draft');
-    }
-
-    protected async startUpload(
+    async upload(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -105,7 +93,8 @@ abstract class SmallUploader extends Uploader {
             this.encryptThumbnails(nodeKeys, thumbnails),
             this.encryptContentBlock(nodeKeys, content.data),
         ]);
-        const commitPayload = await this.encryptCommitPayload(nodeKeys, content.sha1, encryptedBlock);
+        const manifest = await this.getManifest(encryptedBlock, encryptedThumbnails);
+        const commitPayload = await this.encryptCommitPayload(nodeKeys, content.sha1, manifest);
 
         return {
             commitPayload,
@@ -147,12 +136,22 @@ abstract class SmallUploader extends Uploader {
     private async encryptThumbnails(
         nodeKeys: NodeKeys,
         thumbnails: Thumbnail[],
-    ): Promise<{ type: ThumbnailType; encryptedData: Uint8Array<ArrayBuffer> }[]> {
+    ): Promise<
+        {
+            type: ThumbnailType;
+            encryptedData: Uint8Array<ArrayBuffer>;
+            blockHash: Uint8Array<ArrayBuffer>;
+        }[]
+    > {
         const result = [];
         for (const thumbnail of thumbnails) {
             this.logger.debug(`Encrypting thumbnail ${thumbnail.type}`);
             const enc = await this.cryptoService.encryptThumbnail(nodeKeys, thumbnail);
-            result.push({ type: thumbnail.type, encryptedData: enc.encryptedData });
+            result.push({
+                type: thumbnail.type,
+                encryptedData: enc.encryptedData,
+                blockHash: await enc.hashPromise,
+            });
         }
         return result;
     }
@@ -228,21 +227,35 @@ abstract class SmallUploader extends Uploader {
         };
     }
 
-    private async encryptCommitPayload(
-        nodeKeys: NodeKeys,
-        contentSha1: string,
+    private async getManifest(
         encryptedBlock:
             | {
                   blockHash: Uint8Array<ArrayBuffer>;
               }
             | undefined,
+        encryptedThumbnails: {
+            type: ThumbnailType;
+            blockHash: Uint8Array<ArrayBuffer>;
+        }[],
+    ): Promise<Uint8Array<ArrayBuffer>> {
+        encryptedThumbnails.sort((a, b) => a.type - b.type);
+        const hashes = [
+            ...(await Promise.all(encryptedThumbnails.map(({ blockHash }) => blockHash))),
+            ...(encryptedBlock ? [encryptedBlock.blockHash] : []),
+        ];
+        return mergeUint8Arrays(hashes);
+    }
+
+    private async encryptCommitPayload(
+        nodeKeys: NodeKeys,
+        contentSha1: string,
+        manifest: Uint8Array<ArrayBuffer>,
     ): Promise<{
         armoredManifestSignature: string;
         armoredExtendedAttributes: string;
     }> {
         this.logger.debug(`Preparing commit payload`);
 
-        const manifest = encryptedBlock ? encryptedBlock.blockHash : new Uint8Array(0);
         const extendedAttributes = generateFileExtendedAttributes(
             {
                 modificationTime: this.metadata.modificationTime,
@@ -266,7 +279,6 @@ abstract class SmallUploader extends Uploader {
 export class SmallFileUploader extends SmallUploader {
     constructor(
         telemetry: UploadTelemetry,
-        apiService: UploadAPIService,
         cryptoService: UploadCryptoService,
         manager: UploadManager,
         metadata: UploadMetadata,
@@ -275,7 +287,7 @@ export class SmallFileUploader extends SmallUploader {
         private parentFolderUid: string,
         private name: string,
     ) {
-        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        super(telemetry, cryptoService, manager, metadata, onFinish, signal);
         this.parentFolderUid = parentFolderUid;
         this.name = name;
     }
@@ -317,7 +329,6 @@ export class SmallFileUploader extends SmallUploader {
 export class SmallFileRevisionUploader extends SmallUploader {
     constructor(
         telemetry: UploadTelemetry,
-        apiService: UploadAPIService,
         cryptoService: UploadCryptoService,
         manager: UploadManager,
         metadata: UploadMetadata,
@@ -325,7 +336,7 @@ export class SmallFileRevisionUploader extends SmallUploader {
         signal: AbortSignal | undefined,
         private nodeUid: string,
     ) {
-        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        super(telemetry, cryptoService, manager, metadata, onFinish, signal);
         this.nodeUid = nodeUid;
     }
 

package/src/protonDriveClient.ts

@@ -232,7 +232,7 @@ export class ProtonDriveClient {
                 const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url);
                 this.logger.info(`Authenticating public link token ${token}`);
 
-                const { httpClient, shareKey, rootUid, publicRole } = await this.publicSessionManager.auth(
+                const { httpClient, shareKey, rootUid, publicRole, session } = await this.publicSessionManager.auth(
                     token,
                     urlPassword,
                     customPassword,
@@ -250,6 +250,7 @@ export class ProtonDriveClient {
                     publicRootNodeUid: rootUid,
                     isAnonymousContext,
                     publicRole,
+                    session,
                 });
             },
         };

package/src/protonDrivePublicLinkClient.ts

@@ -33,6 +33,7 @@ import {
 import { initDownloadModule } from './internal/download';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharingPublicModule, UnauthDriveAPIService } from './internal/sharingPublic';
+import { SharingPublicLinkSession } from './internal/sharingPublic/session';
 import { initUploadModule } from './internal/upload';
 import { NullFeatureFlagProvider } from './featureFlags';
 import { NodesSecurityScanResult } from './internal/sharingPublic/nodesSecurity';
@@ -56,6 +57,7 @@ export class ProtonDrivePublicLinkClient {
     private sharingPublic: ReturnType<typeof initSharingPublicModule>;
     private download: ReturnType<typeof initDownloadModule>;
     private upload: ReturnType<typeof initUploadModule>;
+    private session: SharingPublicLinkSession;
 
     public experimental: {
         /**
@@ -86,6 +88,14 @@ export class ProtonDrivePublicLinkClient {
          * Experimental feature to create a document (Proton Docs or Proton Sheets) in the public link.
          */
         createDocument: (parentNodeUid: NodeOrUid, documentName: string, documentType: 1 | 2) => Promise<MaybeNode>;
+        /**
+         * Experimental feature to get the session info for the public link.
+         *
+         * This helper is used to set the session for metrics requests.
+         * Returns the session UID and access token that were obtained during
+         * authentication.
+         */
+        getSessionInfo: () => { uid: string; accessToken: string | undefined };
     };
 
     constructor({
@@ -102,6 +112,7 @@ export class ProtonDrivePublicLinkClient {
         publicRootNodeUid,
         isAnonymousContext,
         publicRole,
+        session,
     }: {
         httpClient: ProtonDriveHTTPClient;
         account: ProtonDriveAccount;
@@ -116,6 +127,7 @@ export class ProtonDrivePublicLinkClient {
         publicRootNodeUid: string;
         isAnonymousContext: boolean;
         publicRole: MemberRole;
+        session: SharingPublicLinkSession;
     }) {
         if (!telemetry) {
             telemetry = new Telemetry();
@@ -124,6 +136,7 @@ export class ProtonDrivePublicLinkClient {
             featureFlagProvider = new NullFeatureFlagProvider();
         }
         this.logger = telemetry.getLogger('publicLink-interface');
+        this.session = session;
 
         // Use only in memory cache for public link as there are no events to keep it up to date if persisted.
         const entitiesCache = new MemoryCache<string>();
@@ -197,7 +210,7 @@ export class ProtonDrivePublicLinkClient {
                 if (!keys.passphrase) {
                     throw new Error('Node does not have a passphrase');
                 }
-                return keys.passphrase
+                return keys.passphrase;
             },
             scanHashes: async (hashes: string[]): Promise<NodesSecurityScanResult> => {
                 this.logger.debug(`Scanning ${hashes.length} hashes`);
@@ -210,9 +223,17 @@ export class ProtonDrivePublicLinkClient {
             ): Promise<MaybeNode> => {
                 this.logger.debug(`Creating document in ${getUid(parentNodeUid)}`);
                 return convertInternalNodePromise(
-                    this.sharingPublic.nodes.management.createDocument(getUid(parentNodeUid), documentName, documentType),
+                    this.sharingPublic.nodes.management.createDocument(
+                        getUid(parentNodeUid),
+                        documentName,
+                        documentType,
+                    ),
                 );
             },
+            getSessionInfo: (): { uid: string; accessToken: string | undefined } => {
+                this.logger.debug(`Getting session info`);
+                return this.session.session;
+            },
         };
     }