@protontech/drive-sdk 0.6.0 → 0.6.1

package/src/internal/shares/manager.ts

@@ -46,7 +46,7 @@ export class SharesManager {
      *
      * If the default volume or My files section doesn't exist, it creates it.
      */
-    async getOwnVolumeIDs(): Promise<VolumeShareNodeIDs> {
+    async getRootIDs(): Promise<VolumeShareNodeIDs> {
         if (this.myFilesIds) {
             return this.myFilesIds;
         }
@@ -140,7 +140,7 @@ export class SharesManager {
         addressKey: PrivateKey;
         addressKeyId: string;
     }> {
-        const { volumeId } = await this.getOwnVolumeIDs();
+        const { volumeId } = await this.getRootIDs();
 
         try {
             const { addressId } = await this.cache.getVolume(volumeId);
@@ -196,11 +196,11 @@ export class SharesManager {
     }
 
     async isOwnVolume(volumeId: string): Promise<boolean> {
-        return (await this.getOwnVolumeIDs()).volumeId === volumeId;
+        return (await this.getRootIDs()).volumeId === volumeId;
     }
 
     async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
-        const { volumeId: myVolumeId } = await this.getOwnVolumeIDs();
+        const { volumeId: myVolumeId } = await this.getRootIDs();
 
         // SDK doesn't support public sharing yet, also public sharing
         // doesn't use a volume but shareURL, thus we can simplify and

package/src/internal/sharing/interface.ts

@@ -142,7 +142,7 @@ export interface PublicLinkWithCreatorEmail extends PublicLink {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getOwnVolumeIDs(): Promise<{ volumeId: string }>;
+    getRootIDs(): Promise<{ volumeId: string }>;
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;

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

@@ -93,7 +93,7 @@ describe('SharingAccess', () => {
 
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             loadEncryptedShare: jest.fn().mockResolvedValue({
                 id: 'shareId',
                 membership: { memberUid: 'memberUid' },

package/src/internal/sharing/sharingAccess.ts

@@ -40,7 +40,7 @@ export class SharingAccess {
             const nodeUids = await this.cache.getSharedByMeNodeUids();
             yield* this.iterateSharedNodesFromCache(nodeUids, signal);
         } catch {
-            const { volumeId } = await this.sharesService.getOwnVolumeIDs();
+            const { volumeId } = await this.sharesService.getRootIDs();
             const nodeUidsIterator = this.apiService.iterateSharedNodeUids(volumeId, signal);
             yield* this.iterateSharedNodesFromAPI(
                 nodeUidsIterator,

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

@@ -1,5 +1,6 @@
 import { getMockLogger } from '../../tests/logger';
 import {
+    Logger,
     Member,
     MemberRole,
     NonProtonInvitation,
@@ -14,8 +15,11 @@ import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
 import { SharesService, NodesService } from './interface';
 import { SharingManagement } from './sharingManagement';
+import { ValidationError } from '../../errors';
+import { ErrorCode } from '../apiService';
 
 describe('SharingManagement', () => {
+    let logger: Logger;
     let apiService: SharingAPIService;
     let cache: SharingCache;
     let cryptoService: SharingCryptoService;
@@ -26,6 +30,8 @@ describe('SharingManagement', () => {
     let sharingManagement: SharingManagement;
 
     beforeEach(() => {
+        logger = getMockLogger();
+
         // @ts-expect-error No need to implement all methods for mocking
         apiService = {
             createStandardShare: jest.fn().mockReturnValue('newShareId'),
@@ -110,7 +116,7 @@ describe('SharingManagement', () => {
         };
 
         sharingManagement = new SharingManagement(
-            getMockLogger(),
+            logger,
             apiService,
             cache,
             cryptoService,
@@ -225,6 +231,58 @@ describe('SharingManagement', () => {
             expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith(nodeUid);
             expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith(nodeUid);
         });
+
+        it('should refresh node info if share already exists', async () => {
+            nodesService.getNode = jest
+                .fn()
+                .mockImplementationOnce((nodeUid) => ({
+                    nodeUid,
+                    parentUid: 'parentUid',
+                    name: { ok: true, value: 'name' },
+                }))
+                .mockImplementation((nodeUid) => ({
+                    nodeUid,
+                    shareId: 'shareId',
+                    parentUid: 'parentUid',
+                    name: { ok: true, value: 'name' },
+                }));
+            apiService.createStandardShare = jest
+                .fn()
+                .mockRejectedValue(new ValidationError('Share already exists', ErrorCode.ALREADY_EXISTS));
+
+            const sharingInfo = await sharingManagement.shareNode(nodeUid, { users: ['email'] });
+
+            expect(sharingInfo).toEqual({
+                protonInvitations: [
+                    {
+                        uid: 'created-invitation',
+                        addedByEmail: { ok: true, value: 'volume-email' },
+                        inviteeEmail: 'email',
+                        role: 'viewer',
+                    },
+                ],
+                nonProtonInvitations: [],
+                members: [],
+                publicLink: undefined,
+            });
+
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith(nodeUid);
+            expect(logger.debug).toHaveBeenCalledWith(
+                'Share already exists for node volumeId~nodeUid, refreshing node',
+            );
+            expect(apiService.inviteProtonUser).toHaveBeenCalledWith(
+                'shareId',
+                {
+                    addedByEmail: 'volume-email',
+                    inviteeEmail: 'email',
+                    role: 'viewer',
+                },
+                {
+                    message: undefined,
+                    nodeName: undefined,
+                },
+            );
+        });
     });
 
     describe('shareNode with share re-use', () => {

package/src/internal/sharing/sharingManagement.ts

@@ -15,6 +15,7 @@ import {
     ProtonDriveAccount,
     SharePublicLinkSettingsObject,
 } from '../../interface';
+import { ErrorCode } from '../apiService';
 import { splitNodeUid } from '../uids';
 import { getErrorMessage } from '../errors';
 import { SharingAPIService } from './apiService';
@@ -147,22 +148,40 @@ export class SharingManagement {
             throw new ValidationError(c('Error').t`Expiration date cannot be in the past`);
         }
 
-        let contextShareAddress: ContextShareAddress;
+        let contextShareAddress: ContextShareAddress | undefined;
         let currentSharing = await this.getInternalSharingInfo(nodeUid);
-        if (currentSharing) {
-            contextShareAddress = await this.nodesService.getRootNodeEmailKey(nodeUid);
-        } else {
+        if (!currentSharing) {
             const node = await this.nodesService.getNode(nodeUid);
-            const result = await this.createShare(nodeUid);
-            currentSharing = {
-                share: result.share,
-                nodeName: node.name.ok ? node.name.value : node.name.error.name,
-                protonInvitations: [],
-                nonProtonInvitations: [],
-                members: [],
-                publicLink: undefined,
-            };
-            contextShareAddress = result.contextShareAddress;
+            try {
+                const result = await this.createShare(nodeUid);
+                currentSharing = {
+                    share: result.share,
+                    nodeName: node.name.ok ? node.name.value : node.name.error.name,
+                    protonInvitations: [],
+                    nonProtonInvitations: [],
+                    members: [],
+                    publicLink: undefined,
+                };
+                contextShareAddress = result.contextShareAddress;
+            } catch (error: unknown) {
+                // If the share already exists, notify that the node has
+                // changed to force refresh and get the latest sharing info
+                // again.
+                if (error instanceof ValidationError && error.code === ErrorCode.ALREADY_EXISTS) {
+                    this.logger.debug(`Share already exists for node ${nodeUid}, refreshing node`);
+                    await this.nodesService.notifyNodeChanged(nodeUid);
+                    currentSharing = await this.getInternalSharingInfo(nodeUid);
+                } else {
+                    throw error;
+                }
+            }
+        }
+
+        if (!currentSharing) {
+            throw new ValidationError(c('Error').t`Failed to get sharing info for node ${nodeUid}`);
+        }
+        if (!contextShareAddress) {
+            contextShareAddress = await this.nodesService.getRootNodeEmailKey(nodeUid);
         }
 
         const emailOptions: EmailOptions = {

package/src/internal/sharingPublic/cryptoReporter.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
 import { VERIFICATION_STATUS } from '../../crypto';
-import { getVerificationMessage } from '../errors';
+import { getVerificationMessage, isNotApplicationError } from '../errors';
 import {
     resultOk,
     resultError,
@@ -49,6 +49,10 @@ export class SharingPublicCryptoReporter {
         field: MetricsDecryptionErrorField,
         error: unknown,
     ) {
+        if (isNotApplicationError(error)) {
+            return;
+        }
+
         const fromBefore2024 = node.creationTime < new Date('2024-01-01');
 
         this.logger.error(

package/src/internal/sharingPublic/index.ts

@@ -10,6 +10,7 @@ import { NodeAPIService } from '../nodes/apiService';
 import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesCryptoService } from '../nodes/cryptoService';
+import { NodesManagement } from '../nodes/nodesManagement';
 import { NodesRevisons } from '../nodes/nodesRevisions';
 import { SharingPublicCryptoReporter } from './cryptoReporter';
 import { SharingPublicNodesAccess } from './nodes';
@@ -96,10 +97,12 @@ export function initSharingPublicNodesModule(
         publicShareKey,
         publicRootNodeUid,
     );
+    const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess);
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 
     return {
         access: nodesAccess,
+        management: nodesManagement,
         revisions: nodesRevisions,
     };
 }

package/src/internal/sharingPublic/shares.ts

@@ -19,8 +19,7 @@ export class SharingPublicSharesManager {
         this.publicRootNodeUid = publicRootNodeUid;
     }
 
-    // TODO: Rename to getRootIDs everywhere.
-    async getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
+    async getRootIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
         const { volumeId, nodeId: rootNodeId } = splitNodeUid(this.publicRootNodeUid);
         return { volumeId, rootNodeId, rootNodeUid: this.publicRootNodeUid };
     }

package/src/protonDrivePhotosClient.ts

@@ -117,7 +117,7 @@ export class ProtonDrivePhotosClient {
             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,
@@ -454,6 +454,29 @@ export class ProtonDrivePhotosClient {
         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.
      *

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;
-}