@protontech/drive-sdk 0.4.1 → 0.5.1

package/src/internal/sharingPublic/index.ts

@@ -1,10 +1,19 @@
-import { DriveCrypto } from '../../crypto';
-import { ProtonDriveCryptoCache, ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
+import { DriveCrypto, PrivateKey } from '../../crypto';
+import {
+    ProtonDriveCryptoCache,
+    ProtonDriveTelemetry,
+    ProtonDriveAccount,
+    ProtonDriveEntitiesCache,
+} from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { SharingPublicAPIService } from './apiService';
-import { SharingPublicCryptoCache } from './cryptoCache';
-import { SharingPublicCryptoService } from './cryptoService';
-import { SharingPublicManager } from './manager';
+import { NodeAPIService } from '../nodes/apiService';
+import { NodesCache } from '../nodes/cache';
+import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { NodesRevisons } from '../nodes/nodesRevisions';
+import { SharingPublicCryptoReporter } from './cryptoReporter';
+import { SharingPublicNodesAccess } from './nodes';
+import { SharingPublicSharesManager } from './shares';
 
 export { SharingPublicSessionManager } from './session/manager';
 
@@ -20,22 +29,76 @@ export { SharingPublicSessionManager } from './session/manager';
 export function initSharingPublicModule(
     telemetry: ProtonDriveTelemetry,
     apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
     driveCryptoCache: ProtonDriveCryptoCache,
     driveCrypto: DriveCrypto,
     account: ProtonDriveAccount,
+    url: string,
     token: string,
-    password: string,
+    publicShareKey: PrivateKey,
+    publicRootNodeUid: string,
 ) {
-    const api = new SharingPublicAPIService(telemetry.getLogger('sharingPublic-api'), apiService);
-    const cryptoCache = new SharingPublicCryptoCache(telemetry.getLogger('sharingPublic-crypto'), driveCryptoCache);
-    const cryptoService = new SharingPublicCryptoService(telemetry, driveCrypto, account, password);
-    const manager = new SharingPublicManager(
-        telemetry.getLogger('sharingPublic-nodes'),
+    const shares = new SharingPublicSharesManager(account, publicShareKey, publicRootNodeUid);
+    const nodes = initSharingPublicNodesModule(
+        telemetry,
+        apiService,
+        driveEntitiesCache,
+        driveCryptoCache,
+        driveCrypto,
+        account,
+        shares,
+        url,
+        token,
+        publicShareKey,
+        publicRootNodeUid,
+    );
+
+    return {
+        shares,
+        nodes,
+    };
+}
+
+/**
+ * Provides facade for the public link nodes module.
+ *
+ * The public link nodes initializes the core nodes module, but uses public
+ * link shares or crypto reporter instead.
+ */
+export function initSharingPublicNodesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    driveCrypto: DriveCrypto,
+    account: ProtonDriveAccount,
+    sharesService: SharingPublicSharesManager,
+    url: string,
+    token: string,
+    publicShareKey: PrivateKey,
+    publicRootNodeUid: string,
+) {
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
+    const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
+    const cryptoReporter = new SharingPublicCryptoReporter(telemetry);
+    const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
+    const nodesAccess = new SharingPublicNodesAccess(
+        telemetry,
         api,
+        cache,
         cryptoCache,
         cryptoService,
+        sharesService,
+        url,
         token,
+        publicShareKey,
+        publicRootNodeUid,
     );
+    const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 
-    return manager;
+    return {
+        access: nodesAccess,
+        revisions: nodesRevisions,
+    };
 }

package/src/internal/sharingPublic/nodes.ts

@@ -0,0 +1,59 @@
+import { ProtonDriveTelemetry } 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';
+import { DecryptedNode, DecryptedNodeKeys } from '../nodes/interface';
+import { PrivateKey } from '../../crypto';
+
+export class SharingPublicNodesAccess extends NodesAccess {
+    constructor(
+        telemetry: ProtonDriveTelemetry,
+        apiService: NodeAPIService,
+        cache: NodesCache,
+        cryptoCache: NodesCryptoCache,
+        cryptoService: NodesCryptoService,
+        sharesService: SharingPublicSharesManager,
+        private url: string,
+        private token: string,
+        private publicShareKey: PrivateKey,
+        private publicRootNodeUid: string,
+    ) {
+        super(telemetry, apiService, cache, cryptoCache, cryptoService, sharesService);
+        this.token = token;
+        this.publicShareKey = publicShareKey;
+        this.publicRootNodeUid = publicRootNodeUid;
+    }
+
+    async getParentKeys(
+        node: Pick<DecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
+    ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+        // If we reached the root node of the public link, return the public
+        // share key even if user has access to the parent node. We do not
+        // support access to nodes outside of the public link context.
+        // For other nodes, the client must use the main SDK.
+        if (node.uid === this.publicRootNodeUid) {
+            return {
+                key: this.publicShareKey,
+            };
+        }
+
+        return super.getParentKeys(node);
+    }
+
+    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

@@ -1,5 +1,7 @@
-import { DriveAPIService, drivePaths } from '../../apiService';
-import { PublicLinkInfo, PublicLinkSrpAuth } from './interface';
+import { Logger } from '../../../interface';
+import { DriveAPIService, drivePaths, permissionsToMemberRole } from '../../apiService';
+import { makeNodeUid } from '../../uids';
+import { PublicLinkInfo, PublicLinkSrpAuth, PublicLinkSession, EncryptedShareCrypto } from './interface';
 
 type GetPublicLinkInfoResponse =
     drivePaths['/drive/urls/{token}/info']['get']['responses']['200']['content']['application/json'];
@@ -9,7 +11,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).
@@ -18,7 +20,11 @@ type PostPublicLinkAuthResponse =
  * and vice versa. It should not contain any business logic.
  */
 export class SharingPublicSessionAPIService {
-    constructor(private apiService: DriveAPIService) {
+    constructor(
+        private logger: Logger,
+        private apiService: DriveAPIService,
+    ) {
+        this.logger = logger;
         this.apiService = apiService;
     }
 
@@ -38,6 +44,13 @@ export class SharingPublicSessionAPIService {
             isCustomPasswordProtected: (response.Flags & 1) === 1,
             isLegacy: response.Flags === 0 || response.Flags === 1,
             vendorType: response.VendorType,
+            directAccess: response.DirectAccess
+                ? {
+                      nodeUid: makeNodeUid(response.DirectAccess.VolumeID, response.DirectAccess.LinkID),
+                      directRole: permissionsToMemberRole(this.logger, response.DirectAccess.DirectPermissions),
+                      publicRole: permissionsToMemberRole(this.logger, response.DirectAccess.PublicPermissions),
+                  }
+                : undefined,
         };
     }
 
@@ -52,9 +65,9 @@ export class SharingPublicSessionAPIService {
         token: string,
         srp: PublicLinkSrpAuth,
     ): Promise<{
-        serverProof: string;
-        sessionUid: string;
-        sessionAccessToken?: string;
+        session: PublicLinkSession;
+        encryptedShare: EncryptedShareCrypto;
+        rootUid: string;
     }> {
         const response = await this.apiService.post<PostPublicLinkAuthRequest, PostPublicLinkAuthResponse>(
             `drive/urls/${token}/auth`,
@@ -66,9 +79,18 @@ export class SharingPublicSessionAPIService {
         );
 
         return {
-            serverProof: response.ServerProof,
-            sessionUid: response.UID,
-            sessionAccessToken: response.AccessToken,
+            session: {
+                serverProof: response.ServerProof,
+                sessionUid: response.UID,
+                sessionAccessToken: response.AccessToken,
+            },
+            encryptedShare: {
+                base64UrlPasswordSalt: response.Share.SharePasswordSalt,
+                armoredKey: response.Share.ShareKey,
+                armoredPassphrase: response.Share.SharePassphrase,
+                publicRole: permissionsToMemberRole(this.logger, response.Share.PublicPermissions),
+            },
+            rootUid: makeNodeUid(response.Share.VolumeID, response.Share.LinkID),
         };
     }
 }

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

@@ -1,8 +1,15 @@
+import { MemberRole } from '../../../interface';
+
 export type PublicLinkInfo = {
     srp: PublicLinkSrpInfo;
     isCustomPasswordProtected: boolean;
     isLegacy: boolean;
     vendorType: number;
+    directAccess?: {
+        nodeUid: string;
+        directRole: MemberRole;
+        publicRole: MemberRole;
+    };
 };
 
 export type PublicLinkSrpInfo = {
@@ -18,3 +25,16 @@ export type PublicLinkSrpAuth = {
     clientEphemeral: string;
     srpSession: string;
 };
+
+export type PublicLinkSession = {
+    serverProof: string;
+    sessionUid: string;
+    sessionAccessToken?: string;
+};
+
+export type EncryptedShareCrypto = {
+    base64UrlPasswordSalt: string;
+    armoredKey: string;
+    armoredPassphrase: string;
+    publicRole: MemberRole;
+};

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

@@ -1,9 +1,9 @@
-import { ProtonDriveHTTPClient } from '../../../interface';
-import { SRPModule } from '../../../crypto';
+import { MemberRole, ProtonDriveHTTPClient, ProtonDriveTelemetry } from '../../../interface';
+import { DriveCrypto, PrivateKey, SRPModule } from '../../../crypto';
 import { DriveAPIService } from '../../apiService';
 import { SharingPublicSessionAPIService } from './apiService';
 import { SharingPublicSessionHttpClient } from './httpClient';
-import { PublicLinkInfo } from './interface';
+import { EncryptedShareCrypto, PublicLinkInfo } from './interface';
 import { SharingPublicLinkSession } from './session';
 import { getTokenAndPasswordFromUrl } from './url';
 
@@ -18,14 +18,17 @@ export class SharingPublicSessionManager {
     private infosPerToken: Map<string, PublicLinkInfo> = new Map();
 
     constructor(
+        telemetry: ProtonDriveTelemetry,
         private httpClient: ProtonDriveHTTPClient,
-        apiService: DriveAPIService,
+        private driveCrypto: DriveCrypto,
         private srpModule: SRPModule,
+        apiService: DriveAPIService,
     ) {
         this.httpClient = httpClient;
+        this.driveCrypto = driveCrypto;
         this.srpModule = srpModule;
 
-        this.api = new SharingPublicSessionAPIService(apiService);
+        this.api = new SharingPublicSessionAPIService(telemetry.getLogger('sharingPublicSession'), apiService);
     }
 
     /**
@@ -42,6 +45,11 @@ export class SharingPublicSessionManager {
         isCustomPasswordProtected: boolean;
         isLegacy: boolean;
         vendorType: number;
+        directAccess?: {
+            nodeUid: string;
+            directRole: MemberRole;
+            publicRole: MemberRole;
+        };
     }> {
         const { token } = getTokenAndPasswordFromUrl(url);
 
@@ -52,6 +60,7 @@ export class SharingPublicSessionManager {
             isCustomPasswordProtected: info.isCustomPasswordProtected,
             isLegacy: info.isLegacy,
             vendorType: info.vendorType,
+            directAccess: info.directAccess,
         };
     }
 
@@ -73,8 +82,9 @@ export class SharingPublicSessionManager {
         customPassword?: string,
     ): Promise<{
         token: string;
-        password: string;
         httpClient: SharingPublicSessionHttpClient;
+        shareKey: PrivateKey;
+        rootUid: string;
     }> {
         const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url);
 
@@ -86,12 +96,25 @@ export class SharingPublicSessionManager {
         const password = `${urlPassword}${customPassword || ''}`;
 
         const session = new SharingPublicLinkSession(this.api, this.srpModule, token, password);
-        await session.auth(info.srp);
+        const { encryptedShare, rootUid } = await session.auth(info.srp);
+
+        const shareKey = await this.decryptShareKey(encryptedShare, password);
 
         return {
             token,
-            password,
             httpClient: new SharingPublicSessionHttpClient(this.httpClient, session),
+            shareKey,
+            rootUid,
         };
     }
+
+    private async decryptShareKey(encryptedShare: EncryptedShareCrypto, password: string): Promise<PrivateKey> {
+        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
+            password,
+            encryptedShare.base64UrlPasswordSalt,
+            encryptedShare.armoredKey,
+            encryptedShare.armoredPassphrase,
+        );
+        return shareKey;
+    }
 }

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 { EncryptedShareCrypto, PublicLinkInfo, PublicLinkSrpInfo } from './interface';
 
 /**
  * Session for a public link.
@@ -33,7 +33,7 @@ export class SharingPublicLinkSession {
         return this.apiService.initPublicLinkSession(this.token);
     }
 
-    async auth(srp: PublicLinkSrpInfo): Promise<void> {
+    async auth(srp: PublicLinkSrpInfo): Promise<{ encryptedShare: EncryptedShareCrypto; rootUid: string }> {
         const { expectedServerProof, clientProof, clientEphemeral } = await this.srpModule.getSrp(
             srp.version,
             srp.modulus,
@@ -48,12 +48,17 @@ export class SharingPublicLinkSession {
             srpSession: srp.srpSession,
         });
 
-        if (auth.serverProof !== expectedServerProof) {
+        if (auth.session.serverProof !== expectedServerProof) {
             throw new Error('Invalid server proof');
         }
 
-        this.sessionUid = auth.sessionUid;
-        this.sessionAccessToken = auth.sessionAccessToken;
+        this.sessionUid = auth.session.sessionUid;
+        this.sessionAccessToken = auth.session.sessionAccessToken;
+
+        return {
+            encryptedShare: auth.encryptedShare,
+            rootUid: auth.rootUid,
+        };
     }
 
     /**

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,50 @@
+import { PrivateKey } from '../../crypto';
+import { MetricVolumeType, ProtonDriveAccount } from '../../interface';
+import { splitNodeUid } from '../uids';
+
+/**
+ * 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 {
+    constructor(
+        private account: ProtonDriveAccount,
+        private publicShareKey: PrivateKey,
+        private publicRootNodeUid: string,
+    ) {
+        this.account = account;
+        this.publicShareKey = publicShareKey;
+        this.publicRootNodeUid = publicRootNodeUid;
+    }
+
+    // TODO: Rename to getRootIDs everywhere.
+    async getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
+        const { volumeId, nodeId: rootNodeId } = splitNodeUid(this.publicRootNodeUid);
+        return { volumeId, rootNodeId, rootNodeUid: this.publicRootNodeUid };
+    }
+
+    async getSharePrivateKey(): Promise<PrivateKey> {
+        return this.publicShareKey;
+    }
+
+    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

@@ -1,11 +1,23 @@
+import { AbortError } from '../../errors';
 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);
+    constructor(private signal?: AbortSignal) {
+        this.signal = signal;
+    }
+
+    async waitWhilePaused(): Promise<void> {
+        try {
+            await waitForCondition(() => !this.paused, this.signal);
+        } catch (error) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
     }
 
     pause(): void {
@@ -16,7 +28,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'
+            });
+        });
     });
 });