@protontech/drive-sdk 0.4.1 → 0.5.0

package/src/internal/sharingPublic/interface.ts

@@ -1,12 +1,3 @@
-// TODO: use them directly, or avoid them completely
-export type {
-    EncryptedNode,
-    EncryptedNodeFolderCrypto,
-    EncryptedNodeFileCrypto,
-    DecryptedNode,
-    DecryptedNodeKeys,
-} from '../nodes/interface';
-
 export interface EncryptedShareCrypto {
     base64UrlPasswordSalt: string;
     armoredKey: string;

package/src/internal/sharingPublic/nodes.ts

@@ -0,0 +1,37 @@
+import { Logger } from "../../interface";
+import { NodeAPIService } from "../nodes/apiService";
+import { NodesCache } from "../nodes/cache";
+import { NodesCryptoCache } from "../nodes/cryptoCache";
+import { NodesCryptoService } from "../nodes/cryptoService";
+import { NodesAccess } from "../nodes/nodesAccess";
+import { isProtonDocument, isProtonSheet } from "../nodes/mediaTypes";
+import { splitNodeUid } from "../uids";
+import { SharingPublicSharesManager } from "./shares";
+
+export class SharingPublicNodesAccess extends NodesAccess {
+    constructor(
+        logger: Logger,
+        apiService: NodeAPIService,
+        cache: NodesCache,
+        cryptoCache: NodesCryptoCache,
+        cryptoService: NodesCryptoService,
+        sharesService: SharingPublicSharesManager,
+        private url: string,
+        private token: string,
+    ) {
+        super(logger, apiService, cache, cryptoCache, cryptoService, sharesService);
+        this.token = token;
+    }
+
+    async getNodeUrl(nodeUid: string): Promise<string> {
+        const node = await this.getNode(nodeUid);
+        if (isProtonDocument(node.mediaType) || isProtonSheet(node.mediaType)) {
+            const { nodeId } = splitNodeUid(nodeUid);
+            const type = isProtonDocument(node.mediaType) ? 'doc' : 'sheet';
+            return `https://docs.proton.me/doc?type=${type}&mode=open-url&token=${this.token}&linkId=${nodeId}`;
+        }
+
+        // Public link doesn't support specific node URLs.
+        return this.url;
+    }
+}

package/src/internal/sharingPublic/session/apiService.ts

@@ -9,7 +9,7 @@ type PostPublicLinkAuthRequest = Extract<
     { content: object }
 >['content']['application/json'];
 type PostPublicLinkAuthResponse =
-        drivePaths['/drive/urls/{token}/auth']['post']['responses']['200']['content']['application/json'];
+    drivePaths['/drive/urls/{token}/auth']['post']['responses']['200']['content']['application/json'];
 
 /**
  * Provides API communication for managing public link session (not data).

package/src/internal/sharingPublic/session/session.ts

@@ -1,6 +1,6 @@
-import { SRPModule } from "../../../crypto";
-import { SharingPublicSessionAPIService } from "./apiService";
-import { PublicLinkInfo, PublicLinkSrpInfo } from "./interface";
+import { SRPModule } from '../../../crypto';
+import { SharingPublicSessionAPIService } from './apiService';
+import { PublicLinkInfo, PublicLinkSrpInfo } from './interface';
 
 /**
  * Session for a public link.

package/src/internal/sharingPublic/session/url.test.ts

@@ -9,7 +9,7 @@ describe('getTokenAndPasswordFromUrl', () => {
 
             expect(result).toEqual({
                 token: 'abc123',
-                password: 'def456'
+                password: 'def456',
             });
         });
 
@@ -19,7 +19,7 @@ describe('getTokenAndPasswordFromUrl', () => {
 
             expect(result).toEqual({
                 token: 'mytoken',
-                password: 'mypassword'
+                password: 'mypassword',
             });
         });
 
@@ -29,7 +29,7 @@ describe('getTokenAndPasswordFromUrl', () => {
 
             expect(result).toEqual({
                 token: 'token123',
-                password: 'password456'
+                password: 'password456',
             });
         });
     });

package/src/internal/sharingPublic/shares.ts

@@ -0,0 +1,86 @@
+import { PrivateKey } from '../../crypto';
+import { MetricVolumeType, ProtonDriveAccount } from '../../interface';
+import { splitNodeUid } from '../uids';
+import { SharingPublicAPIService } from './apiService';
+import { SharingPublicCryptoCache } from './cryptoCache';
+import { SharingPublicCryptoService } from './cryptoService';
+
+/**
+ * Provides high-level actions for managing public link share.
+ *
+ * The public link share manager provides the same interface as the code share
+ * service so it can be used in the same way in various modules that use shares.
+ */
+export class SharingPublicSharesManager {
+    private promisePublicLinkRoot?: Promise<{
+        rootIds: { volumeId: string; rootNodeId: string; rootNodeUid: string };
+        shareKey: PrivateKey;
+    }>;
+
+    constructor(
+        private apiService: SharingPublicAPIService,
+        private cryptoCache: SharingPublicCryptoCache,
+        private cryptoService: SharingPublicCryptoService,
+        private account: ProtonDriveAccount,
+        private token: string,
+    ) {
+        this.apiService = apiService;
+        this.cryptoCache = cryptoCache;
+        this.cryptoService = cryptoService;
+        this.account = account;
+        this.token = token;
+    }
+
+    // TODO: Rename to getRootIDs everywhere.
+    async getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
+        const { rootIds } = await this.getPublicLinkRoot();
+        return rootIds;
+    }
+
+    async getSharePrivateKey(): Promise<PrivateKey> {
+        const { shareKey } = await this.getPublicLinkRoot();
+        return shareKey;
+    }
+
+    private async getPublicLinkRoot(): Promise<{
+        rootIds: { volumeId: string; rootNodeId: string; rootNodeUid: string };
+        shareKey: PrivateKey;
+    }> {
+        if (!this.promisePublicLinkRoot) {
+            this.promisePublicLinkRoot = (async () => {
+                const { encryptedNode, encryptedShare } = await this.apiService.getPublicLinkRoot(this.token);
+
+                const { volumeId, nodeId: rootNodeId } = splitNodeUid(encryptedNode.uid);
+
+                const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
+                await this.cryptoCache.setShareKey(shareKey);
+
+                return {
+                    rootIds: { volumeId, rootNodeId, rootNodeUid: encryptedNode.uid },
+                    shareKey,
+                };
+            })();
+        }
+
+        return this.promisePublicLinkRoot;
+    }
+
+    async getContextShareMemberEmailKey(): Promise<{
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }> {
+        const address = await this.account.getOwnPrimaryAddress();
+        return {
+            email: address.email,
+            addressId: address.addressId,
+            addressKey: address.keys[address.primaryKeyIndex].key,
+            addressKeyId: address.keys[address.primaryKeyIndex].id,
+        };
+    }
+
+    async getVolumeMetricContext(): Promise<MetricVolumeType> {
+        return MetricVolumeType.SharedPublic;
+    }
+}

package/src/internal/upload/apiService.ts

@@ -110,6 +110,17 @@ export class UploadAPIService {
         nodeUid: string;
         nodeRevisionUid: string;
     }> {
+        // The client shouldn't send the clear text size of the file.
+        // The intented upload size is needed only for early validation that
+        // the file can fit in the remaining quota to avoid data transfer when
+        // the upload would be rejected. The backend will still validate
+        // the quota during block upload and revision commit.
+        const precision = 100_000; // bytes
+        const intendedUploadSize =
+            node.intendedUploadSize && node.intendedUploadSize > precision
+                ? Math.floor(node.intendedUploadSize / precision) * precision
+                : null;
+
         const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
         const result = await this.apiService.post<PostCreateDraftRequest, PostCreateDraftResponse>(
             `drive/v2/volumes/${volumeId}/files`,
@@ -119,7 +130,7 @@ export class UploadAPIService {
                 Hash: node.hash,
                 MIMEType: node.mediaType,
                 ClientUID: this.clientUid || null,
-                IntendedUploadSize: node.intendedUploadSize || null,
+                IntendedUploadSize: intendedUploadSize,
                 NodeKey: node.armoredNodeKey,
                 NodePassphrase: node.armoredNodePassphrase,
                 NodePassphraseSignature: node.armoredNodePassphraseSignature,

package/src/internal/upload/controller.ts

@@ -2,7 +2,7 @@ import { waitForCondition } from '../wait';
 
 export class UploadController {
     private paused = false;
-    public promise?: Promise<string>;
+    public promise?: Promise<{ nodeRevisionUid: string, nodeUid: string }>;
 
     async waitIfPaused(): Promise<void> {
         await waitForCondition(() => !this.paused);
@@ -16,7 +16,7 @@ export class UploadController {
         this.paused = false;
     }
 
-    async completion(): Promise<string> {
+    async completion(): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         if (!this.promise) {
             throw new Error('UploadController.completion() called before upload started');
         }

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

@@ -108,6 +108,7 @@ describe('FileUploader', () => {
 
         revisionDraft = {
             nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid',
             nodeKeys: {
                 signatureAddress: { addressId: 'addressId' },
             },
@@ -131,10 +132,13 @@ describe('FileUploader', () => {
             abortController.signal,
         );
 
-        startUploadSpy = jest.spyOn(uploader as any, 'startUpload').mockReturnValue(Promise.resolve('revisionUid'));
+        startUploadSpy = jest.spyOn(uploader as any, 'startUpload').mockReturnValue(Promise.resolve({
+            nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid'
+        }));
     });
 
-    describe('writeFile', () => {
+    describe('uploadFromFile', () => {
         // @ts-expect-error Ignore mocking File
         const file = {
             type: 'image/png',
@@ -146,50 +150,60 @@ describe('FileUploader', () => {
         const onProgress = jest.fn();
 
         it('should set media type if not set', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
             expect(metadata.mediaType).toEqual('image/png');
             expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
         it('should set expected size if not set', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
             expect(metadata.expectedSize).toEqual(file.size);
             expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
         it('should set modification time if not set', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
             expect(metadata.modificationTime).toEqual(new Date(123456789));
             expect(startUploadSpy).toHaveBeenCalledWith('stream', thumbnails, onProgress);
         });
 
         it('should throw an error if upload already started', async () => {
-            await uploader.writeFile(file, thumbnails, onProgress);
+            await uploader.uploadFromFile(file, thumbnails, onProgress);
 
-            await expect(uploader.writeFile(file, thumbnails, onProgress)).rejects.toThrow('Upload already started');
+            await expect(uploader.uploadFromFile(file, thumbnails, onProgress)).rejects.toThrow('Upload already started');
         });
     });
 
-    describe('writeStream', () => {
+    describe('uploadFromStream', () => {
         const stream = new ReadableStream();
         const thumbnails: Thumbnail[] = [];
         const onProgress = jest.fn();
 
         it('should start the upload process', async () => {
-            await uploader.writeStream(stream, thumbnails, onProgress);
+            await uploader.uploadFromStream(stream, thumbnails, onProgress);
 
             expect(startUploadSpy).toHaveBeenCalledWith(stream, thumbnails, onProgress);
         });
 
         it('should throw an error if upload already started', async () => {
-            await uploader.writeStream(stream, thumbnails, onProgress);
+            await uploader.uploadFromStream(stream, thumbnails, onProgress);
 
-            await expect(uploader.writeStream(stream, thumbnails, onProgress)).rejects.toThrow(
+            await expect(uploader.uploadFromStream(stream, thumbnails, onProgress)).rejects.toThrow(
                 'Upload already started',
             );
         });
+
+        it('should return correct nodeUid and nodeRevisionUid via controller completion', async () => {
+            const controller = await uploader.uploadFromStream(stream, thumbnails, onProgress);
+            const result = await controller.completion();
+
+            expect(result).toEqual({
+                nodeRevisionUid: 'revisionUid',
+                nodeUid: 'nodeUid'
+            });
+        });
     });
 });

package/src/internal/upload/fileUploader.ts

@@ -46,7 +46,7 @@ class Uploader {
         this.controller = new UploadController();
     }
 
-    async writeFile(
+    async uploadFromFile(
         fileObject: File,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -67,7 +67,7 @@ class Uploader {
         return this.controller;
     }
 
-    async writeStream(
+    async uploadFromStream(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
@@ -83,7 +83,7 @@ class Uploader {
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
-    ): Promise<string> {
+    ): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         const uploader = await this.initStreamUploader();
         return uploader.start(stream, thumbnails, onProgress);
     }
@@ -119,6 +119,7 @@ class Uploader {
             revisionDraft,
             this.metadata,
             onFinish,
+            this.controller,
             this.signal,
         );
     }

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

@@ -108,6 +108,7 @@ describe('StreamUploader', () => {
 
         revisionDraft = {
             nodeRevisionUid: 'revisionUid',
+            nodeUid: 'nodeUid',
             nodeKeys: {
                 signatureAddress: { addressId: 'addressId' },
             },
@@ -131,6 +132,7 @@ describe('StreamUploader', () => {
             revisionDraft,
             metadata,
             onFinish,
+            controller,
             abortController.signal,
         );
     });
@@ -143,7 +145,12 @@ describe('StreamUploader', () => {
         let stream: ReadableStream<Uint8Array>;
 
         const verifySuccess = async () => {
-            await uploader.start(stream, thumbnails, onProgress);
+            const result = await uploader.start(stream, thumbnails, onProgress);
+            
+            expect(result).toEqual({
+                nodeRevisionUid: 'revisionUid',
+                nodeUid: 'nodeUid'
+            });
 
             const numberOfExpectedBlocks = Math.ceil(metadata.expectedSize / FILE_CHUNK_SIZE);
             expect(uploadManager.commitDraft).toHaveBeenCalledTimes(1);
@@ -251,6 +258,8 @@ describe('StreamUploader', () => {
                 revisionDraft,
                 metadata,
                 onFinish,
+                controller,
+                abortController.signal,
             );
 
             await verifySuccess();
@@ -278,6 +287,8 @@ describe('StreamUploader', () => {
                 revisionDraft,
                 metadata,
                 onFinish,
+                controller,
+                abortController.signal,
             );
 
             await verifySuccess();
@@ -459,9 +470,10 @@ describe('StreamUploader', () => {
                     {
                         // Fake expected size to break verification
                         expectedSize: 1 * 1024 * 1024 + 1024,
-                        mediaType: '',
-                    },
+                    } as UploadMetadata,
                     onFinish,
+                    controller,
+                    abortController.signal,
                 );
 
                 await verifyFailure(

package/src/internal/upload/streamUploader.ts

@@ -84,6 +84,7 @@ export class StreamUploader {
         protected revisionDraft: NodeRevisionDraft,
         protected metadata: UploadMetadata,
         protected onFinish: (failure: boolean) => Promise<void>,
+        protected uploadController: UploadController,
         protected signal?: AbortSignal,
     ) {
         this.telemetry = telemetry;
@@ -104,14 +105,14 @@ export class StreamUploader {
         }
 
         this.digests = new UploadDigests();
-        this.controller = new UploadController();
+        this.controller = uploadController;
     }
 
     async start(
         stream: ReadableStream,
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
-    ): Promise<string> {
+    ): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
         let failure = false;
 
         // File progress is tracked for telemetry - to track at what
@@ -154,7 +155,11 @@ export class StreamUploader {
             await this.onFinish(failure);
         }
 
-        return this.revisionDraft.nodeRevisionUid;
+        return {
+            nodeRevisionUid: this.revisionDraft.nodeRevisionUid,
+            nodeUid: this.revisionDraft.nodeUid
+        }
+
     }
 
     private async encryptAndUploadBlocks(

package/src/protonDriveClient.ts

@@ -208,12 +208,12 @@ export class ProtonDriveClient {
                 const { httpClient, token, password } = await this.sessionManager.auth(url, customPassword);
                 return new ProtonDrivePublicLinkClient({
                     httpClient,
-                    cryptoCache,
                     account,
                     openPGPCryptoModule,
                     srpModule,
                     config,
                     telemetry,
+                    url,
                     token,
                     password,
                 });
@@ -726,7 +726,7 @@ export class ProtonDriveClient {
      * ```typescript
      * const downloader = await client.getFileDownloader(nodeUid, signal);
      * const claimedSize = fileDownloader.getClaimedSizeInBytes();
-     * const downloadController = fileDownloader.writeToStream(stream, (downloadedBytes) => { ... });
+     * const downloadController = fileDownloader.downloadToStream(stream, (downloadedBytes) => { ... });
      *
      * signalController.abort(); // to cancel
      * downloadController.pause(); // to pause
@@ -786,12 +786,12 @@ export class ProtonDriveClient {
      *
      * ```typescript
      * const uploader = await client.getFileUploader(parentFolderUid, name, metadata, signal);
-     * const uploadController = await uploader.writeStream(stream, thumbnails, (uploadedBytes) => { ... });
+     * const uploadController = await uploader.uploadFromStream(stream, thumbnails, (uploadedBytes) => { ... });
      *
      * signalController.abort(); // to cancel
      * uploadController.pause(); // to pause
      * uploadController.resume(); // to resume
-     * const nodeUid = await uploadController.completion(); // to await completion
+     * const { nodeUid, nodeRevisionUid } = await uploadController.completion(); // to await completion
      * ```
      */
     async getFileUploader(