@protontech/drive-sdk 0.5.1 → 0.6.1

package/src/protonDrivePhotosClient.ts

@@ -10,12 +10,20 @@ import {
     MaybeNode,
     ThumbnailType,
     ThumbnailResult,
+    ShareNodeSettings,
+    ShareResult,
+    UnshareNodeSettings,
+    ProtonInvitationOrUid,
+    NonProtonInvitationOrUid,
+    ProtonInvitationWithNode,
+    NodeResult,
 } from './interface';
 import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { Telemetry } from './telemetry';
 import {
     convertInternalMissingNodeIterator,
+    convertInternalNode,
     convertInternalNodeIterator,
     convertInternalNodePromise,
     getUid,
@@ -25,7 +33,12 @@ import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import { initNodesModule } from './internal/nodes';
-import { initPhotosModule, initPhotoSharesModule, initPhotoUploadModule } from './internal/photos';
+import {
+    PHOTOS_SHARE_TARGET_TYPES,
+    initPhotosModule,
+    initPhotoSharesModule,
+    initPhotoUploadModule,
+} from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
 import { initSharingModule } from './internal/sharing';
@@ -72,7 +85,7 @@ export class ProtonDrivePhotosClient {
         if (!telemetry) {
             telemetry = new Telemetry();
         }
-        this.logger = telemetry.getLogger('interface');
+        this.logger = telemetry.getLogger('photos-interface');
 
         const fullConfig = getConfig(config);
         this.sdkEvents = new SDKEvents(telemetry);
@@ -102,8 +115,9 @@ export class ProtonDrivePhotosClient {
             account,
             cryptoModule,
             this.photoShares,
+            fullConfig.clientUid,
         );
-        this.photos = initPhotosModule(apiService, this.photoShares, this.nodes.access);
+        this.photos = initPhotosModule(telemetry, apiService, cryptoModule, this.photoShares, this.nodes.access);
         this.sharing = initSharingModule(
             telemetry,
             apiService,
@@ -112,6 +126,7 @@ export class ProtonDrivePhotosClient {
             cryptoModule,
             this.photoShares,
             this.nodes.access,
+            PHOTOS_SHARE_TARGET_TYPES,
         );
         this.download = initDownloadModule(
             telemetry,
@@ -204,6 +219,16 @@ export class ProtonDrivePhotosClient {
         yield* this.photos.timeline.iterateTimeline(signal);
     }
 
+    /**
+     * Iterates the trashed nodes.
+     *
+     * See `ProtonDriveClient.iterateTrashedNodes` for more information.
+     */
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating trashed nodes');
+        yield* convertInternalNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
+    }
+
     /**
      * Iterates the nodes by their UIDs.
      *
@@ -226,14 +251,163 @@ export class ProtonDrivePhotosClient {
     }
 
     /**
-     * Iterates the albums.
+     * Rename the node.
      *
-     * The output is not sorted and the order of the nodes is not guaranteed.
+     * See `ProtonDriveClient.renameNode` for more information.
      */
-    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
-        this.logger.info('Iterating albums');
-        // TODO: expose album type
-        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
+        this.logger.info(`Renaming node ${getUid(nodeUid)}`);
+        return convertInternalNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
+    }
+
+    /**
+     * Trash the nodes.
+     *
+     * See `ProtonDriveClient.trashNodes` for more information.
+     */
+    async *trashNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Trashing ${nodeUids.length} nodes`);
+        yield* this.nodes.management.trashNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Restore the nodes from the trash to their original place.
+     *
+     * See `ProtonDriveClient.restoreNodes` for more information.
+     */
+    async *restoreNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Restoring ${nodeUids.length} nodes`);
+        yield* this.nodes.management.restoreNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Delete the nodes permanently.
+     *
+     * See `ProtonDriveClient.deleteNodes` for more information.
+     */
+    async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Deleting ${nodeUids.length} nodes`);
+        yield* this.nodes.management.deleteNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Empty the trash.
+     *
+     * See `ProtonDriveClient.emptyTrash` for more information.
+     */
+    async emptyTrash(): Promise<void> {
+        this.logger.info('Emptying trash');
+        throw new Error('Method not implemented');
+    }
+
+    /**
+     * Iterates the nodes shared by the user.
+     *
+     * See `ProtonDriveClient.iterateSharedNodes` for more information.
+     */
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating shared nodes by me');
+        yield* convertInternalNodeIterator(this.sharing.access.iterateSharedNodes(signal));
+    }
+
+    /**
+     * Iterates the nodes shared with the user.
+     *
+     * See `ProtonDriveClient.iterateSharedNodesWithMe` for more information.
+     */
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating shared nodes with me');
+
+        for await (const node of this.sharing.access.iterateSharedNodesWithMe(signal)) {
+            yield convertInternalNode(node);
+        }
+    }
+
+    /**
+     * Leave shared node that was previously shared with the user.
+     *
+     * See `ProtonDriveClient.leaveSharedNode` for more information.
+     */
+    async leaveSharedNode(nodeUid: NodeOrUid): Promise<void> {
+        this.logger.info(`Leaving shared node with me ${getUid(nodeUid)}`);
+        await this.sharing.access.removeSharedNodeWithMe(getUid(nodeUid));
+    }
+
+    /**
+     * Iterates the invitations to shared nodes.
+     *
+     * See `ProtonDriveClient.iterateInvitations` for more information.
+     */
+    async *iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
+        this.logger.info('Iterating invitations');
+        yield* this.sharing.access.iterateInvitations(signal);
+    }
+
+    /**
+     * Accept the invitation to the shared node.
+     *
+     * See `ProtonDriveClient.acceptInvitation` for more information.
+     */
+    async acceptInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Accepting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.acceptInvitation(getUid(invitationUid));
+    }
+
+    /**
+     * Reject the invitation to the shared node.
+     *
+     * See `ProtonDriveClient.rejectInvitation` for more information.
+     */
+    async rejectInvitation(invitationUid: ProtonInvitationOrUid): Promise<void> {
+        this.logger.info(`Rejecting invitation ${getUid(invitationUid)}`);
+        await this.sharing.access.rejectInvitation(getUid(invitationUid));
+    }
+
+    /**
+     * Get sharing info of the node.
+     *
+     * See `ProtonDriveClient.getSharingInfo` for more information.
+     */
+    async getSharingInfo(nodeUid: NodeOrUid): Promise<ShareResult | undefined> {
+        this.logger.info(`Getting sharing info for ${getUid(nodeUid)}`);
+        return this.sharing.management.getSharingInfo(getUid(nodeUid));
+    }
+
+    /**
+     * Share or update sharing of the node.
+     *
+     * See `ProtonDriveClient.shareNode` for more information.
+     */
+    async shareNode(nodeUid: NodeOrUid, settings: ShareNodeSettings): Promise<ShareResult> {
+        this.logger.info(`Sharing node ${getUid(nodeUid)}`);
+        return this.sharing.management.shareNode(getUid(nodeUid), settings);
+    }
+
+    /**
+     * Unshare the node, completely or partially.
+     *
+     * See `ProtonDriveClient.unshareNode` for more information.
+     */
+    async unshareNode(nodeUid: NodeOrUid, settings?: UnshareNodeSettings): Promise<ShareResult | undefined> {
+        if (!settings) {
+            this.logger.info(`Unsharing node ${getUid(nodeUid)}`);
+        } else {
+            this.logger.info(`Partially unsharing ${getUid(nodeUid)}`);
+        }
+        return this.sharing.management.unshareNode(getUid(nodeUid), settings);
+    }
+
+    /**
+     * Resend the invitation email to shared node.
+     *
+     * See `ProtonDriveClient.resendInvitation` for more information.
+     */
+    async resendInvitation(
+        nodeUid: NodeOrUid,
+        invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid,
+    ): Promise<void> {
+        this.logger.info(`Resending invitation ${getUid(invitationUid)}`);
+        return this.sharing.management.resendInvitationEmail(getUid(nodeUid), getUid(invitationUid));
     }
 
     /**
@@ -279,4 +453,38 @@ export class ProtonDrivePhotosClient {
         const parentFolderUid = await this.nodes.access.getVolumeRootFolder();
         return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
     }
+
+    /**
+     * Check if the photo is a duplicate.
+     *
+     * For given photo name, find existing photos with the same name
+     * in the timeline and check if the photo content is also the same.
+     * Only the same name is not considered as duplicate photo because
+     * it is expected that there are photos with the same name (e.g.,
+     * date as a name from multiple cameras, or rolling number).
+     *
+     * The function accepts a callback to generate the SHA1 and it is
+     * called only when there is any matching node name hash to avoid
+     * computation for every node if its not necessary.
+     *
+     * @param name - The name of the photo to check for duplicates.
+     * @param generateSha1 - A callback to generate the hex string representation of the SHA1 of the photo content.
+     * @param signal - An optional abort signal to cancel the operation.
+     * @returns True if the photo already exists in the timeline, false otherwise.
+     */
+    async isDuplicatePhoto(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<boolean> {
+        this.logger.info(`Checking if photo is a duplicate`);
+        return this.photos.timeline.isDuplicatePhoto(name, generateSha1, signal);
+    }
+
+    /**
+     * Iterates the albums.
+     *
+     * The output is not sorted and the order of the nodes is not guaranteed.
+     */
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+        this.logger.info('Iterating albums');
+        // TODO: expose album type
+        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+    }
 }

package/src/protonDrivePublicLinkClient.ts

@@ -15,6 +15,9 @@ import {
     FileDownloader,
     ThumbnailType,
     ThumbnailResult,
+    UploadMetadata,
+    FileUploader,
+    NodeResult,
 } from './interface';
 import { Telemetry } from './telemetry';
 import {
@@ -28,6 +31,7 @@ import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharingPublicModule } from './internal/sharingPublic';
+import { initUploadModule } from './internal/upload';
 
 /**
  * ProtonDrivePublicLinkClient is the interface for the public link client.
@@ -47,6 +51,7 @@ export class ProtonDrivePublicLinkClient {
     private sdkEvents: SDKEvents;
     private sharingPublic: ReturnType<typeof initSharingPublicModule>;
     private download: ReturnType<typeof initDownloadModule>;
+    private upload: ReturnType<typeof initUploadModule>;
 
     public experimental: {
         /**
@@ -91,7 +96,7 @@ export class ProtonDrivePublicLinkClient {
         if (!telemetry) {
             telemetry = new Telemetry();
         }
-        this.logger = telemetry.getLogger('interface');
+        this.logger = telemetry.getLogger('publicLink-interface');
 
         // Use only in memory cache for public link as there are no events to keep it up to date if persisted.
         const entitiesCache = new MemoryCache<string>();
@@ -129,6 +134,14 @@ export class ProtonDrivePublicLinkClient {
             this.sharingPublic.nodes.access,
             this.sharingPublic.nodes.revisions,
         );
+        this.upload = initUploadModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            this.sharingPublic.shares,
+            this.sharingPublic.nodes.access,
+            fullConfig.clientUid,
+        );
 
         this.experimental = {
             getNodeUrl: async (nodeUid: NodeOrUid) => {
@@ -151,7 +164,7 @@ export class ProtonDrivePublicLinkClient {
      */
     async getRootNode(): Promise<MaybeNode> {
         this.logger.info(`Getting root node`);
-        const { rootNodeUid } = await this.sharingPublic.shares.getOwnVolumeIDs();
+        const { rootNodeUid } = await this.sharingPublic.shares.getRootIDs();
         return convertInternalNodePromise(this.sharingPublic.nodes.access.getNode(rootNodeUid));
     }
 
@@ -193,6 +206,38 @@ export class ProtonDrivePublicLinkClient {
         return convertInternalNodePromise(this.sharingPublic.nodes.access.getNode(getUid(nodeUid)));
     }
 
+    /**
+     * Rename the node.
+     *
+     * See `ProtonDriveClient.renameNode` for more information.
+     */
+    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
+        this.logger.info(`Renaming node ${getUid(nodeUid)}`);
+        return convertInternalNodePromise(this.sharingPublic.nodes.management.renameNode(getUid(nodeUid), newName));
+    }
+
+    /**
+     * Delete the nodes permanently.
+     *
+     * See `ProtonDriveClient.deleteNodes` for more information.
+     */
+    async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        this.logger.info(`Deleting ${nodeUids.length} nodes`);
+        yield* this.sharingPublic.nodes.management.deleteNodes(getUids(nodeUids), signal);
+    }
+
+    /**
+     * Create a new folder.
+     *
+     * See `ProtonDriveClient.createFolder` for more information.
+     */
+    async createFolder(parentNodeUid: NodeOrUid, name: string, modificationTime?: Date): Promise<MaybeNode> {
+        this.logger.info(`Creating folder in ${getUid(parentNodeUid)}`);
+        return convertInternalNodePromise(
+            this.sharingPublic.nodes.management.createFolder(getUid(parentNodeUid), name, modificationTime),
+        );
+    }
+
     /**
      * Get the file downloader to download the node content.
      *
@@ -216,4 +261,34 @@ export class ProtonDrivePublicLinkClient {
         this.logger.info(`Iterating ${nodeUids.length} thumbnails`);
         yield* this.download.iterateThumbnails(getUids(nodeUids), thumbnailType, signal);
     }
+
+    /**
+     * Get the file uploader to upload a new file. For uploading a new
+     * revision, use `getFileRevisionUploader` instead.
+     *
+     * See `ProtonDriveClient.getFileUploader` for more information.
+     */
+    async getFileUploader(
+        parentFolderUid: NodeOrUid,
+        name: string,
+        metadata: UploadMetadata,
+        signal?: AbortSignal,
+    ): Promise<FileUploader> {
+        this.logger.info(`Getting file uploader for parent ${getUid(parentFolderUid)}`);
+        return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
+    }
+
+    /**
+     * Same as `getFileUploader`, but for a uploading new revision of the file.
+     *
+     * See `ProtonDriveClient.getFileRevisionUploader` for more information.
+     */
+    async getFileRevisionUploader(
+        nodeUid: NodeOrUid,
+        metadata: UploadMetadata,
+        signal?: AbortSignal,
+    ): Promise<FileUploader> {
+        this.logger.info(`Getting file revision uploader for ${getUid(nodeUid)}`);
+        return this.upload.getFileRevisionUploader(getUid(nodeUid), metadata, signal);
+    }
 }

package/dist/diagnostic/sdkDiagnostic.d.ts

@@ -1,23 +0,0 @@
-import { MaybeNode } from '../interface';
-import { ProtonDriveClient } from '../protonDriveClient';
-import { DiagnosticOptions, DiagnosticResult } from './interface';
-/**
- * Diagnostic tool that uses SDK to traverse the node tree and verify
- * the integrity of the node tree.
- *
- * It produces only events that can be read by direct SDK invocation.
- * To get the full diagnostic, use {@link FullSDKDiagnostic}.
- */
-export declare class SDKDiagnostic {
-    private protonDriveClient;
-    constructor(protonDriveClient: ProtonDriveClient);
-    verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult>;
-    verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult>;
-    private verifyNode;
-    private verifyAuthor;
-    private verifyFileExtendedAttributes;
-    private verifyContent;
-    private verifyThumbnails;
-    private verifyNodeChildren;
-    private verifyExpectedNodeChildren;
-}