@protontech/drive-sdk 0.15.0 → 0.15.2

package/src/internal/photos/photosManager.test.ts

@@ -58,7 +58,7 @@ async function collectSaveToTimelineResults(manager: PhotosManager, nodeUids: st
 describe('PhotosManager', () => {
     let logger: ReturnType<typeof getMockLogger>;
     let apiService: jest.Mocked<
-        Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite' | 'transferPhotos'>
+        Pick<PhotosAPIService, 'addPhotoTags' | 'removePhotoTags' | 'setPhotoFavorite' | 'transferPhotos' | 'copyPhoto'>
     >;
     let cryptoService: jest.Mocked<Pick<AlbumsCryptoService, 'encryptPhotoForAlbum'>>;
     let nodesService: jest.Mocked<
@@ -70,6 +70,7 @@ describe('PhotosManager', () => {
             | 'iterateNodes'
             | 'getNodePrivateAndSessionKeys'
             | 'notifyNodeChanged'
+            | 'notifyChildCreated'
         >
     >;
     let manager: PhotosManager;
@@ -92,6 +93,7 @@ describe('PhotosManager', () => {
             removePhotoTags: jest.fn().mockResolvedValue(undefined),
             setPhotoFavorite: jest.fn().mockResolvedValue(undefined),
             transferPhotos: jest.fn().mockImplementation(async function* () {}),
+            copyPhoto: jest.fn().mockResolvedValue('volume1~newPhoto'),
         };
 
         cryptoService = {
@@ -122,6 +124,7 @@ describe('PhotosManager', () => {
                 passphraseSessionKey: 'passphraseSessionKey' as any,
             }),
             notifyNodeChanged: jest.fn().mockResolvedValue(undefined),
+            notifyChildCreated: jest.fn().mockResolvedValue(undefined),
         };
 
         manager = new PhotosManager(logger, apiService as any, cryptoService as any, nodesService as any);
@@ -304,5 +307,37 @@ describe('PhotosManager', () => {
             );
             expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('volume1~photo1');
         });
+
+        it('copies cross-volume photo and notifies parent root folder', async () => {
+            apiService.copyPhoto.mockResolvedValue('volume1~newPhoto1');
+
+            const results = await collectSaveToTimelineResults(manager, ['volume2~photo1']);
+
+            expect(results).toEqual([{ uid: 'volume2~photo1', ok: true }]);
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(1);
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('volume1~root');
+            expect(nodesService.notifyNodeChanged).not.toHaveBeenCalled();
+        });
+
+        it('re-queues cross-volume photo once on MissingRelatedPhotosError then succeeds', async () => {
+            const missingRelatedUid = 'volume2~related1';
+            let copyCall = 0;
+            apiService.copyPhoto.mockImplementation(async () => {
+                copyCall++;
+                if (copyCall === 1) {
+                    throw new MissingRelatedPhotosError([missingRelatedUid]);
+                }
+                return 'volume1~newPhoto1';
+            });
+
+            const results = await collectSaveToTimelineResults(manager, ['volume2~photo1']);
+
+            expect(results).toEqual([{ uid: 'volume2~photo1', ok: true }]);
+            expect(apiService.copyPhoto).toHaveBeenCalledTimes(2);
+            expect(logger.info).toHaveBeenCalledWith(
+                `Missing related photos for saving volume2~photo1, re-queuing: ${missingRelatedUid}`,
+            );
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('volume1~root');
+        });
     });
 });

package/src/internal/photos/photosManager.ts

@@ -3,12 +3,17 @@ import { c } from 'ttag';
 import { AbortError } from '../../errors';
 import { Logger, NodeResultWithError, PhotoTag } from '../../interface';
 import { batch } from '../batch';
+import { splitNodeUid } from '../uids';
 import { createBatches } from './addToAlbum';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { MissingRelatedPhotosError } from './errors';
 import { PhotosNodesAccess } from './nodes';
-import { PhotoAlreadyInTargetError, PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
+import {
+    PhotoAlreadyInTargetError,
+    PhotoTransferPayloadBuilder,
+    TransferEncryptedPhotoPayload,
+} from './photosTransferPayloadBuilder';
 
 /**
  * The number of photos that are loaded in parallel to prepare the payloads.
@@ -39,13 +44,14 @@ export class PhotosManager {
 
     async *saveToTimeline(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
         const rootNode = await this.nodesService.getVolumeRootFolder();
+        const { volumeId: userVolumeId } = splitNodeUid(rootNode.uid);
         const volumeRootKeys = await this.nodesService.getNodeKeys(rootNode.uid);
         const signingKeys = await this.nodesService.getNodeSigningKeys({ nodeUid: rootNode.uid });
 
-        const queue: {
-            photoNodeUid: string;
-            additionalRelatedPhotoNodeUids: string[];
-        }[] = nodeUids.map((nodeUid) => ({ photoNodeUid: nodeUid, additionalRelatedPhotoNodeUids: [] }));
+        const queue: { photoNodeUid: string; additionalRelatedPhotoNodeUids: string[] }[] = nodeUids.map((nodeUid) => ({
+            photoNodeUid: nodeUid,
+            additionalRelatedPhotoNodeUids: [],
+        }));
         const retriedPhotoUids = new Set<string>();
 
         while (queue.length > 0) {
@@ -62,7 +68,10 @@ export class PhotosManager {
                 yield { uid, ok: false, error };
             }
 
-            for (const batch of createBatches(payloads)) {
+            const sameVolumePayloads = payloads.filter((p) => splitNodeUid(p.nodeUid).volumeId === userVolumeId);
+            const crossVolumePayloads = payloads.filter((p) => splitNodeUid(p.nodeUid).volumeId !== userVolumeId);
+
+            for (const batch of createBatches(sameVolumePayloads)) {
                 for await (const result of this.apiService.transferPhotos(rootNode.uid, batch, signal)) {
                     if (
                         !result.ok &&
@@ -79,16 +88,48 @@ export class PhotosManager {
                         });
                         continue;
                     }
-
                     if (result.ok) {
                         await this.nodesService.notifyNodeChanged(result.uid);
                     }
                     yield result;
                 }
             }
+
+            // Cross-volume photos (e.g. from shared-with-me albums): copy into the user's own
+            // timeline root using the generic copy endpoint.
+            for (const payload of crossVolumePayloads) {
+                try {
+                    await this.copyPhoto(payload, signal);
+                    await this.nodesService.notifyChildCreated(rootNode.uid);
+                    yield { uid: payload.nodeUid, ok: true };
+                } catch (error) {
+                    if (error instanceof MissingRelatedPhotosError && !retriedPhotoUids.has(payload.nodeUid)) {
+                        retriedPhotoUids.add(payload.nodeUid);
+                        this.logger.info(
+                            `Missing related photos for saving ${payload.nodeUid}, re-queuing: ${error.missingNodeUids.join(', ')}`,
+                        );
+                        queue.push({
+                            photoNodeUid: payload.nodeUid,
+                            additionalRelatedPhotoNodeUids: error.missingNodeUids,
+                        });
+                        continue;
+                    }
+                    yield {
+                        uid: payload.nodeUid,
+                        ok: false,
+                        error:
+                            error instanceof Error ? error : new Error(c('Error').t`Unknown error`, { cause: error }),
+                    };
+                }
+            }
         }
     }
 
+    private async copyPhoto(payload: TransferEncryptedPhotoPayload, signal?: AbortSignal): Promise<string> {
+        const rootNode = await this.nodesService.getVolumeRootFolder();
+        return this.apiService.copyPhoto(rootNode.uid, payload, signal);
+    }
+
     async *updatePhotos(photos: UpdatePhotoSettings[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
         for await (const {
             photoSettings: { nodeUid, tagsToAdd, tagsToRemove },

package/src/internal/sharing/cryptoService.test.ts

@@ -169,7 +169,7 @@ describe('SharingCryptoService', () => {
 
         it('should handle invalid node name', async () => {
             driveCrypto.decryptNodeName = jest.fn().mockResolvedValue({
-                name: 'invalid/name',
+                name: '',
             });
 
             const result = await cryptoService.decryptBookmark(encryptedBookmark);
@@ -177,8 +177,8 @@ describe('SharingCryptoService', () => {
             expect(result).toMatchObject({
                 url: resultOk('https://drive.proton.me/urls/tokenId#urlPassword'),
                 nodeName: resultError({
-                    name: 'invalid/name',
-                    error: "Name must not contain the character '/'",
+                    name: '',
+                    error: "Name must not be empty",
                 }),
             });
         });

package/src/internal/sharing/cryptoService.ts

@@ -193,12 +193,12 @@ export class SharingCryptoService {
         encryptedInvitation: EncryptedInvitationWithNode,
     ): Promise<ProtonInvitationWithNode> {
         const inviteeAddress = await this.account.getOwnAddress(encryptedInvitation.inviteeEmail);
-        const inviteeKey = inviteeAddress.keys[inviteeAddress.primaryKeyIndex].key;
+        const inviteeKeys = inviteeAddress.keys.map(k => k.key);
 
         const shareKey = await this.driveCrypto.decryptUnsignedKey(
             encryptedInvitation.share.armoredKey,
             encryptedInvitation.share.armoredPassphrase,
-            inviteeKey,
+            inviteeKeys,
         );
 
         let nodeName: Result<string, Error>;
@@ -246,7 +246,8 @@ export class SharingCryptoService {
     }> {
         const inviteeAddress = await this.account.getOwnAddress(encryptedInvitation.inviteeEmail);
         const inviteeKey = inviteeAddress.keys[inviteeAddress.primaryKeyIndex].key;
-        const result = await this.driveCrypto.acceptInvitation(encryptedInvitation.base64KeyPacket, inviteeKey);
+        const inviteeKeys = inviteeAddress.keys.map(k => k.key);
+        const result = await this.driveCrypto.acceptInvitation(encryptedInvitation.base64KeyPacket, inviteeKeys, inviteeKey);
         return result;
     }
 

package/src/internal/sharingPublic/nodes.ts

@@ -17,6 +17,9 @@ import { makeNodeUid, splitNodeUid } from '../uids';
 import { SharingPublicSharesManager } from './shares';
 
 export class SharingPublicNodesCryptoService extends NodesCryptoService {
+    // Do not allow fallback verification for public links, because it is not possible to load owners' address keys.
+    protected allowContentKeyPacketFallbackVerification = false;
+
     async generateDocument(
         parentKeys: { key: PrivateKey; hashKey: Uint8Array<ArrayBuffer> },
         signingKeys: NodeSigningKeys,

package/src/protonDriveClient.ts

@@ -6,6 +6,7 @@ import {
     Device,
     DeviceOrUid,
     DeviceType,
+    DriveEvent,
     FileDownloader,
     FileUploader,
     Logger,
@@ -36,7 +37,7 @@ import {
 import { DriveAPIService } from './internal/apiService';
 import { initDevicesModule } from './internal/devices';
 import { initDownloadModule } from './internal/download';
-import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
+import { CoreApiEvent, DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import { initNodesModule } from './internal/nodes';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
@@ -113,6 +114,16 @@ export class ProtonDriveClient {
             customPassword?: string,
             isAnonymousContext?: boolean,
         ) => Promise<ProtonDrivePublicLinkClient>;
+        /**
+         * Feed a raw core API event response into the SDK.
+         *
+         * The SDK will derive drive-relevant events (e.g. `SharedWithMeUpdated`)
+         * from it, update internal caches, and return the derived events.
+         *
+         * The `rawEvent` shape matches the response of the
+         * `core/v5/events/{id}` endpoint.
+         */
+        processCoreEvent: (rawEvent: CoreApiEvent) => Promise<DriveEvent[]>;
     };
 
     constructor({
@@ -255,6 +266,10 @@ export class ProtonDriveClient {
                     session,
                 });
             },
+            processCoreEvent: async (rawEvent: CoreApiEvent) => {
+                this.logger.debug(`Processing core event ${rawEvent.EventID}`);
+                return this.events.processCoreEvent(rawEvent);
+            },
         };
     }
 
@@ -293,6 +308,8 @@ export class ProtonDriveClient {
      * Subscribes to the remote general data updates.
      *
      * Only one instance of the SDK should subscribe to updates.
+     *
+     * @deprecated Use `experimental.processCoreEvent` instead.
      */
     async subscribeToDriveEvents(callback: DriveListener): Promise<EventSubscription> {
         this.logger.debug('Subscribing to core updates');

package/src/protonDrivePhotosClient.ts

@@ -2,6 +2,7 @@ import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { NullFeatureFlagProvider } from './featureFlags';
 import {
+    DriveEvent,
     FileDownloader,
     FileUploader,
     Logger,
@@ -26,7 +27,7 @@ import {
 } from './interface';
 import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
-import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
+import { CoreApiEvent, DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import {
     AlbumItem,
     initPhotoSharesModule,
@@ -82,6 +83,12 @@ export class ProtonDrivePhotosClient {
          * @param signal - An optional abort signal to cancel the operation.
          */
         iterateAlbumUids: (signal?: AbortSignal) => AsyncGenerator<string>;
+        /**
+         * Feed a raw core API event response into the SDK.
+         *
+         * See `ProtonDriveClient.experimental.processCoreEvent` for more information.
+         */
+        processCoreEvent: (rawEvent: CoreApiEvent) => Promise<DriveEvent[]>;
     };
 
     constructor({
@@ -186,6 +193,10 @@ export class ProtonDrivePhotosClient {
                 this.logger.debug('Iterating album UIDs');
                 return this.photos.albums.iterateAlbumUids(signal);
             },
+            processCoreEvent: async (rawEvent: CoreApiEvent) => {
+                this.logger.debug(`Processing core event ${rawEvent.EventID}`);
+                return this.events.processCoreEvent(rawEvent);
+            },
         };
     }
 
@@ -213,6 +224,8 @@ export class ProtonDrivePhotosClient {
      * Subscribes to the remote general data updates.
      *
      * See `ProtonDriveClient.subscribeToDriveEvents` for more information.
+     *
+     * @deprecated Use `experimental.processCoreEvent` instead.
      */
     async subscribeToDriveEvents(callback: DriveListener): Promise<EventSubscription> {
         this.logger.debug('Subscribing to core updates');
@@ -707,10 +720,7 @@ export class ProtonDrivePhotosClient {
      * @param signal - An optional abort signal to cancel the operation.
      * @returns An async generator of per-photo results.
      */
-    async *savePhotosToTimeline(
-        photoNodeUids: NodeOrUid[],
-        signal?: AbortSignal,
-    ): AsyncGenerator<NodeResultWithError> {
+    async *savePhotosToTimeline(photoNodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResultWithError> {
         this.logger.info(`Saving ${photoNodeUids.length} photos to timeline`);
         yield* this.photos.photos.saveToTimeline(getUids(photoNodeUids), signal);
     }