@protontech/drive-sdk 0.5.0 → 0.5.1

package/src/internal/download/controller.ts

@@ -1,11 +1,23 @@
+import { AbortError } from '../../errors';
 import { waitForCondition } from '../wait';
 
 export class DownloadController {
     private paused = false;
     public promise?: Promise<void>;
 
+    constructor(private signal?: AbortSignal) {
+        this.signal = signal;
+    }
+
     async waitWhilePaused(): Promise<void> {
-        await waitForCondition(() => !this.paused);
+        try {
+            await waitForCondition(() => !this.paused, this.signal);
+        } catch (error) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
     }
 
     pause(): void {

package/src/internal/download/fileDownloader.ts

@@ -1,4 +1,7 @@
+import { c } from 'ttag';
+
 import { PrivateKey, SessionKey, base64StringToUint8Array } from '../../crypto';
+import { AbortError } from '../../errors';
 import { Logger } from '../../interface';
 import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
@@ -48,7 +51,7 @@ export class FileDownloader {
         this.revision = revision;
         this.signal = signal;
         this.onFinish = onFinish;
-        this.controller = new DownloadController();
+        this.controller = new DownloadController(this.signal);
     }
 
     getClaimedSizeInBytes(): number | undefined {
@@ -289,6 +292,10 @@ export class FileDownloader {
                 logger.debug(`Decrypting`);
                 decryptedBlock = await this.cryptoService.decryptBlock(encryptedBlock, cryptoKeys);
             } catch (error) {
+                if (this.signal?.aborted) {
+                    throw new AbortError(c('Error').t`Operation aborted`);
+                }
+
                 if (blockProgress !== 0) {
                     onProgress?.(-blockProgress);
                     blockProgress = 0;

package/src/internal/nodes/apiService.test.ts

@@ -1,3 +1,4 @@
+import { NodeWithSameNameExistsValidationError, ValidationError } from '../../errors';
 import { MemberRole, NodeType } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { DriveAPIService, ErrorCode, InvalidRequirementsAPIError } from '../apiService';
@@ -627,6 +628,69 @@ describe('nodeAPIService', () => {
         });
     });
 
+    describe('createFolder', () => {
+        it('should create folder', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: ErrorCode.OK,
+                Folder: {
+                    ID: 'newNodeId',
+                },
+            });
+
+            const result = await api.createFolder('volumeId~parentNodeId', {
+                armoredKey: 'armoredKey',
+                armoredHashKey: 'armoredHashKey',
+                armoredNodePassphrase: 'armoredNodePassphrase',
+                armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                signatureEmail: 'signatureEmail',
+                encryptedName: 'encryptedName',
+                hash: 'hash',
+                armoredExtendedAttributes: 'armoredExtendedAttributes',
+            });
+
+            expect(result).toEqual('volumeId~newNodeId');
+            expect(apiMock.post).toHaveBeenCalledWith('drive/v2/volumes/volumeId/folders', {
+                ParentLinkID: 'parentNodeId',
+                NodeKey: 'armoredKey',
+                NodeHashKey: 'armoredHashKey',
+                NodePassphrase: 'armoredNodePassphrase',
+                NodePassphraseSignature: 'armoredNodePassphraseSignature',
+                SignatureEmail: 'signatureEmail',
+                Name: 'encryptedName',
+                Hash: 'hash',
+                XAttr: 'armoredExtendedAttributes',
+            });
+        });
+
+        it('should throw NodeWithSameNameExistsValidationError if node already exists', async () => {
+            apiMock.post = jest.fn().mockRejectedValue(
+                new ValidationError('Node already exists', ErrorCode.ALREADY_EXISTS, {
+                    ConflictLinkID: 'existingNodeId',
+                }),
+            );
+
+            try {
+                await api.createFolder('volumeId~parentNodeId', {
+                    armoredKey: 'armoredKey',
+                    armoredHashKey: 'armoredHashKey',
+                    armoredNodePassphrase: 'armoredNodePassphrase',
+                    armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                    signatureEmail: 'signatureEmail',
+                    encryptedName: 'encryptedName',
+                    hash: 'hash',
+                    armoredExtendedAttributes: 'armoredExtendedAttributes',
+                });
+                expect(false).toBeTruthy();
+            } catch (error: unknown) {
+                expect(error).toBeInstanceOf(NodeWithSameNameExistsValidationError);
+                if (error instanceof NodeWithSameNameExistsValidationError) {
+                    expect(error.code).toEqual(ErrorCode.ALREADY_EXISTS);
+                    expect(error.existingNodeUid).toEqual('volumeId~existingNodeId');
+                }
+            }
+        });
+    });
+
     describe('renameNode', () => {
         it('should rename node', async () => {
             await api.renameNode(

package/src/internal/nodes/apiService.ts

@@ -1,11 +1,12 @@
 import { c } from 'ttag';
 
-import { ProtonDriveError, ValidationError } from '../../errors';
+import { NodeWithSameNameExistsValidationError, ProtonDriveError, ValidationError } from '../../errors';
 import { Logger, NodeResult } from '../../interface';
 import { MemberRole, RevisionState } from '../../interface/nodes';
 import {
     DriveAPIService,
     drivePaths,
+    ErrorCode,
     InvalidRequirementsAPIError,
     isCodeOk,
     nodeTypeNumberToNodeType,
@@ -400,7 +401,7 @@ export class NodeAPIService {
             );
 
             // TODO: remove `as` when backend fixes OpenAPI schema.
-            yield * handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
+            yield* handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
         }
     }
 
@@ -449,21 +450,41 @@ export class NodeAPIService {
     ): Promise<string> {
         const { volumeId, nodeId: parentId } = splitNodeUid(parentUid);
 
-        const response = await this.apiService.post<PostCreateFolderRequest, PostCreateFolderResponse>(
-            `drive/v2/volumes/${volumeId}/folders`,
-            {
-                ParentLinkID: parentId,
-                NodeKey: newNode.armoredKey,
-                NodeHashKey: newNode.armoredHashKey,
-                NodePassphrase: newNode.armoredNodePassphrase,
-                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
-                SignatureEmail: newNode.signatureEmail,
-                Name: newNode.encryptedName,
-                Hash: newNode.hash,
-                // @ts-expect-error: XAttr is optional as undefined.
-                XAttr: newNode.armoredExtendedAttributes,
-            },
-        );
+        let response: PostCreateFolderResponse;
+        try {
+            response = await this.apiService.post<PostCreateFolderRequest, PostCreateFolderResponse>(
+                `drive/v2/volumes/${volumeId}/folders`,
+                {
+                    ParentLinkID: parentId,
+                    NodeKey: newNode.armoredKey,
+                    NodeHashKey: newNode.armoredHashKey,
+                    NodePassphrase: newNode.armoredNodePassphrase,
+                    NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                    SignatureEmail: newNode.signatureEmail,
+                    Name: newNode.encryptedName,
+                    Hash: newNode.hash,
+                    // @ts-expect-error: XAttr is optional as undefined.
+                    XAttr: newNode.armoredExtendedAttributes,
+                },
+            );
+        } catch (error: unknown) {
+            if (error instanceof ValidationError) {
+                if (error.code === ErrorCode.ALREADY_EXISTS) {
+                    const typedDetails = error.details as
+                        | {
+                              ConflictLinkID: string;
+                          }
+                        | undefined;
+
+                    const existingNodeUid = typedDetails?.ConflictLinkID
+                        ? makeNodeUid(volumeId, typedDetails.ConflictLinkID)
+                        : undefined;
+
+                    throw new NodeWithSameNameExistsValidationError(error.message, error.code, existingNodeUid);
+                }
+            }
+            throw error;
+        }
 
         return makeNodeUid(volumeId, response.Folder.ID);
     }

package/src/internal/nodes/debouncer.test.ts

@@ -1,18 +1,14 @@
+import { ProtonDriveTelemetry } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
 import { NodesDebouncer } from './debouncer';
-import { Logger } from '../../interface';
 
 describe('NodesDebouncer', () => {
     let debouncer: NodesDebouncer;
-    let mockLogger: jest.Mocked<Logger>;
+    let mockTelemetry: ReturnType<typeof getMockTelemetry>;
 
     beforeEach(() => {
-        mockLogger = {
-            debug: jest.fn(),
-            info: jest.fn(),
-            warn: jest.fn(),
-            error: jest.fn(),
-        };
-        debouncer = new NodesDebouncer(mockLogger);
+        mockTelemetry = getMockTelemetry();
+        debouncer = new NodesDebouncer(mockTelemetry);
 
         jest.useFakeTimers();
     });
@@ -77,7 +73,22 @@ describe('NodesDebouncer', () => {
         debouncer.loadingNode(nodeUid);
         debouncer.loadingNode(nodeUid);
 
-        expect(mockLogger.warn).toHaveBeenCalledWith(`debouncer: Loading twice for: ${nodeUid}`);
+        expect(mockTelemetry.mockLogger.warn).toHaveBeenCalledWith(`Loading twice for: ${nodeUid}`);
+    });
+
+    it('should send metric when waiting for a long time', async () => {
+        const nodeUid = 'test-node-1';
+        debouncer.loadingNode(nodeUid);
+
+        const waitPromise = debouncer.waitForLoadingNode(nodeUid);
+        expect(mockTelemetry.recordMetric).not.toHaveBeenCalled();
+        jest.advanceTimersByTime(1500);
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
+            eventName: 'debounceLongWait',
+        });
+
+        debouncer.finishedLoadingNode(nodeUid);
+        await waitPromise;
     });
 
     it('should timeout', async () => {
@@ -85,7 +96,7 @@ describe('NodesDebouncer', () => {
         debouncer.loadingNode(nodeUid);
 
         jest.advanceTimersByTime(6000);
-        expect(mockLogger.warn).toHaveBeenCalledWith(`debouncer: Timeout for: ${nodeUid}`);
+        expect(mockTelemetry.mockLogger.warn).toHaveBeenCalledWith(`Timeout for: ${nodeUid}`);
         await expect(debouncer.waitForLoadingNode(nodeUid)).resolves.toBeUndefined();
     });
 
@@ -112,7 +123,7 @@ describe('NodesDebouncer', () => {
 
             const result = await debouncer.waitForLoadingNode(nodeUid);
             expect(result).toBeUndefined();
-            expect(mockLogger.debug).not.toHaveBeenCalled();
+            expect(mockTelemetry.mockLogger.debug).not.toHaveBeenCalled();
         });
 
         it('should wait for registered node and log debug message', async () => {
@@ -121,7 +132,8 @@ describe('NodesDebouncer', () => {
 
             const waitPromise = debouncer.waitForLoadingNode(nodeUid);
 
-            expect(mockLogger.debug).toHaveBeenCalledWith(`debouncer: Wait for: ${nodeUid}`);
+            expect(mockTelemetry.mockLogger.debug).toHaveBeenCalledWith(`Wait for: ${nodeUid}`);
+
             debouncer.finishedLoadingNode(nodeUid);
             await waitPromise;
         });

package/src/internal/nodes/debouncer.ts

@@ -1,5 +1,4 @@
-import { Logger } from "../../interface";
-import { LoggerWithPrefix } from '../../telemetry';
+import { Logger, ProtonDriveTelemetry } from '../../interface';
 
 /**
  * The timeout for which the node is considered to be loading.
@@ -11,6 +10,12 @@ import { LoggerWithPrefix } from '../../telemetry';
  */
 const DEBOUNCE_TIMEOUT = 5000;
 
+/**
+ * The timeout for which the node is considered to be waiting for a long time.
+ * After this timeout the metric is sent.
+ */
+const DEBOUNCE_LONG_WAIT_TIMEOUT = 1000;
+
 /**
  * Helper to avoid loading the same node twice.
  *
@@ -23,6 +28,8 @@ const DEBOUNCE_TIMEOUT = 5000;
  * the node to be loaded if that is the case.
  */
 export class NodesDebouncer {
+    private logger: Logger;
+
     private promises: Map<
         string,
         {
@@ -32,8 +39,9 @@ export class NodesDebouncer {
         }
     > = new Map();
 
-    constructor(private logger: Logger) {
-        this.logger = new LoggerWithPrefix(logger, 'debouncer');
+    constructor(private telemetry: ProtonDriveTelemetry) {
+        this.logger = telemetry.getLogger('nodes-debouncer');
+        this.telemetry = telemetry;
     }
 
     loadingNodes(nodeUids: string[]) {
@@ -79,8 +87,16 @@ export class NodesDebouncer {
             return;
         }
 
+        const metricTimeout = setTimeout(() => {
+            this.telemetry.recordMetric({
+                eventName: 'debounceLongWait',
+            });
+        }, DEBOUNCE_LONG_WAIT_TIMEOUT);
+
         this.logger.debug(`Wait for: ${nodeUid}`);
         await result.promise;
+
+        clearTimeout(metricTimeout);
     }
 
     clear() {

package/src/internal/nodes/extendedAttributes.ts

@@ -208,11 +208,11 @@ function parseBlockSizes(
         return undefined;
     }
     if (!Array.isArray(blockSizes)) {
-        logger.warn(`XAttr block sizes "${blockSizes}" is not valid`);
+        logger.warn(`XAttr block sizes "${JSON.stringify(blockSizes)}" is not valid`);
         return undefined;
     }
     if (blockSizes.some((size) => typeof size !== 'number' || size <= 0)) {
-        logger.warn(`XAttr block sizes "${blockSizes}" is not valid`);
+        logger.warn(`XAttr block sizes "${JSON.stringify(blockSizes)}" is not valid`);
         return undefined;
     }
     if (blockSizes.length === 0) {

package/src/internal/nodes/index.ts

@@ -43,14 +43,7 @@ export function initNodesModule(
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
     const cryptoReporter = new NodesCryptoReporter(telemetry, sharesService);
     const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
-    const nodesAccess = new NodesAccess(
-        telemetry.getLogger('nodes'),
-        api,
-        cache,
-        cryptoCache,
-        cryptoService,
-        sharesService,
-    );
+    const nodesAccess = new NodesAccess(telemetry, api, cache, cryptoCache, cryptoService, sharesService);
     const nodesEventHandler = new NodesEventsHandler(telemetry.getLogger('nodes-events'), cache);
     const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess);
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);

package/src/internal/nodes/nodesAccess.test.ts

@@ -1,4 +1,4 @@
-import { getMockLogger } from '../../tests/logger';
+import { getMockTelemetry } from '../../tests/telemetry';
 import { PrivateKey } from '../../crypto';
 import { DecryptionError } from '../../errors';
 import { NodeAPIService } from './apiService';
@@ -50,7 +50,7 @@ describe('nodesAccess', () => {
             getSharePrivateKey: jest.fn(),
         };
 
-        access = new NodesAccess(getMockLogger(), apiService, cache, cryptoCache, cryptoService, shareService);
+        access = new NodesAccess(getMockTelemetry(), apiService, cache, cryptoCache, cryptoService, shareService);
     });
 
     describe('getNode', () => {
@@ -569,7 +569,11 @@ describe('nodesAccess', () => {
         it('should get share parent keys', async () => {
             shareService.getSharePrivateKey = jest.fn(() => Promise.resolve('shareKey' as any as PrivateKey));
 
-            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: undefined });
+            const result = await access.getParentKeys({
+                uid: 'volumeId~nodeId',
+                shareId: 'shareId',
+                parentUid: undefined,
+            });
             expect(result).toEqual({ key: 'shareKey' });
             expect(cryptoCache.getNodeKeys).not.toHaveBeenCalled();
         });
@@ -577,7 +581,11 @@ describe('nodesAccess', () => {
         it('should get node parent keys', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
 
-            const result = await access.getParentKeys({ shareId: undefined, parentUid: 'volumeId~parentNodeid' });
+            const result = await access.getParentKeys({
+                uid: 'volumeId~nodeId',
+                shareId: undefined,
+                parentUid: 'volumeId~parentNodeid',
+            });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });
@@ -585,7 +593,11 @@ describe('nodesAccess', () => {
         it('should get node parent keys even if share is set', async () => {
             cryptoCache.getNodeKeys = jest.fn(() => Promise.resolve({ key: 'parentKey' } as any as DecryptedNodeKeys));
 
-            const result = await access.getParentKeys({ shareId: 'shareId', parentUid: 'volume1~parentNodeid' });
+            const result = await access.getParentKeys({
+                uid: 'volume1~nodeId',
+                shareId: 'shareId',
+                parentUid: 'volume1~parentNodeid',
+            });
             expect(result).toEqual({ key: 'parentKey' });
             expect(shareService.getSharePrivateKey).not.toHaveBeenCalled();
         });

package/src/internal/nodes/nodesAccess.ts

@@ -1,7 +1,16 @@
 import { c } from 'ttag';
 
 import { PrivateKey, SessionKey } from '../../crypto';
-import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from '../../interface';
+import {
+    InvalidNameError,
+    Logger,
+    MissingNode,
+    NodeType,
+    ProtonDriveTelemetry,
+    Result,
+    resultError,
+    resultOk,
+} from '../../interface';
 import { DecryptionError, ProtonDriveError } from '../../errors';
 import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
@@ -41,10 +50,11 @@ const DECRYPTION_CONCURRENCY = 30;
  * nodes metadata.
  */
 export class NodesAccess {
+    private logger: Logger;
     private debouncer: NodesDebouncer;
 
     constructor(
-        private logger: Logger,
+        private telemetry: ProtonDriveTelemetry,
         private apiService: NodeAPIService,
         private cache: NodesCache,
         private cryptoCache: NodesCryptoCache,
@@ -54,13 +64,13 @@ export class NodesAccess {
             'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
         >,
     ) {
-        this.logger = logger;
+        this.logger = telemetry.getLogger('nodes');
         this.apiService = apiService;
         this.cache = cache;
         this.cryptoCache = cryptoCache;
         this.cryptoService = cryptoService;
         this.shareService = shareService;
-        this.debouncer = new NodesDebouncer(this.logger);
+        this.debouncer = new NodesDebouncer(this.telemetry);
     }
 
     async getVolumeRootFolder() {
@@ -357,7 +367,7 @@ export class NodesAccess {
     }
 
     async getParentKeys(
-        node: Pick<DecryptedNode, 'parentUid' | 'shareId'>,
+        node: Pick<DecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
     ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
         if (node.parentUid) {
             try {

package/src/internal/nodes/nodesManagement.test.ts

@@ -50,7 +50,7 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
-            copyNode: jest.fn(),
+            copyNode: jest.fn().mockResolvedValue('newCopiedNodeUid'),
             trashNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
@@ -251,6 +251,7 @@ describe('NodesManagement', () => {
 
         expect(newNode).toEqual({
             ...nodes.nodeUid,
+            uid: 'newCopiedNodeUid',
             parentUid: 'newParentNodeUid',
             encryptedName: 'copiedArmoredNodeName',
             hash: 'copiedHash',
@@ -307,6 +308,7 @@ describe('NodesManagement', () => {
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
+            uid: 'newCopiedNodeUid',
             parentUid: 'newParentNodeUid',
             encryptedName: 'copiedArmoredNodeName',
             hash: 'copiedHash',

package/src/internal/nodes/nodesManagement.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { MemberRole, NodeType, NodeResult, resultOk } from '../../interface';
+import { MemberRole, NodeType, NodeResult, NodeResultWithNewUid, resultOk } from '../../interface';
 import { AbortError, ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
 import { splitNodeUid } from '../uids';
@@ -182,16 +182,21 @@ export class NodesManagement {
         return newNode;
     }
 
-    // Improvement requested: copy nodes in parallel
-    async *copyNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    // Improvement requested: copy nodes in parallel using copy_multiple endpoint
+    async *copyNodes(
+        nodeUids: string[],
+        newParentNodeUid: string,
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResultWithNewUid> {
         for (const nodeUid of nodeUids) {
             if (signal?.aborted) {
                 throw new AbortError(c('Error').t`Copy operation aborted`);
             }
             try {
-                await this.copyNode(nodeUid, newParentNodeUid);
+                const { uid: newNodeUid } = await this.copyNode(nodeUid, newParentNodeUid);
                 yield {
                     uid: nodeUid,
+                    newUid: newNodeUid,
                     ok: true,
                 };
             } catch (error: unknown) {
@@ -237,7 +242,7 @@ export class NodesManagement {
                   signatureEmail: encryptedCrypto.signatureEmail,
                   armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
               };
-        await this.apiService.copyNode(nodeUid, {
+        const newNodeUid = await this.apiService.copyNode(nodeUid, {
             ...keySignatureProperties,
             parentUid: newParentUid,
             armoredNodePassphrase: encryptedCrypto.armoredNodePassphrase,
@@ -247,6 +252,7 @@ export class NodesManagement {
         });
         const newNode: DecryptedNode = {
             ...node,
+            uid: newNodeUid,
             encryptedName: encryptedCrypto.encryptedName,
             parentUid: newParentUid,
             hash: encryptedCrypto.hash,

package/src/internal/photos/apiService.ts

@@ -1,12 +1,9 @@
-import { c } from 'ttag';
-
-import { DriveAPIService, drivePaths, NotFoundAPIError } from '../apiService';
+import { DriveAPIService, drivePaths } from '../apiService';
 import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
 import { makeNodeUid } from '../uids';
 
-type GetVolumesResponse = drivePaths['/drive/volumes']['get']['responses']['200']['content']['application/json'];
-
-type GetShareResponse = drivePaths['/drive/shares/{shareID}']['get']['responses']['200']['content']['application/json'];
+type GetPhotoShareResponse =
+    drivePaths['/drive/v2/shares/photos']['get']['responses']['200']['content']['application/json'];
 
 type PostCreateVolumeRequest = Extract<
     drivePaths['/drive/photos/volumes']['post']['requestBody'],
@@ -34,33 +31,19 @@ export class PhotosAPIService {
     }
 
     async getPhotoShare(): Promise<EncryptedRootShare> {
-        // TODO: Switch to drive/v2/shares/photos once available.
-
-        const volumesResponse = await this.apiService.get<GetVolumesResponse>('drive/volumes');
-
-        const photoVolume = volumesResponse.Volumes.find((volume) => volume.Type === 2);
-
-        if (!photoVolume) {
-            throw new NotFoundAPIError(c('Error').t`Photo volume not found`);
-        }
-
-        const response = await this.apiService.get<GetShareResponse>(`drive/shares/${photoVolume.Share.ShareID}`);
-
-        if (!response.AddressID) {
-            throw new Error('Photo root share has not address ID set');
-        }
+        const response = await this.apiService.get<GetPhotoShareResponse>('drive/v2/shares/photos');
 
         return {
-            volumeId: response.VolumeID,
-            shareId: response.ShareID,
-            rootNodeId: response.LinkID,
-            creatorEmail: response.Creator,
+            volumeId: response.Volume.VolumeID,
+            shareId: response.Share.ShareID,
+            rootNodeId: response.Link.Link.LinkID,
+            creatorEmail: response.Share.CreatorEmail,
             encryptedCrypto: {
-                armoredKey: response.Key,
-                armoredPassphrase: response.Passphrase,
-                armoredPassphraseSignature: response.PassphraseSignature,
+                armoredKey: response.Share.Key,
+                armoredPassphrase: response.Share.Passphrase,
+                armoredPassphraseSignature: response.Share.PassphraseSignature,
             },
-            addressId: response.AddressID,
+            addressId: response.Share.AddressID,
             type: ShareType.Photo,
         };
     }

package/src/internal/photos/upload.ts

@@ -85,7 +85,25 @@ export class PhotoStreamUploader extends StreamUploader {
         controller: UploadController,
         signal?: AbortSignal,
     ) {
-        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, controller, signal);
+        const abortController = new AbortController();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                abortController.abort();
+            });
+        }
+
+        super(
+            telemetry,
+            apiService,
+            cryptoService,
+            uploadManager,
+            blockVerifier,
+            revisionDraft,
+            metadata,
+            onFinish,
+            controller,
+            abortController,
+        );
         this.photoUploadManager = uploadManager;
         this.photoMetadata = metadata;
     }

package/src/internal/sharing/apiService.ts

@@ -347,8 +347,8 @@ export class SharingAPIService {
         return response.Share.ID;
     }
 
-    async deleteShare(shareId: string): Promise<void> {
-        await this.apiService.delete(`drive/shares/${shareId}?Force=1`);
+    async deleteShare(shareId: string, force: boolean = false): Promise<void> {
+        await this.apiService.delete(`drive/shares/${shareId}?Force=${force ? 1 : 0}`);
     }
 
     async inviteProtonUser(