@protontech/drive-sdk 0.5.0 → 0.6.0

package/src/internal/nodes/nodesManagement.test.ts

@@ -50,7 +50,7 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
-            copyNode: jest.fn(),
+            copyNode: jest.fn().mockResolvedValue('newCopiedNodeUid'),
             trashNodes: jest.fn(async function* (uids) {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
@@ -61,6 +61,10 @@ describe('NodesManagement', () => {
                 yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
             createFolder: jest.fn(),
+            checkAvailableHashes: jest.fn().mockResolvedValue({
+                availableHashes: ['name1Hash'],
+                pendingHashes: [],
+            }),
         };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoCache = {
@@ -75,6 +79,20 @@ describe('NodesManagement', () => {
             }),
             encryptNodeWithNewParent: jest.fn(),
             createFolder: jest.fn(),
+            generateNameHashes: jest.fn().mockResolvedValue([
+                {
+                    name: 'name1',
+                    hash: 'name1Hash',
+                },
+                {
+                    name: 'name2',
+                    hash: 'name2Hash',
+                },
+                {
+                    name: 'name3',
+                    hash: 'name3Hash',
+                },
+            ]),
         };
         // @ts-expect-error No need to implement all methods for mocking
         nodesAccess = {
@@ -251,6 +269,7 @@ describe('NodesManagement', () => {
 
         expect(newNode).toEqual({
             ...nodes.nodeUid,
+            uid: 'newCopiedNodeUid',
             parentUid: 'newParentNodeUid',
             encryptedName: 'copiedArmoredNodeName',
             hash: 'copiedHash',
@@ -307,6 +326,7 @@ describe('NodesManagement', () => {
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
+            uid: 'newCopiedNodeUid',
             parentUid: 'newParentNodeUid',
             encryptedName: 'copiedArmoredNodeName',
             hash: 'copiedHash',
@@ -338,4 +358,51 @@ describe('NodesManagement', () => {
         expect(restored).toEqual(new Set(uids));
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
     });
+
+    describe('findAvailableName', () => {
+        it('should find available name', async () => {
+            apiService.checkAvailableHashes = jest.fn().mockImplementation(() => {
+                return {
+                    availableHashes: ['name3Hash'],
+                    pendingHashes: [],
+                };
+            });
+
+            const result = await management.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
+                        availableHashes: [],
+                        pendingHashes: [],
+                    };
+                }
+                return {
+                    availableHashes: ['name3Hash'],
+                    pendingHashes: [],
+                };
+            });
+
+            const result = await management.findAvailableName('parentUid', 'name');
+            expect(result).toBe('name3');
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledTimes(2);
+            expect(apiService.checkAvailableHashes).toHaveBeenCalledWith('parentUid', [
+                'name1Hash',
+                'name2Hash',
+                'name3Hash',
+            ]);
+        });
+    });
 });

package/src/internal/nodes/nodesManagement.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { MemberRole, NodeType, NodeResult, resultOk } from '../../interface';
+import { MemberRole, NodeType, NodeResult, NodeResultWithNewUid, resultOk } from '../../interface';
 import { AbortError, ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
 import { splitNodeUid } from '../uids';
@@ -8,10 +8,14 @@ import { NodeAPIService } from './apiService';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
 import { NodeOutOfSyncError } from './errors';
+import { generateFolderExtendedAttributes } from './extendedAttributes';
 import { DecryptedNode } from './interface';
+import { splitExtension, joinNameAndExtension } from './nodeName';
 import { NodesAccess } from './nodesAccess';
 import { validateNodeName } from './validations';
-import { generateFolderExtendedAttributes } from './extendedAttributes';
+
+const AVAILABLE_NAME_BATCH_SIZE = 10;
+const AVAILABLE_NAME_LIMIT = 1000;
 
 /**
  * Provides high-level actions for managing nodes.
@@ -182,16 +186,21 @@ export class NodesManagement {
         return newNode;
     }
 
-    // Improvement requested: copy nodes in parallel
-    async *copyNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    // Improvement requested: copy nodes in parallel using copy_multiple endpoint
+    async *copyNodes(
+        nodeUids: string[],
+        newParentNodeUid: string,
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResultWithNewUid> {
         for (const nodeUid of nodeUids) {
             if (signal?.aborted) {
                 throw new AbortError(c('Error').t`Copy operation aborted`);
             }
             try {
-                await this.copyNode(nodeUid, newParentNodeUid);
+                const { uid: newNodeUid } = await this.copyNode(nodeUid, newParentNodeUid);
                 yield {
                     uid: nodeUid,
+                    newUid: newNodeUid,
                     ok: true,
                 };
             } catch (error: unknown) {
@@ -237,7 +246,7 @@ export class NodesManagement {
                   signatureEmail: encryptedCrypto.signatureEmail,
                   armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
               };
-        await this.apiService.copyNode(nodeUid, {
+        const newNodeUid = await this.apiService.copyNode(nodeUid, {
             ...keySignatureProperties,
             parentUid: newParentUid,
             armoredNodePassphrase: encryptedCrypto.armoredNodePassphrase,
@@ -247,6 +256,7 @@ export class NodesManagement {
         });
         const newNode: DecryptedNode = {
             ...node,
+            uid: newNodeUid,
             encryptedName: encryptedCrypto.encryptedName,
             parentUid: newParentUid,
             hash: encryptedCrypto.hash,
@@ -343,4 +353,42 @@ export class NodesManagement {
         await this.cryptoCache.setNodeKeys(nodeUid, keys);
         return node;
     }
+
+    async findAvailableName(parentFolderUid: string, name: string): Promise<string> {
+        const { hashKey: parentHashKey } = await this.nodesAccess.getNodeKeys(parentFolderUid);
+        if (!parentHashKey) {
+            throw new ValidationError(c('Error').t`Creating files in non-folders is not allowed`);
+        }
+
+        const [namePart, extension] = splitExtension(name);
+
+        let startIndex = 1;
+        while (startIndex < AVAILABLE_NAME_LIMIT) {
+            const namesToCheck = startIndex === 1 ? [name] : [];
+            for (let i = startIndex; i < startIndex + AVAILABLE_NAME_BATCH_SIZE; i++) {
+                namesToCheck.push(joinNameAndExtension(namePart, i, extension));
+            }
+
+            const hashesToCheck = await this.cryptoService.generateNameHashes(parentHashKey, namesToCheck);
+
+            const { availableHashes } = await this.apiService.checkAvailableHashes(
+                parentFolderUid,
+                hashesToCheck.map(({ hash }) => hash),
+            );
+
+            if (!availableHashes.length) {
+                startIndex += AVAILABLE_NAME_BATCH_SIZE;
+                continue;
+            }
+
+            const availableHash = hashesToCheck.find(({ hash }) => hash === availableHashes[0]);
+            if (!availableHash) {
+                throw Error('Backend returned unexpected hash');
+            }
+
+            return availableHash.name;
+        }
+
+        throw new ValidationError(c('Error').t`No available name found`);
+    }
 }

package/src/internal/photos/apiService.ts

@@ -1,12 +1,9 @@
-import { c } from 'ttag';
-
-import { DriveAPIService, drivePaths, NotFoundAPIError } from '../apiService';
+import { DriveAPIService, drivePaths } from '../apiService';
 import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
 import { makeNodeUid } from '../uids';
 
-type GetVolumesResponse = drivePaths['/drive/volumes']['get']['responses']['200']['content']['application/json'];
-
-type GetShareResponse = drivePaths['/drive/shares/{shareID}']['get']['responses']['200']['content']['application/json'];
+type GetPhotoShareResponse =
+    drivePaths['/drive/v2/shares/photos']['get']['responses']['200']['content']['application/json'];
 
 type PostCreateVolumeRequest = Extract<
     drivePaths['/drive/photos/volumes']['post']['requestBody'],
@@ -34,33 +31,19 @@ export class PhotosAPIService {
     }
 
     async getPhotoShare(): Promise<EncryptedRootShare> {
-        // TODO: Switch to drive/v2/shares/photos once available.
-
-        const volumesResponse = await this.apiService.get<GetVolumesResponse>('drive/volumes');
-
-        const photoVolume = volumesResponse.Volumes.find((volume) => volume.Type === 2);
-
-        if (!photoVolume) {
-            throw new NotFoundAPIError(c('Error').t`Photo volume not found`);
-        }
-
-        const response = await this.apiService.get<GetShareResponse>(`drive/shares/${photoVolume.Share.ShareID}`);
-
-        if (!response.AddressID) {
-            throw new Error('Photo root share has not address ID set');
-        }
+        const response = await this.apiService.get<GetPhotoShareResponse>('drive/v2/shares/photos');
 
         return {
-            volumeId: response.VolumeID,
-            shareId: response.ShareID,
-            rootNodeId: response.LinkID,
-            creatorEmail: response.Creator,
+            volumeId: response.Volume.VolumeID,
+            shareId: response.Share.ShareID,
+            rootNodeId: response.Link.Link.LinkID,
+            creatorEmail: response.Share.CreatorEmail,
             encryptedCrypto: {
-                armoredKey: response.Key,
-                armoredPassphrase: response.Passphrase,
-                armoredPassphraseSignature: response.PassphraseSignature,
+                armoredKey: response.Share.Key,
+                armoredPassphrase: response.Share.Passphrase,
+                armoredPassphraseSignature: response.Share.PassphraseSignature,
             },
-            addressId: response.AddressID,
+            addressId: response.Share.AddressID,
             type: ShareType.Photo,
         };
     }

package/src/internal/photos/index.ts

@@ -24,6 +24,10 @@ import {
     PhotoUploadManager,
     PhotoUploadMetadata,
 } from './upload';
+import { ShareTargetType } from '../shares';
+
+// Only photos and albums can be shared in photos volume.
+export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
 
 /**
  * Provides facade for the whole photos module.

package/src/internal/photos/upload.ts

@@ -85,7 +85,25 @@ export class PhotoStreamUploader extends StreamUploader {
         controller: UploadController,
         signal?: AbortSignal,
     ) {
-        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, controller, signal);
+        const abortController = new AbortController();
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                abortController.abort();
+            });
+        }
+
+        super(
+            telemetry,
+            apiService,
+            cryptoService,
+            uploadManager,
+            blockVerifier,
+            revisionDraft,
+            metadata,
+            onFinish,
+            controller,
+            abortController,
+        );
         this.photoUploadManager = uploadManager;
         this.photoMetadata = metadata;
     }

package/src/internal/shares/index.ts

@@ -12,6 +12,7 @@ import { SharesCache } from './cache';
 import { SharesCryptoService } from './cryptoService';
 import { SharesManager } from './manager';
 
+export { ShareTargetType } from './interface';
 export type { EncryptedShare } from './interface';
 
 /**

package/src/internal/shares/interface.ts

@@ -1,6 +1,15 @@
 import { PrivateKey, SessionKey } from '../../crypto';
 import { Result, UnverifiedAuthorError } from '../../interface';
 
+export enum ShareTargetType {
+    Root = 0,
+    Folder = 1,
+    File = 2,
+    Album = 3,
+    Photo = 4,
+    ProtonVendor = 5,
+}
+
 /**
  * Internal interface providing basic identification of volume and its root
  * share and node.

package/src/internal/sharing/apiService.ts

@@ -7,6 +7,7 @@ import {
     permissionsToMemberRole,
     memberRoleToPermission,
 } from '../apiService';
+import { ShareTargetType } from '../shares';
 import {
     makeNodeUid,
     splitNodeUid,
@@ -119,14 +120,6 @@ type PutShareUrlRequest = Extract<
 type PutShareUrlResponse =
     drivePaths['/drive/shares/{shareID}/urls/{urlID}']['put']['responses']['200']['content']['application/json'];
 
-// We do not support photos and albums yet.
-const SUPPORTED_SHARE_TARGET_TYPES = [
-    0, // Root
-    1, // Folder
-    2, // File
-    5, // Proton vendor (documents and sheets)
-];
-
 /**
  * Provides API communication for fetching and managing sharing.
  *
@@ -137,9 +130,11 @@ export class SharingAPIService {
     constructor(
         private logger: Logger,
         private apiService: DriveAPIService,
+        private shareTargetTypes: ShareTargetType[],
     ) {
         this.logger = logger;
         this.apiService = apiService;
+        this.shareTargetTypes = shareTargetTypes;
     }
 
     async *iterateSharedNodeUids(volumeId: string, signal?: AbortSignal): AsyncGenerator<string> {
@@ -163,6 +158,7 @@ export class SharingAPIService {
     async *iterateSharedWithMeNodeUids(signal?: AbortSignal): AsyncGenerator<string> {
         let anchor = '';
         while (true) {
+            // TODO: Use ShareTargetTypes filter when it is supported by the API.
             const response = await this.apiService.get<GetSharedWithMeNodesResponse>(
                 `drive/v2/sharedwithme?${anchor ? `AnchorID=${anchor}` : ''}`,
                 signal,
@@ -170,8 +166,8 @@ export class SharingAPIService {
             for (const link of response.Links) {
                 const nodeUid = makeNodeUid(link.VolumeID, link.LinkID);
 
-                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(link.ShareTargetType)) {
-                    this.logger.warn(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
+                if (!this.shareTargetTypes.includes(link.ShareTargetType)) {
+                    this.logger.debug(`Unsupported share target type ${link.ShareTargetType} for node ${nodeUid}`);
                     continue;
                 }
 
@@ -188,14 +184,21 @@ export class SharingAPIService {
     async *iterateInvitationUids(signal?: AbortSignal): AsyncGenerator<string> {
         let anchor = '';
         while (true) {
+            const params = new URLSearchParams();
+            this.shareTargetTypes.forEach((type) => {
+                params.append('ShareTargetTypes[]', type.toString());
+            });
+            if (anchor) {
+                params.append('AnchorID', anchor);
+            }
             const response = await this.apiService.get<GetInvitationsResponse>(
-                `drive/v2/shares/invitations?${anchor ? `AnchorID=${anchor}` : ''}`,
+                `drive/v2/shares/invitations?${params.toString()}`,
                 signal,
             );
             for (const invitation of response.Invitations) {
                 const invitationUid = makeInvitationUid(invitation.ShareID, invitation.InvitationID);
 
-                if (!SUPPORTED_SHARE_TARGET_TYPES.includes(invitation.ShareTargetType)) {
+                if (!this.shareTargetTypes.includes(invitation.ShareTargetType)) {
                     this.logger.warn(
                         `Unsupported share target type ${invitation.ShareTargetType} for invitation ${invitationUid}`,
                     );
@@ -347,8 +350,8 @@ export class SharingAPIService {
         return response.Share.ID;
     }
 
-    async deleteShare(shareId: string): Promise<void> {
-        await this.apiService.delete(`drive/shares/${shareId}?Force=1`);
+    async deleteShare(shareId: string, force: boolean = false): Promise<void> {
+        await this.apiService.delete(`drive/shares/${shareId}?Force=${force ? 1 : 0}`);
     }
 
     async inviteProtonUser(

package/src/internal/sharing/index.ts

@@ -1,6 +1,7 @@
 import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from '../../interface';
 import { DriveCrypto } from '../../crypto';
 import { DriveAPIService } from '../apiService';
+import { ShareTargetType } from '../shares';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
@@ -9,6 +10,10 @@ import { SharingManagement } from './sharingManagement';
 import { SharesService, NodesService } from './interface';
 import { SharingEventHandler } from './events';
 
+// Root shares are not allowed to be shared.
+// Photos and Albums are not supported in main volume (core Drive).
+const DEFAULT_SHARE_TARGET_TYPES = [ShareTargetType.Folder, ShareTargetType.File, ShareTargetType.ProtonVendor];
+
 /**
  * Provides facade for the whole sharing module.
  *
@@ -24,8 +29,9 @@ export function initSharingModule(
     crypto: DriveCrypto,
     sharesService: SharesService,
     nodesService: NodesService,
+    shareTargetTypes: ShareTargetType[] = DEFAULT_SHARE_TARGET_TYPES,
 ) {
-    const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService);
+    const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService, shareTargetTypes);
     const cache = new SharingCache(driveEntitiesCache);
     const cryptoService = new SharingCryptoService(telemetry, crypto, account, sharesService);
     const sharingAccess = new SharingAccess(api, cache, cryptoService, sharesService, nodesService);

package/src/internal/sharing/sharingManagement.ts

@@ -286,7 +286,7 @@ export class SharingManagement {
 
         if (!settings) {
             this.logger.info(`Unsharing node ${nodeUid}`);
-            await this.deleteShare(currentSharing.share.shareId, nodeUid);
+            await this.deleteShareWithForce(currentSharing.share.shareId, nodeUid);
             return;
         }
 
@@ -348,7 +348,7 @@ export class SharingManagement {
             // update local state immediately.
             this.logger.info(`Deleting share ${currentSharing.share.shareId} for node ${nodeUid}`);
             try {
-                await this.deleteShare(currentSharing.share.shareId, nodeUid);
+                await this.deleteShareWithForce(currentSharing.share.shareId, nodeUid);
             } catch (error: unknown) {
                 // If deleting the share fails, we don't want to throw an error
                 // as it might be a race condition that other client updated
@@ -433,8 +433,11 @@ export class SharingManagement {
         };
     }
 
-    private async deleteShare(shareId: string, nodeUid: string): Promise<void> {
-        await this.apiService.deleteShare(shareId);
+    /**
+     * Deletes the share even if it is not empty.
+     */
+    private async deleteShareWithForce(shareId: string, nodeUid: string): Promise<void> {
+        await this.apiService.deleteShare(shareId, true);
         await this.nodesService.notifyNodeChanged(nodeUid);
         if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
             await this.cache.removeSharedByMeNodeUid(nodeUid);

package/src/internal/sharingPublic/apiService.ts

@@ -1,92 +1,38 @@
-import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
-import { Logger, MemberRole } from '../../interface';
-import { makeNodeUid } from '../uids';
-import { EncryptedNode } from '../nodes/interface';
-import { EncryptedShareCrypto } from './interface';
+import { DriveAPIService, drivePaths } from '../apiService';
 
-type GetTokenInfoResponse = drivePaths['/drive/urls/{token}']['get']['responses']['200']['content']['application/json'];
+type PostTokenInfoRequest = Extract<
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostTokenInfoResponse =
+    drivePaths['/drive/v2/urls/{token}/bookmark']['post']['responses']['200']['content']['application/json'];
 
 /**
- * Provides API communication for accessing public link data.
+ * Provides API communication for actions on the public link.
  *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
 export class SharingPublicAPIService {
-    constructor(
-        private logger: Logger,
-        private apiService: DriveAPIService,
-    ) {
-        this.logger = logger;
+    constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
     }
 
-    async getPublicLinkRoot(token: string): Promise<{
-        encryptedNode: EncryptedNode;
-        encryptedShare: EncryptedShareCrypto;
-    }> {
-        const response = await this.apiService.get<GetTokenInfoResponse>(`drive/urls/${token}`);
-        const encryptedNode = tokenToEncryptedNode(this.logger, response.Token);
-
-        return {
-            encryptedNode: encryptedNode,
-            encryptedShare: {
-                base64UrlPasswordSalt: response.Token.SharePasswordSalt,
-                armoredKey: response.Token.ShareKey,
-                armoredPassphrase: response.Token.SharePassphrase,
-            },
-        };
-    }
-}
-
-function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token']): EncryptedNode {
-    const baseNodeMetadata = {
-        // Internal metadata
-        encryptedName: token.Name,
-
-        // Basic node metadata
-        uid: makeNodeUid(token.VolumeID, token.LinkID),
-        parentUid: undefined,
-        type: nodeTypeNumberToNodeType(logger, token.LinkType),
-        creationTime: new Date(), // TODO
-
-        isShared: false,
-        isSharedPublicly: false,
-        directRole: MemberRole.Viewer, // TODO
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: token.SignatureEmail || undefined,
-        armoredKey: token.NodeKey,
-        armoredNodePassphrase: token.NodePassphrase,
-        armoredNodePassphraseSignature: token.NodePassphraseSignature || undefined,
-    };
-
-    if (token.LinkType === 1 && token.NodeHashKey) {
-        return {
-            ...baseNodeMetadata,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                folder: {
-                    armoredHashKey: token.NodeHashKey as string,
+    async bookmarkPublicLink(bookmark: {
+        token: string;
+        encryptedUrlPassword: string;
+        addressId: string;
+        addressKeyId: string;
+    }): Promise<void> {
+        await this.apiService.post<PostTokenInfoRequest, PostTokenInfoResponse>(
+            `drive/v2/urls/${bookmark.token}/bookmark`,
+            {
+                BookmarkShareURL: {
+                    EncryptedUrlPassword: bookmark.encryptedUrlPassword,
+                    AddressID: bookmark.addressId,
+                    AddressKeyID: bookmark.addressKeyId,
                 },
             },
-        };
+        );
     }
-
-    if (token.LinkType === 2 && token.ContentKeyPacket) {
-        return {
-            ...baseNodeMetadata,
-            totalStorageSize: token.Size || undefined,
-            mediaType: token.MIMEType || undefined,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                file: {
-                    base64ContentKeyPacket: token.ContentKeyPacket,
-                },
-            },
-        };
-    }
-
-    throw new Error(`Unknown node type: ${token.LinkType}`);
 }