@protontech/drive-sdk 0.7.0 → 0.7.1

package/src/internal/photos/index.ts

@@ -6,6 +6,10 @@ import {
     ProtonDriveEntitiesCache,
     ProtonDriveTelemetry,
 } from '../../interface';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { NodesCryptoReporter } from '../nodes/cryptoReporter';
+import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { ShareTargetType } from '../shares';
 import { SharesCache } from '../shares/cache';
 import { SharesCryptoCache } from '../shares/cryptoCache';
 import { SharesCryptoService } from '../shares/cryptoService';
@@ -14,7 +18,8 @@ import { UploadTelemetry } from '../upload/telemetry';
 import { UploadQueue } from '../upload/queue';
 import { Albums } from './albums';
 import { PhotosAPIService } from './apiService';
-import { NodesService, SharesService } from './interface';
+import { SharesService } from './interface';
+import { PhotosNodesAPIService, PhotosNodesAccess, PhotosNodesCache, PhotosNodesManagement } from './nodes';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
 import {
@@ -24,7 +29,10 @@ import {
     PhotoUploadManager,
     PhotoUploadMetadata,
 } from './upload';
-import { ShareTargetType } from '../shares';
+import { NodesRevisons } from '../nodes/nodesRevisions';
+import { NodesEventsHandler } from '../nodes/events';
+
+export type { DecryptedPhotoNode } from './interface';
 
 // Only photos and albums can be shared in photos volume.
 export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
@@ -40,7 +48,7 @@ export function initPhotosModule(
     apiService: DriveAPIService,
     driveCrypto: DriveCrypto,
     photoShares: PhotoSharesManager,
-    nodesService: NodesService,
+    nodesService: PhotosNodesAccess,
 ) {
     const api = new PhotosAPIService(apiService);
     const timeline = new PhotosTimeline(
@@ -89,6 +97,40 @@ export function initPhotoSharesModule(
     );
 }
 
+/**
+ * Provides facade for the photo nodes module.
+ *
+ * The photo nodes module wraps the core nodes module and adds photo specific
+ * metadata. It provides the same interface so it can be used in the same way.
+ */
+export function initPhotosNodesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    account: ProtonDriveAccount,
+    driveCrypto: DriveCrypto,
+    sharesService: PhotoSharesManager,
+    clientUid: string | undefined,
+) {
+    const api = new PhotosNodesAPIService(telemetry.getLogger('nodes-api'), apiService, clientUid);
+    const cache = new PhotosNodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
+    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 PhotosNodesAccess(telemetry, api, cache, cryptoCache, cryptoService, sharesService);
+    const nodesEventHandler = new NodesEventsHandler(telemetry.getLogger('nodes-events'), cache);
+    const nodesManagement = new PhotosNodesManagement(api, cryptoCache, cryptoService, nodesAccess);
+    const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
+
+    return {
+        access: nodesAccess,
+        management: nodesManagement,
+        revisions: nodesRevisions,
+        eventHandler: nodesEventHandler,
+    };
+}
+
 /**
  * Provides facade for the photo upload module.
  *

package/src/internal/photos/interface.ts

@@ -1,6 +1,6 @@
 import { PrivateKey } from '../../crypto';
-import { MissingNode, MetricVolumeType } from '../../interface';
-import { DecryptedNode } from '../nodes';
+import { MetricVolumeType, PhotoAttributes } from '../../interface';
+import { DecryptedNode, EncryptedNode, DecryptedUnparsedNode } from '../nodes/interface';
 import { EncryptedShare } from '../shares';
 
 export interface SharesService {
@@ -23,10 +23,22 @@ export interface SharesService {
     getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
 }
 
-export interface NodesService {
-    getNode(nodeUid: string): Promise<DecryptedNode>;
-    iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
-    getNodeKeys(nodeUid: string): Promise<{
-        hashKey?: Uint8Array;
-    }>;
-}
+export type EncryptedPhotoNode = EncryptedNode & {
+    photo?: EcnryptedPhotoAttributes;
+};
+
+export type DecryptedUnparsedPhotoNode = DecryptedUnparsedNode & {
+    photo?: PhotoAttributes;
+};
+
+export type DecryptedPhotoNode = DecryptedNode & {
+    photo?: PhotoAttributes;
+};
+
+export type EcnryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
+    contentHash?: string;
+    albums: (PhotoAttributes['albums'][0] & {
+        nameHash?: string;
+        contentHash?: string;
+    })[];
+};

package/src/internal/photos/nodes.ts

@@ -0,0 +1,233 @@
+import { PrivateKey } from '../../crypto';
+import { DecryptionError } from '../../errors';
+import { NodeType } from '../../interface';
+import { drivePaths } from '../apiService';
+import { NodeAPIServiceBase, linkToEncryptedNode, linkToEncryptedNodeBaseMetadata } from '../nodes/apiService';
+import { NodesCacheBase, serialiseNode, deserialiseNode } from '../nodes/cache';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { DecryptedNodeKeys } from '../nodes/interface';
+import { NodesAccessBase, parseNode as parseNodeBase } from '../nodes/nodesAccess';
+import { NodesManagementBase } from '../nodes/nodesManagement';
+import { makeNodeUid } from '../uids';
+import { EncryptedPhotoNode, DecryptedPhotoNode, DecryptedUnparsedPhotoNode } from './interface';
+
+type PostLoadLinksMetadataRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostLoadLinksMetadataResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
+
+export class PhotosNodesAPIService extends NodeAPIServiceBase<
+    EncryptedPhotoNode,
+    PostLoadLinksMetadataResponse['Links'][0]
+> {
+    protected async fetchNodeMetadata(volumeId: string, linkIds: string[], signal?: AbortSignal) {
+        const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(
+            `drive/photos/volumes/${volumeId}/links`,
+            {
+                LinkIDs: linkIds,
+            },
+            signal,
+        );
+        return response.Links;
+    }
+
+    protected linkToEncryptedNode(
+        volumeId: string,
+        link: PostLoadLinksMetadataResponse['Links'][0],
+        isOwnVolumeId: boolean,
+    ): EncryptedPhotoNode {
+        const { baseNodeMetadata, baseCryptoNodeMetadata } = linkToEncryptedNodeBaseMetadata(
+            this.logger,
+            volumeId,
+            link,
+            isOwnVolumeId,
+        );
+
+        if (link.Link.Type === 2 && link.Photo && link.Photo.ActiveRevision) {
+            const node = linkToEncryptedNode(
+                this.logger,
+                volumeId,
+                { ...link, File: link.Photo, Folder: null },
+                isOwnVolumeId,
+            );
+            return {
+                ...node,
+                type: NodeType.Photo,
+                photo: {
+                    captureTime: new Date(link.Photo.CaptureTime * 1000),
+                    mainPhotoNodeUid: link.Photo.MainPhotoLinkID
+                        ? makeNodeUid(volumeId, link.Photo.MainPhotoLinkID)
+                        : undefined,
+                    relatedPhotoNodeUids: link.Photo.RelatedPhotosLinkIDs.map((relatedLinkId) =>
+                        makeNodeUid(volumeId, relatedLinkId),
+                    ),
+                    contentHash: link.Photo.ContentHash || undefined,
+                    tags: link.Photo.Tags,
+                    albums: link.Photo.Albums.map((album) => ({
+                        nodeUid: makeNodeUid(volumeId, album.AlbumLinkID),
+                        additionTime: new Date(album.AddedTime * 1000),
+                        nameHash: album.Hash,
+                        contentHash: album.ContentHash,
+                    })),
+                },
+            };
+        }
+
+        if (link.Link.Type === 3) {
+            return {
+                ...baseNodeMetadata,
+                encryptedCrypto: {
+                    ...baseCryptoNodeMetadata,
+                },
+            };
+        }
+
+        const baseLink = {
+            Link: link.Link,
+            Membership: link.Membership,
+            Sharing: link.Sharing,
+            // @ts-expect-error The photo link can have a folder type, but not always. If not set, it will use other paths.
+            Folder: link.Folder,
+            File: null, // The photo link metadata never returns a file type.
+        };
+        return linkToEncryptedNode(this.logger, volumeId, baseLink, isOwnVolumeId);
+    }
+}
+
+export class PhotosNodesCache extends NodesCacheBase<DecryptedPhotoNode> {
+    serialiseNode(node: DecryptedPhotoNode): string {
+        return serialiseNode(node);
+    }
+
+    // TODO: use better deserialisation with validation
+    deserialiseNode(nodeData: string): DecryptedPhotoNode {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const node = deserialiseNode(nodeData) as any;
+
+        if (
+            !node ||
+            typeof node !== 'object' ||
+            (typeof node.photo !== 'object' && node.photo !== undefined) ||
+            (typeof node.photo?.captureTime !== 'string' && node.folder?.captureTime !== undefined) ||
+            (typeof node.photo?.albums !== 'object' && node.photo?.albums !== undefined)
+        ) {
+            throw new Error(`Invalid node data: ${nodeData}`);
+        }
+
+        return {
+            ...node,
+            photo: !node.photo
+                ? undefined
+                : {
+                      captureTime: new Date(node.photo.captureTime),
+                      mainPhotoNodeUid: node.photo.mainPhotoNodeUid,
+                      relatedPhotoNodeUids: node.photo.relatedPhotoNodeUids,
+                      contentHash: node.photo.contentHash,
+                      tags: node.photo.tags,
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      albums: node.photo.albums?.map((album: any) => ({
+                          nodeUid: album.nodeUid,
+                          additionTime: new Date(album.additionTime),
+                      })),
+                  },
+        } as DecryptedPhotoNode;
+    }
+}
+
+export class PhotosNodesAccess extends NodesAccessBase<EncryptedPhotoNode, DecryptedPhotoNode, PhotosNodesCryptoService> {
+    async getParentKeys(
+        node: Pick<EncryptedPhotoNode, 'uid' | 'parentUid' | 'shareId' | 'photo'>,
+    ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+        if (node.parentUid || node.shareId) {
+            return super.getParentKeys(node);
+        }
+
+        if (node.photo?.albums.length) {
+            // If photo is in multiple albums, we just need to get keys for one of them.
+            // Prefer to find a cached key first.
+            for (const album of node.photo.albums) {
+                try {
+                    const keys = await this.cryptoCache.getNodeKeys(album.nodeUid);
+                    return {
+                        key: keys.key,
+                        hashKey: keys.hashKey,
+                    };
+                } catch {
+                    // We ignore missing or invalid keys here, its just optimization.
+                    // If it cannot be fixed, it will bubble up later when requesting
+                    // the node keys for one of the albums.
+                }
+            }
+
+            const albumNodeUid = node.photo.albums[0].nodeUid;
+            return this.getNodeKeys(albumNodeUid);
+        }
+
+        // This is bug that should not happen.
+        // API cannot provide node without parent or share or album.
+        throw new Error('Node has neither parent node nor share nor album');
+    }
+
+    protected getDegradedUndecryptableNode(
+        encryptedNode: EncryptedPhotoNode,
+        error: DecryptionError,
+    ): DecryptedPhotoNode {
+        return this.getDegradedUndecryptableNodeBase(encryptedNode, error);
+    }
+
+    protected parseNode(unparsedNode: DecryptedUnparsedPhotoNode): DecryptedPhotoNode {
+        if (unparsedNode.type === NodeType.Photo) {
+            const node = parseNodeBase(this.logger, {
+                ...unparsedNode,
+                type: NodeType.File,
+            });
+            return {
+                ...node,
+                photo: unparsedNode.photo,
+            };
+        }
+
+        return parseNodeBase(this.logger, unparsedNode);
+    }
+}
+
+export class PhotosNodesCryptoService extends NodesCryptoService {
+    async decryptNode(
+        encryptedNode: EncryptedPhotoNode,
+        parentKey: PrivateKey,
+    ): Promise<{ node: DecryptedUnparsedPhotoNode; keys?: DecryptedNodeKeys }> {
+        const decryptedNode = await super.decryptNode(encryptedNode, parentKey);
+
+        if (decryptedNode.node.type === NodeType.Photo) {
+            return {
+                node: {
+                    ...decryptedNode.node,
+                    photo: encryptedNode.photo,
+                },
+            };
+        }
+
+        return decryptedNode;
+    }
+}
+
+export class PhotosNodesManagement extends NodesManagementBase<
+    EncryptedPhotoNode,
+    DecryptedPhotoNode,
+    PhotosNodesCryptoService
+> {
+    protected generateNodeFolder(
+        nodeUid: string,
+        parentNodeUid: string,
+        name: string,
+        encryptedCrypto: {
+            hash: string;
+            encryptedName: string;
+            signatureEmail: string | null;
+        },
+    ): DecryptedPhotoNode {
+        return this.generateNodeFolderBase(nodeUid, parentNodeUid, name, encryptedCrypto);
+    }
+}

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

@@ -2,7 +2,7 @@ import { getMockLogger } from '../../tests/logger';
 import { DriveCrypto } from '../../crypto';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
-import { NodesService } from './interface';
+import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
 
@@ -11,7 +11,7 @@ describe('PhotosTimeline', () => {
     let apiService: PhotosAPIService;
     let driveCrypto: DriveCrypto;
     let photoShares: PhotoSharesManager;
-    let nodesService: NodesService;
+    let nodesService: PhotosNodesAccess;
     let timeline: PhotosTimeline;
 
     const volumeId = 'volumeId';

package/src/internal/photos/timeline.ts

@@ -2,7 +2,7 @@ import { DriveCrypto } from '../../crypto';
 import { Logger } from '../../interface';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
-import { NodesService } from './interface';
+import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 
 /**
@@ -14,7 +14,7 @@ export class PhotosTimeline {
         private apiService: PhotosAPIService,
         private driveCrypto: DriveCrypto,
         private photoShares: PhotoSharesManager,
-        private nodesService: NodesService,
+        private nodesService: PhotosNodesAccess,
     ) {
         this.logger = logger;
         this.apiService = apiService;

package/src/protonDriveClient.ts

@@ -424,6 +424,12 @@ export class ProtonDriveClient {
      * The operation is performed node by node and the results are yielded
      * as they are available. Order of the results is not guaranteed.
      *
+     * The `nodeUids` can be a list of node entities or their UIDs, or a list
+     * of objects with `uid` and `name` properties where the name is the new
+     * name of the copied node. By default, the name is the same as the
+     * original node. Use `getAvailableName` to get the available name for the
+     * new node in the target parent node in case of a name conflict.
+     *
      * If one of the nodes fails to copy, the operation continues with the
      * rest of the nodes. Use `NodeResult` to check the status of the action.
      *
@@ -433,12 +439,23 @@ export class ProtonDriveClient {
      * @returns An async generator of the results of the copy operation
      */
     async *copyNodes(
-        nodeUids: NodeOrUid[],
+        nodesOrNodeUidsOrWithNames: (NodeOrUid | { uid: string; name: string })[],
         newParentNodeUid: NodeOrUid,
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResultWithNewUid> {
-        this.logger.info(`Copying ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
-        yield* this.nodes.management.copyNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
+        this.logger.info(`Copying ${nodesOrNodeUidsOrWithNames.length} nodes to ${getUid(newParentNodeUid)}`);
+
+        const nodeUidsOrWithNames = nodesOrNodeUidsOrWithNames.map((param) => {
+            if (typeof param === 'string') {
+                return param;
+            }
+            if ('uid' in param && 'name' in param && typeof param.uid === 'string' && typeof param.name === 'string') {
+                return { uid: param.uid, name: param.name };
+            }
+            return getUid(param);
+        });
+
+        yield* this.nodes.management.copyNodes(nodeUidsOrWithNames, getUid(newParentNodeUid), signal);
     }
 
     /**

package/src/protonDrivePhotosClient.ts

@@ -2,12 +2,12 @@ import {
     Logger,
     ProtonDriveClientContructorParameters,
     NodeOrUid,
-    MaybeMissingNode,
+    MaybeMissingPhotoNode,
     UploadMetadata,
     FileDownloader,
     FileUploader,
     SDKEvent,
-    MaybeNode,
+    MaybePhotoNode,
     ThumbnailType,
     ThumbnailResult,
     ShareNodeSettings,
@@ -22,22 +22,22 @@ import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { Telemetry } from './telemetry';
 import {
-    convertInternalMissingNodeIterator,
-    convertInternalNode,
-    convertInternalNodeIterator,
-    convertInternalNodePromise,
+    convertInternalMissingPhotoNodeIterator,
+    convertInternalPhotoNode,
+    convertInternalPhotoNodeIterator,
+    convertInternalPhotoNodePromise,
     getUid,
     getUids,
 } from './transformers';
 import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
-import { initNodesModule } from './internal/nodes';
 import {
     PHOTOS_SHARE_TARGET_TYPES,
     initPhotosModule,
     initPhotoSharesModule,
     initPhotoUploadModule,
+    initPhotosNodesModule,
 } from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
@@ -56,7 +56,7 @@ export class ProtonDrivePhotosClient {
     private sdkEvents: SDKEvents;
     private events: DriveEventsService;
     private photoShares: ReturnType<typeof initPhotoSharesModule>;
-    private nodes: ReturnType<typeof initNodesModule>;
+    private nodes: ReturnType<typeof initPhotosNodesModule>;
     private sharing: ReturnType<typeof initSharingModule>;
     private download: ReturnType<typeof initDownloadModule>;
     private upload: ReturnType<typeof initPhotoUploadModule>;
@@ -107,7 +107,7 @@ export class ProtonDrivePhotosClient {
             cryptoModule,
             coreShares,
         );
-        this.nodes = initNodesModule(
+        this.nodes = initPhotosNodesModule(
             telemetry,
             apiService,
             entitiesCache,
@@ -224,9 +224,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateTrashedNodes` for more information.
      */
-    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating trashed nodes');
-        yield* convertInternalNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
+        yield * convertInternalPhotoNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
     }
 
     /**
@@ -234,10 +234,10 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateNodes` for more information.
      */
-    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingNode> {
+    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingPhotoNode> {
         this.logger.info(`Iterating ${nodeUids.length} nodes`);
         // TODO: expose photo type
-        yield* convertInternalMissingNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
+        yield * convertInternalMissingPhotoNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
     }
 
     /**
@@ -245,9 +245,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.getNode` for more information.
      */
-    async getNode(nodeUid: NodeOrUid): Promise<MaybeNode> {
+    async getNode(nodeUid: NodeOrUid): Promise<MaybePhotoNode> {
         this.logger.info(`Getting node ${getUid(nodeUid)}`);
-        return convertInternalNodePromise(this.nodes.access.getNode(getUid(nodeUid)));
+        return convertInternalPhotoNodePromise(this.nodes.access.getNode(getUid(nodeUid)));
     }
 
     /**
@@ -255,9 +255,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.renameNode` for more information.
      */
-    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
+    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybePhotoNode> {
         this.logger.info(`Renaming node ${getUid(nodeUid)}`);
-        return convertInternalNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
+        return convertInternalPhotoNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
     }
 
     /**
@@ -305,9 +305,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateSharedNodes` for more information.
      */
-    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating shared nodes by me');
-        yield* convertInternalNodeIterator(this.sharing.access.iterateSharedNodes(signal));
+        yield * convertInternalPhotoNodeIterator(this.sharing.access.iterateSharedNodes(signal));
     }
 
     /**
@@ -315,11 +315,11 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateSharedNodesWithMe` for more information.
      */
-    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating shared nodes with me');
 
         for await (const node of this.sharing.access.iterateSharedNodesWithMe(signal)) {
-            yield convertInternalNode(node);
+            yield convertInternalPhotoNode(node);
         }
     }
 
@@ -482,9 +482,9 @@ export class ProtonDrivePhotosClient {
      *
      * The output is not sorted and the order of the nodes is not guaranteed.
      */
-    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating albums');
         // TODO: expose album type
-        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+        yield * convertInternalPhotoNodeIterator(this.photos.albums.iterateAlbums(signal));
     }
 }

package/src/protonDrivePublicLinkClient.ts

@@ -18,6 +18,7 @@ import {
     UploadMetadata,
     FileUploader,
     NodeResult,
+    SDKEvent,
 } from './interface';
 import { Telemetry } from './telemetry';
 import {
@@ -164,6 +165,16 @@ export class ProtonDrivePublicLinkClient {
         };
     }
 
+    /**
+     * Subscribes to the general SDK events.
+     *
+     * See `ProtonDriveClient.onMessage` for more information.
+     */
+    onMessage(eventName: SDKEvent, callback: () => void): () => void {
+        this.logger.debug(`Subscribing to event ${eventName}`);
+        return this.sdkEvents.addListener(eventName, callback);
+    }
+
     /**
      * @returns The root folder to the public link.
      */