@protontech/drive-sdk 0.5.1 → 0.6.1

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';
@@ -78,7 +79,8 @@ export function initSharingPublicNodesModule(
     publicShareKey: PrivateKey,
     publicRootNodeUid: string,
 ) {
-    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    const clientUid = undefined; // No client UID for public context yet.
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService, clientUid);
     const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
     const cryptoReporter = new SharingPublicCryptoReporter(telemetry);
@@ -95,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/internal/upload/apiService.ts

@@ -6,13 +6,6 @@ import { splitNodeUid, makeNodeUid, splitNodeRevisionUid, makeNodeRevisionUid }
 import { UploadTokens } from './interface';
 import { ThumbnailType } from '../../interface';
 
-type PostCheckAvailableHashesRequest = Extract<
-    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['requestBody'],
-    { content: object }
->['content']['application/json'];
-type PostCheckAvailableHashesResponse =
-    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['responses']['200']['content']['application/json'];
-
 type PostCreateDraftRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['requestBody'],
     { content: object }
@@ -60,38 +53,6 @@ export class UploadAPIService {
         this.clientUid = clientUid;
     }
 
-    async checkAvailableHashes(
-        parentNodeUid: string,
-        hashes: string[],
-    ): Promise<{
-        availalbleHashes: string[];
-        pendingHashes: {
-            hash: string;
-            nodeUid: string;
-            revisionUid: string;
-            clientUid?: string;
-        }[];
-    }> {
-        const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentNodeUid);
-        const result = await this.apiService.post<PostCheckAvailableHashesRequest, PostCheckAvailableHashesResponse>(
-            `drive/v2/volumes/${volumeId}/links/${parentNodeId}/checkAvailableHashes`,
-            {
-                Hashes: hashes,
-                ClientUID: this.clientUid ? [this.clientUid] : null,
-            },
-        );
-
-        return {
-            availalbleHashes: result.AvailableHashes,
-            pendingHashes: result.PendingHashes.map((hash) => ({
-                hash: hash.Hash,
-                nodeUid: makeNodeUid(volumeId, hash.LinkID),
-                revisionUid: makeNodeRevisionUid(volumeId, hash.LinkID, hash.RevisionID),
-                clientUid: hash.ClientUID || undefined,
-            })),
-        };
-    }
-
     async createDraft(
         parentNodeUid: string,
         node: {

package/src/internal/upload/cryptoService.ts

@@ -40,15 +40,6 @@ export class UploadCryptoService {
         };
     }
 
-    async generateNameHashes(parentHashKey: Uint8Array, names: string[]): Promise<{ name: string; hash: string }[]> {
-        return Promise.all(
-            names.map(async (name) => ({
-                name,
-                hash: await this.driveCrypto.generateLookupHash(name, parentHashKey),
-            })),
-        );
-    }
-
     async encryptThumbnail(
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
         thumbnail: Thumbnail,

package/src/internal/upload/fileUploader.ts

@@ -176,11 +176,6 @@ export class FileUploader extends Uploader {
             blockVerifier,
         };
     }
-
-    async getAvailableName(): Promise<string> {
-        const availableName = await this.manager.findAvailableName(this.parentFolderUid, this.name);
-        return availableName;
-    }
 }
 
 /**

package/src/internal/upload/manager.test.ts

@@ -26,10 +26,6 @@ describe('UploadManager', () => {
                 nodeRevisionUid: 'newNode:nodeRevisionUid',
             }),
             deleteDraft: jest.fn(),
-            checkAvailableHashes: jest.fn().mockResolvedValue({
-                availalbleHashes: ['name1Hash'],
-                pendingHashes: [],
-            }),
             commitDraftRevision: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
@@ -58,20 +54,6 @@ describe('UploadManager', () => {
                     email: 'signatureEmail',
                 },
             }),
-            generateNameHashes: jest.fn().mockResolvedValue([
-                {
-                    name: 'name1',
-                    hash: 'name1Hash',
-                },
-                {
-                    name: 'name2',
-                    hash: 'name2Hash',
-                },
-                {
-                    name: 'name3',
-                    hash: 'name3Hash',
-                },
-            ]),
             commitFile: jest.fn().mockResolvedValue({
                 armoredManifestSignature: 'newNode:armoredManifestSignature',
                 signatureEmail: 'signatureEmail',
@@ -280,53 +262,6 @@ describe('UploadManager', () => {
         });
     });
 
-    describe('findAvailableName', () => {
-        it('should find available name', async () => {
-            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                return {
-                    availalbleHashes: ['name3Hash'],
-                    pendingHashes: [],
-                };
-            });
-
-            const result = await manager.findAvailableName('parentUid', 'name');
-            expect(result).toBe('name3');
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(1);
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
-                'name1Hash',
-                'name2Hash',
-                'name3Hash',
-            ]);
-        });
-
-        it('should find available name with multiple pages', async () => {
-            let firstCall = false;
-            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
-                if (!firstCall) {
-                    firstCall = true;
-                    return {
-                        // First page has no available hashes
-                        availalbleHashes: [],
-                        pendingHashes: [],
-                    };
-                }
-                return {
-                    availalbleHashes: ['name3Hash'],
-                    pendingHashes: [],
-                };
-            });
-
-            const result = await manager.findAvailableName('parentUid', 'name');
-            expect(result).toBe('name3');
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(2);
-            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
-                'name1Hash',
-                'name2Hash',
-                'name3Hash',
-            ]);
-        });
-    });
-
     describe('commit draft', () => {
         const nodeRevisionDraft = {
             nodeUid: 'newNode:nodeUid',

package/src/internal/upload/manager.ts

@@ -173,43 +173,6 @@ export class UploadManager {
         }
     }
 
-    async findAvailableName(parentFolderUid: string, name: string): Promise<string> {
-        const { hashKey: parentHashKey } = await this.nodesService.getNodeKeys(parentFolderUid);
-        if (!parentHashKey) {
-            throw new ValidationError(c('Error').t`Creating files in non-folders is not allowed`);
-        }
-
-        const [namePart, extension] = splitExtension(name);
-
-        const batchSize = 10;
-        let startIndex = 1;
-        while (true) {
-            const namesToCheck = [];
-            for (let i = startIndex; i < startIndex + batchSize; i++) {
-                namesToCheck.push(joinNameAndExtension(namePart, i, extension));
-            }
-
-            const hashesToCheck = await this.cryptoService.generateNameHashes(parentHashKey, namesToCheck);
-
-            const { availalbleHashes } = await this.apiService.checkAvailableHashes(
-                parentFolderUid,
-                hashesToCheck.map(({ hash }) => hash),
-            );
-
-            if (!availalbleHashes.length) {
-                startIndex += batchSize;
-                continue;
-            }
-
-            const availableHash = hashesToCheck.find(({ hash }) => hash === availalbleHashes[0]);
-            if (!availableHash) {
-                throw Error('Backend returned unexpected hash');
-            }
-
-            return availableHash.name;
-        }
-    }
-
     async deleteDraftNode(nodeUid: string): Promise<void> {
         try {
             await this.apiService.deleteDraft(nodeUid);
@@ -294,30 +257,3 @@ export class UploadManager {
         }
     }
 }
-
-/**
- * Split a filename into `[name, extension]`
- */
-function splitExtension(filename = ''): [string, string] {
-    const endIdx = filename.lastIndexOf('.');
-    if (endIdx === -1 || endIdx === filename.length - 1) {
-        return [filename, ''];
-    }
-    return [filename.slice(0, endIdx), filename.slice(endIdx + 1)];
-}
-
-/**
- * Join a filename into `name (index).extension`
- */
-function joinNameAndExtension(name: string, index: number, extension: string): string {
-    if (!name && !extension) {
-        return `(${index})`;
-    }
-    if (!name) {
-        return `(${index}).${extension}`;
-    }
-    if (!extension) {
-        return `${name} (${index})`;
-    }
-    return `${name} (${index}).${extension}`;
-}

package/src/protonDriveClient.ts

@@ -24,7 +24,6 @@ import {
     UploadMetadata,
     FileDownloader,
     FileUploader,
-    FileRevisionUploader,
     ThumbnailType,
     ThumbnailResult,
     SDKEvent,
@@ -144,6 +143,7 @@ export class ProtonDriveClient {
             account,
             cryptoModule,
             this.shares,
+            fullConfig.clientUid,
         );
         this.sharing = initSharingModule(
             telemetry,
@@ -703,6 +703,12 @@ export class ProtonDriveClient {
         return this.sharing.management.unshareNode(getUid(nodeUid), settings);
     }
 
+    /**
+     * Resend the invitation email to shared node.
+     *
+     * @param nodeUid - Node entity or its UID string.
+     * @param invitationUid - Invitation entity or its UID string.
+     */
     async resendInvitation(
         nodeUid: NodeOrUid,
         invitationUid: ProtonInvitationOrUid | NonProtonInvitationOrUid,
@@ -829,11 +835,24 @@ export class ProtonDriveClient {
         nodeUid: NodeOrUid,
         metadata: UploadMetadata,
         signal?: AbortSignal,
-    ): Promise<FileRevisionUploader> {
+    ): Promise<FileUploader> {
         this.logger.info(`Getting file revision uploader for ${getUid(nodeUid)}`);
         return this.upload.getFileRevisionUploader(getUid(nodeUid), metadata, signal);
     }
 
+    /**
+     * Returns the available name for the file in the given parent folder.
+     *
+     * The function will return a name that includes the original name with the
+     * available index. The name is guaranteed to be unique in the parent folder.
+     *
+     * Example new name: `file (2).txt`.
+     */
+    async getAvailableName(parentFolderUid: NodeOrUid, name: string): Promise<string> {
+        this.logger.info(`Getting available name in folder ${getUid(parentFolderUid)}`);
+        return this.nodes.management.findAvailableName(getUid(parentFolderUid), name);
+    }
+
     /**
      * Iterates the devices of the user.
      *