@protontech/drive-sdk 0.7.0 → 0.7.2

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,
@@ -197,6 +197,14 @@ export class ProtonDrivePhotosClient {
         return this.events.subscribeToCoreEvents(callback);
     }
 
+    /**
+     * @returns The root folder to Photos section of the user.
+     */
+    async getMyPhotosRootFolder(): Promise<MaybePhotoNode> {
+        this.logger.info('Getting my photos root folder');
+        return convertInternalPhotoNodePromise(this.nodes.access.getVolumeRootFolder());
+    }
+
     /**
      * Iterates all the photos for the timeline view.
      *
@@ -224,9 +232,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 +242,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 +253,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 +263,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 +313,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 +323,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 +490,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.
      */

package/src/transformers.ts

@@ -1,15 +1,19 @@
 import {
     MaybeNode as PublicMaybeNode,
     MaybeMissingNode as PublicMaybeMissingNode,
-    NodeEntity as PublicNodeEntity,
     DegradedNode as PublicDegradedNode,
     Revision as PublicRevision,
     Result,
     resultOk,
     resultError,
     MissingNode,
+    MaybePhotoNode as PublicMaybePhotoNode,
+    MaybeMissingPhotoNode as PublicMaybeMissingPhotoNode,
+    PhotoNode as PublicPhotoNode,
+    DegradedPhotoNode as PublicDegradedPhotoNode,
 } from './interface';
 import { DecryptedNode as InternalNode, DecryptedRevision as InternalRevision } from './internal/nodes';
+import { DecryptedPhotoNode as InternalPartialPhotoNode } from './internal/photos';
 
 type InternalPartialNode = Pick<
     InternalNode,
@@ -25,6 +29,7 @@ type InternalPartialNode = Pick<
     | 'isShared'
     | 'isSharedPublicly'
     | 'creationTime'
+    | 'modificationTime'
     | 'trashTime'
     | 'activeRevision'
     | 'folder'
@@ -93,6 +98,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         isShared: node.isShared,
         isSharedPublicly: node.isSharedPublicly,
         creationTime: node.creationTime,
+        modificationTime: node.modificationTime,
         trashTime: node.trashTime,
         totalStorageSize: node.totalStorageSize,
         folder: node.folder,
@@ -118,7 +124,48 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         ...baseNodeMetadata,
         name: name.value,
         activeRevision: activeRevision?.ok ? convertInternalRevision(activeRevision.value) : undefined,
-    } as PublicNodeEntity);
+    });
+}
+
+export async function* convertInternalPhotoNodeIterator(
+    photoNodeIterator: AsyncGenerator<InternalPartialPhotoNode>,
+): AsyncGenerator<PublicMaybePhotoNode> {
+    for await (const photoNode of photoNodeIterator) {
+        yield convertInternalPhotoNode(photoNode);
+    }
+}
+
+export async function* convertInternalMissingPhotoNodeIterator(
+    photoNodeIterator: AsyncGenerator<InternalPartialPhotoNode | MissingNode>,
+): AsyncGenerator<PublicMaybeMissingPhotoNode> {
+    for await (const photoNode of photoNodeIterator) {
+        if ('missingUid' in photoNode) {
+            yield resultError(photoNode);
+        } else {
+            yield convertInternalPhotoNode(photoNode);
+        }
+    }
+}
+
+export async function convertInternalPhotoNodePromise(
+    photoNodePromise: Promise<InternalPartialPhotoNode>,
+): Promise<PublicMaybePhotoNode> {
+    const photoNode = await photoNodePromise;
+    return convertInternalPhotoNode(photoNode);
+}
+
+export function convertInternalPhotoNode(photoNode: InternalPartialPhotoNode): PublicMaybePhotoNode {
+    const node = convertInternalNode(photoNode);
+    if (node.ok) {
+        return resultOk({
+            ...node.value,
+            photo: photoNode.photo,
+        } as PublicPhotoNode);
+    }
+    return resultError({
+        ...node.error,
+        photo: photoNode.photo,
+    } as PublicDegradedPhotoNode);
 }
 
 export async function* convertInternalRevisionIterator(