@protontech/drive-sdk 0.5.0 → 0.5.1

package/src/internal/sharing/sharingManagement.ts

@@ -286,7 +286,7 @@ export class SharingManagement {
 
         if (!settings) {
             this.logger.info(`Unsharing node ${nodeUid}`);
-            await this.deleteShare(currentSharing.share.shareId, nodeUid);
+            await this.deleteShareWithForce(currentSharing.share.shareId, nodeUid);
             return;
         }
 
@@ -348,7 +348,7 @@ export class SharingManagement {
             // update local state immediately.
             this.logger.info(`Deleting share ${currentSharing.share.shareId} for node ${nodeUid}`);
             try {
-                await this.deleteShare(currentSharing.share.shareId, nodeUid);
+                await this.deleteShareWithForce(currentSharing.share.shareId, nodeUid);
             } catch (error: unknown) {
                 // If deleting the share fails, we don't want to throw an error
                 // as it might be a race condition that other client updated
@@ -433,8 +433,11 @@ export class SharingManagement {
         };
     }
 
-    private async deleteShare(shareId: string, nodeUid: string): Promise<void> {
-        await this.apiService.deleteShare(shareId);
+    /**
+     * Deletes the share even if it is not empty.
+     */
+    private async deleteShareWithForce(shareId: string, nodeUid: string): Promise<void> {
+        await this.apiService.deleteShare(shareId, true);
         await this.nodesService.notifyNodeChanged(nodeUid);
         if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
             await this.cache.removeSharedByMeNodeUid(nodeUid);

package/src/internal/sharingPublic/apiService.ts

@@ -1,92 +1,38 @@
-import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
-import { Logger, MemberRole } from '../../interface';
-import { makeNodeUid } from '../uids';
-import { EncryptedNode } from '../nodes/interface';
-import { EncryptedShareCrypto } from './interface';
+import { DriveAPIService, drivePaths } from '../apiService';
 
-type GetTokenInfoResponse = drivePaths['/drive/urls/{token}']['get']['responses']['200']['content']['application/json'];
+type PostTokenInfoRequest = Extract<
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostTokenInfoResponse =
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['responses']['200']['content']['application/json'];
 
 /**
- * Provides API communication for accessing public link data.
+ * Provides API communication for actions on the public link.
  *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
 export class SharingPublicAPIService {
-    constructor(
-        private logger: Logger,
-        private apiService: DriveAPIService,
-    ) {
-        this.logger = logger;
+    constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
     }
 
-    async getPublicLinkRoot(token: string): Promise<{
-        encryptedNode: EncryptedNode;
-        encryptedShare: EncryptedShareCrypto;
-    }> {
-        const response = await this.apiService.get<GetTokenInfoResponse>(`drive/urls/${token}`);
-        const encryptedNode = tokenToEncryptedNode(this.logger, response.Token);
-
-        return {
-            encryptedNode: encryptedNode,
-            encryptedShare: {
-                base64UrlPasswordSalt: response.Token.SharePasswordSalt,
-                armoredKey: response.Token.ShareKey,
-                armoredPassphrase: response.Token.SharePassphrase,
-            },
-        };
-    }
-}
-
-function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token']): EncryptedNode {
-    const baseNodeMetadata = {
-        // Internal metadata
-        encryptedName: token.Name,
-
-        // Basic node metadata
-        uid: makeNodeUid(token.VolumeID, token.LinkID),
-        parentUid: undefined,
-        type: nodeTypeNumberToNodeType(logger, token.LinkType),
-        creationTime: new Date(), // TODO
-
-        isShared: false,
-        isSharedPublicly: false,
-        directRole: MemberRole.Viewer, // TODO
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: token.SignatureEmail || undefined,
-        armoredKey: token.NodeKey,
-        armoredNodePassphrase: token.NodePassphrase,
-        armoredNodePassphraseSignature: token.NodePassphraseSignature || undefined,
-    };
-
-    if (token.LinkType === 1 && token.NodeHashKey) {
-        return {
-            ...baseNodeMetadata,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                folder: {
-                    armoredHashKey: token.NodeHashKey as string,
+    async bookmarkPublicLink(bookmark: {
+        token: string;
+        encryptedUrlPassword: string;
+        addressId: string;
+        addressKeyId: string;
+    }): Promise<void> {
+        await this.apiService.post<PostTokenInfoRequest, PostTokenInfoResponse>(
+            `drive/v2/urls/${bookmark.token}/bookmark`,
+            {
+                BookmarkShareURL: {
+                    EncryptedUrlPassword: bookmark.encryptedUrlPassword,
+                    AddressID: bookmark.addressId,
+                    AddressKeyID: bookmark.addressKeyId,
                 },
             },
-        };
+        );
     }
-
-    if (token.LinkType === 2 && token.ContentKeyPacket) {
-        return {
-            ...baseNodeMetadata,
-            totalStorageSize: token.Size || undefined,
-            mediaType: token.MIMEType || undefined,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                file: {
-                    base64ContentKeyPacket: token.ContentKeyPacket,
-                },
-            },
-        };
-    }
-
-    throw new Error(`Unknown node type: ${token.LinkType}`);
 }

package/src/internal/sharingPublic/index.ts

@@ -1,4 +1,4 @@
-import { DriveCrypto } from '../../crypto';
+import { DriveCrypto, PrivateKey } from '../../crypto';
 import {
     ProtonDriveCryptoCache,
     ProtonDriveTelemetry,
@@ -11,10 +11,7 @@ import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesCryptoService } from '../nodes/cryptoService';
 import { NodesRevisons } from '../nodes/nodesRevisions';
-import { SharingPublicAPIService } from './apiService';
-import { SharingPublicCryptoCache } from './cryptoCache';
 import { SharingPublicCryptoReporter } from './cryptoReporter';
-import { SharingPublicCryptoService } from './cryptoService';
 import { SharingPublicNodesAccess } from './nodes';
 import { SharingPublicSharesManager } from './shares';
 
@@ -38,12 +35,10 @@ export function initSharingPublicModule(
     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(driveCrypto, password);
-    const shares = new SharingPublicSharesManager(api, cryptoCache, cryptoService, account, token);
+    const shares = new SharingPublicSharesManager(account, publicShareKey, publicRootNodeUid);
     const nodes = initSharingPublicNodesModule(
         telemetry,
         apiService,
@@ -54,6 +49,8 @@ export function initSharingPublicModule(
         shares,
         url,
         token,
+        publicShareKey,
+        publicRootNodeUid,
     );
 
     return {
@@ -78,6 +75,8 @@ export function initSharingPublicNodesModule(
     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);
@@ -85,7 +84,7 @@ export function initSharingPublicNodesModule(
     const cryptoReporter = new SharingPublicCryptoReporter(telemetry);
     const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
     const nodesAccess = new SharingPublicNodesAccess(
-        telemetry.getLogger('nodes'),
+        telemetry,
         api,
         cache,
         cryptoCache,
@@ -93,6 +92,8 @@ export function initSharingPublicNodesModule(
         sharesService,
         url,
         token,
+        publicShareKey,
+        publicRootNodeUid,
     );
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 

package/src/internal/sharingPublic/nodes.ts

@@ -1,16 +1,18 @@
-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";
+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(
-        logger: Logger,
+        telemetry: ProtonDriveTelemetry,
         apiService: NodeAPIService,
         cache: NodesCache,
         cryptoCache: NodesCryptoCache,
@@ -18,9 +20,29 @@ export class SharingPublicNodesAccess extends NodesAccess {
         sharesService: SharingPublicSharesManager,
         private url: string,
         private token: string,
+        private publicShareKey: PrivateKey,
+        private publicRootNodeUid: string,
     ) {
-        super(logger, apiService, cache, cryptoCache, cryptoService, sharesService);
+        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> {

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'];
@@ -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 { 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/shares.ts

@@ -1,9 +1,6 @@
 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.
@@ -12,57 +9,24 @@ import { SharingPublicCryptoService } from './cryptoService';
  * 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,
+        private publicShareKey: PrivateKey,
+        private publicRootNodeUid: string,
     ) {
-        this.apiService = apiService;
-        this.cryptoCache = cryptoCache;
-        this.cryptoService = cryptoService;
         this.account = account;
-        this.token = token;
+        this.publicShareKey = publicShareKey;
+        this.publicRootNodeUid = publicRootNodeUid;
     }
 
     // TODO: Rename to getRootIDs everywhere.
     async getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
-        const { rootIds } = await this.getPublicLinkRoot();
-        return rootIds;
+        const { volumeId, nodeId: rootNodeId } = splitNodeUid(this.publicRootNodeUid);
+        return { volumeId, rootNodeId, rootNodeUid: this.publicRootNodeUid };
     }
 
     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;
+        return this.publicShareKey;
     }
 
     async getContextShareMemberEmailKey(): Promise<{

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<{ nodeRevisionUid: string, nodeUid: 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<{ nodeRevisionUid: string, nodeUid: 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.ts

@@ -43,7 +43,7 @@ class Uploader {
             });
         }
 
-        this.controller = new UploadController();
+        this.controller = new UploadController(this.abortController.signal);
     }
 
     async uploadFromFile(
@@ -120,7 +120,7 @@ class Uploader {
             this.metadata,
             onFinish,
             this.controller,
-            this.signal,
+            this.abortController,
         );
     }