@protontech/drive-sdk 0.5.0 → 0.6.0

package/src/internal/sharingPublic/index.ts

@@ -1,4 +1,4 @@
-import { DriveCrypto } from '../../crypto';
+import { DriveCrypto, PrivateKey } from '../../crypto';
 import {
     ProtonDriveCryptoCache,
     ProtonDriveTelemetry,
@@ -11,10 +11,7 @@ import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesCryptoService } from '../nodes/cryptoService';
 import { NodesRevisons } from '../nodes/nodesRevisions';
-import { SharingPublicAPIService } from './apiService';
-import { SharingPublicCryptoCache } from './cryptoCache';
 import { SharingPublicCryptoReporter } from './cryptoReporter';
-import { SharingPublicCryptoService } from './cryptoService';
 import { SharingPublicNodesAccess } from './nodes';
 import { SharingPublicSharesManager } from './shares';
 
@@ -38,12 +35,10 @@ export function initSharingPublicModule(
     account: ProtonDriveAccount,
     url: string,
     token: string,
-    password: string,
+    publicShareKey: PrivateKey,
+    publicRootNodeUid: string,
 ) {
-    const api = new SharingPublicAPIService(telemetry.getLogger('sharingPublic-api'), apiService);
-    const cryptoCache = new SharingPublicCryptoCache(telemetry.getLogger('sharingPublic-crypto'), driveCryptoCache);
-    const cryptoService = new SharingPublicCryptoService(driveCrypto, password);
-    const shares = new SharingPublicSharesManager(api, cryptoCache, cryptoService, account, token);
+    const shares = new SharingPublicSharesManager(account, publicShareKey, publicRootNodeUid);
     const nodes = initSharingPublicNodesModule(
         telemetry,
         apiService,
@@ -54,6 +49,8 @@ export function initSharingPublicModule(
         shares,
         url,
         token,
+        publicShareKey,
+        publicRootNodeUid,
     );
 
     return {
@@ -78,14 +75,17 @@ export function initSharingPublicNodesModule(
     sharesService: SharingPublicSharesManager,
     url: string,
     token: string,
+    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);
     const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
     const nodesAccess = new SharingPublicNodesAccess(
-        telemetry.getLogger('nodes'),
+        telemetry,
         api,
         cache,
         cryptoCache,
@@ -93,6 +93,8 @@ export function initSharingPublicNodesModule(
         sharesService,
         url,
         token,
+        publicShareKey,
+        publicRootNodeUid,
     );
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 

package/src/internal/sharingPublic/nodes.ts

@@ -1,16 +1,18 @@
-import { Logger } from "../../interface";
-import { NodeAPIService } from "../nodes/apiService";
-import { NodesCache } from "../nodes/cache";
-import { NodesCryptoCache } from "../nodes/cryptoCache";
-import { NodesCryptoService } from "../nodes/cryptoService";
-import { NodesAccess } from "../nodes/nodesAccess";
-import { isProtonDocument, isProtonSheet } from "../nodes/mediaTypes";
-import { splitNodeUid } from "../uids";
-import { SharingPublicSharesManager } from "./shares";
+import { ProtonDriveTelemetry } from '../../interface';
+import { NodeAPIService } from '../nodes/apiService';
+import { NodesCache } from '../nodes/cache';
+import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { NodesAccess } from '../nodes/nodesAccess';
+import { isProtonDocument, isProtonSheet } from '../nodes/mediaTypes';
+import { splitNodeUid } from '../uids';
+import { SharingPublicSharesManager } from './shares';
+import { DecryptedNode, DecryptedNodeKeys } from '../nodes/interface';
+import { PrivateKey } from '../../crypto';
 
 export class SharingPublicNodesAccess extends NodesAccess {
     constructor(
-        logger: Logger,
+        telemetry: ProtonDriveTelemetry,
         apiService: NodeAPIService,
         cache: NodesCache,
         cryptoCache: NodesCryptoCache,
@@ -18,9 +20,29 @@ export class SharingPublicNodesAccess extends NodesAccess {
         sharesService: SharingPublicSharesManager,
         private url: string,
         private token: string,
+        private publicShareKey: PrivateKey,
+        private publicRootNodeUid: string,
     ) {
-        super(logger, apiService, cache, cryptoCache, cryptoService, sharesService);
+        super(telemetry, apiService, cache, cryptoCache, cryptoService, sharesService);
         this.token = token;
+        this.publicShareKey = publicShareKey;
+        this.publicRootNodeUid = publicRootNodeUid;
+    }
+
+    async getParentKeys(
+        node: Pick<DecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
+    ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+        // If we reached the root node of the public link, return the public
+        // share key even if user has access to the parent node. We do not
+        // support access to nodes outside of the public link context.
+        // For other nodes, the client must use the main SDK.
+        if (node.uid === this.publicRootNodeUid) {
+            return {
+                key: this.publicShareKey,
+            };
+        }
+
+        return super.getParentKeys(node);
     }
 
     async getNodeUrl(nodeUid: string): Promise<string> {

package/src/internal/sharingPublic/session/apiService.ts

@@ -1,5 +1,7 @@
-import { DriveAPIService, drivePaths } from '../../apiService';
-import { PublicLinkInfo, PublicLinkSrpAuth } from './interface';
+import { Logger } from '../../../interface';
+import { DriveAPIService, drivePaths, permissionsToMemberRole } from '../../apiService';
+import { makeNodeUid } from '../../uids';
+import { PublicLinkInfo, PublicLinkSrpAuth, PublicLinkSession, EncryptedShareCrypto } from './interface';
 
 type GetPublicLinkInfoResponse =
     drivePaths['/drive/urls/{token}/info']['get']['responses']['200']['content']['application/json'];
@@ -18,7 +20,11 @@ type PostPublicLinkAuthResponse =
  * and vice versa. It should not contain any business logic.
  */
 export class SharingPublicSessionAPIService {
-    constructor(private apiService: DriveAPIService) {
+    constructor(
+        private logger: Logger,
+        private apiService: DriveAPIService,
+    ) {
+        this.logger = logger;
         this.apiService = apiService;
     }
 
@@ -38,6 +44,13 @@ export class SharingPublicSessionAPIService {
             isCustomPasswordProtected: (response.Flags & 1) === 1,
             isLegacy: response.Flags === 0 || response.Flags === 1,
             vendorType: response.VendorType,
+            directAccess: response.DirectAccess
+                ? {
+                      nodeUid: makeNodeUid(response.DirectAccess.VolumeID, response.DirectAccess.LinkID),
+                      directRole: permissionsToMemberRole(this.logger, response.DirectAccess.DirectPermissions),
+                      publicRole: permissionsToMemberRole(this.logger, response.DirectAccess.PublicPermissions),
+                  }
+                : undefined,
         };
     }
 
@@ -52,9 +65,9 @@ export class SharingPublicSessionAPIService {
         token: string,
         srp: PublicLinkSrpAuth,
     ): Promise<{
-        serverProof: string;
-        sessionUid: string;
-        sessionAccessToken?: string;
+        session: PublicLinkSession;
+        encryptedShare: EncryptedShareCrypto;
+        rootUid: string;
     }> {
         const response = await this.apiService.post<PostPublicLinkAuthRequest, PostPublicLinkAuthResponse>(
             `drive/urls/${token}/auth`,
@@ -66,9 +79,18 @@ export class SharingPublicSessionAPIService {
         );
 
         return {
-            serverProof: response.ServerProof,
-            sessionUid: response.UID,
-            sessionAccessToken: response.AccessToken,
+            session: {
+                serverProof: response.ServerProof,
+                sessionUid: response.UID,
+                sessionAccessToken: response.AccessToken,
+            },
+            encryptedShare: {
+                base64UrlPasswordSalt: response.Share.SharePasswordSalt,
+                armoredKey: response.Share.ShareKey,
+                armoredPassphrase: response.Share.SharePassphrase,
+                publicRole: permissionsToMemberRole(this.logger, response.Share.PublicPermissions),
+            },
+            rootUid: makeNodeUid(response.Share.VolumeID, response.Share.LinkID),
         };
     }
 }

package/src/internal/sharingPublic/session/interface.ts

@@ -1,8 +1,15 @@
+import { MemberRole } from '../../../interface';
+
 export type PublicLinkInfo = {
     srp: PublicLinkSrpInfo;
     isCustomPasswordProtected: boolean;
     isLegacy: boolean;
     vendorType: number;
+    directAccess?: {
+        nodeUid: string;
+        directRole: MemberRole;
+        publicRole: MemberRole;
+    };
 };
 
 export type PublicLinkSrpInfo = {
@@ -18,3 +25,16 @@ export type PublicLinkSrpAuth = {
     clientEphemeral: string;
     srpSession: string;
 };
+
+export type PublicLinkSession = {
+    serverProof: string;
+    sessionUid: string;
+    sessionAccessToken?: string;
+};
+
+export type EncryptedShareCrypto = {
+    base64UrlPasswordSalt: string;
+    armoredKey: string;
+    armoredPassphrase: string;
+    publicRole: MemberRole;
+};

package/src/internal/sharingPublic/session/manager.ts

@@ -1,9 +1,9 @@
-import { ProtonDriveHTTPClient } from '../../../interface';
-import { SRPModule } from '../../../crypto';
+import { MemberRole, ProtonDriveHTTPClient, ProtonDriveTelemetry } from '../../../interface';
+import { DriveCrypto, PrivateKey, SRPModule } from '../../../crypto';
 import { DriveAPIService } from '../../apiService';
 import { SharingPublicSessionAPIService } from './apiService';
 import { SharingPublicSessionHttpClient } from './httpClient';
-import { PublicLinkInfo } from './interface';
+import { EncryptedShareCrypto, PublicLinkInfo } from './interface';
 import { SharingPublicLinkSession } from './session';
 import { getTokenAndPasswordFromUrl } from './url';
 
@@ -18,14 +18,17 @@ export class SharingPublicSessionManager {
     private infosPerToken: Map<string, PublicLinkInfo> = new Map();
 
     constructor(
+        telemetry: ProtonDriveTelemetry,
         private httpClient: ProtonDriveHTTPClient,
-        apiService: DriveAPIService,
+        private driveCrypto: DriveCrypto,
         private srpModule: SRPModule,
+        apiService: DriveAPIService,
     ) {
         this.httpClient = httpClient;
+        this.driveCrypto = driveCrypto;
         this.srpModule = srpModule;
 
-        this.api = new SharingPublicSessionAPIService(apiService);
+        this.api = new SharingPublicSessionAPIService(telemetry.getLogger('sharingPublicSession'), apiService);
     }
 
     /**
@@ -42,6 +45,11 @@ export class SharingPublicSessionManager {
         isCustomPasswordProtected: boolean;
         isLegacy: boolean;
         vendorType: number;
+        directAccess?: {
+            nodeUid: string;
+            directRole: MemberRole;
+            publicRole: MemberRole;
+        };
     }> {
         const { token } = getTokenAndPasswordFromUrl(url);
 
@@ -52,6 +60,7 @@ export class SharingPublicSessionManager {
             isCustomPasswordProtected: info.isCustomPasswordProtected,
             isLegacy: info.isLegacy,
             vendorType: info.vendorType,
+            directAccess: info.directAccess,
         };
     }
 
@@ -73,8 +82,9 @@ export class SharingPublicSessionManager {
         customPassword?: string,
     ): Promise<{
         token: string;
-        password: string;
         httpClient: SharingPublicSessionHttpClient;
+        shareKey: PrivateKey;
+        rootUid: string;
     }> {
         const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url);
 
@@ -86,12 +96,25 @@ export class SharingPublicSessionManager {
         const password = `${urlPassword}${customPassword || ''}`;
 
         const session = new SharingPublicLinkSession(this.api, this.srpModule, token, password);
-        await session.auth(info.srp);
+        const { encryptedShare, rootUid } = await session.auth(info.srp);
+
+        const shareKey = await this.decryptShareKey(encryptedShare, password);
 
         return {
             token,
-            password,
             httpClient: new SharingPublicSessionHttpClient(this.httpClient, session),
+            shareKey,
+            rootUid,
         };
     }
+
+    private async decryptShareKey(encryptedShare: EncryptedShareCrypto, password: string): Promise<PrivateKey> {
+        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
+            password,
+            encryptedShare.base64UrlPasswordSalt,
+            encryptedShare.armoredKey,
+            encryptedShare.armoredPassphrase,
+        );
+        return shareKey;
+    }
 }

package/src/internal/sharingPublic/session/session.ts

@@ -1,6 +1,6 @@
 import { SRPModule } from '../../../crypto';
 import { SharingPublicSessionAPIService } from './apiService';
-import { PublicLinkInfo, PublicLinkSrpInfo } from './interface';
+import { EncryptedShareCrypto, PublicLinkInfo, PublicLinkSrpInfo } from './interface';
 
 /**
  * Session for a public link.
@@ -33,7 +33,7 @@ export class SharingPublicLinkSession {
         return this.apiService.initPublicLinkSession(this.token);
     }
 
-    async auth(srp: PublicLinkSrpInfo): Promise<void> {
+    async auth(srp: PublicLinkSrpInfo): Promise<{ encryptedShare: EncryptedShareCrypto; rootUid: string }> {
         const { expectedServerProof, clientProof, clientEphemeral } = await this.srpModule.getSrp(
             srp.version,
             srp.modulus,
@@ -48,12 +48,17 @@ export class SharingPublicLinkSession {
             srpSession: srp.srpSession,
         });
 
-        if (auth.serverProof !== expectedServerProof) {
+        if (auth.session.serverProof !== expectedServerProof) {
             throw new Error('Invalid server proof');
         }
 
-        this.sessionUid = auth.sessionUid;
-        this.sessionAccessToken = auth.sessionAccessToken;
+        this.sessionUid = auth.session.sessionUid;
+        this.sessionAccessToken = auth.session.sessionAccessToken;
+
+        return {
+            encryptedShare: auth.encryptedShare,
+            rootUid: auth.rootUid,
+        };
     }
 
     /**

package/src/internal/sharingPublic/shares.ts

@@ -1,9 +1,6 @@
 import { PrivateKey } from '../../crypto';
 import { MetricVolumeType, ProtonDriveAccount } from '../../interface';
 import { splitNodeUid } from '../uids';
-import { SharingPublicAPIService } from './apiService';
-import { SharingPublicCryptoCache } from './cryptoCache';
-import { SharingPublicCryptoService } from './cryptoService';
 
 /**
  * Provides high-level actions for managing public link share.
@@ -12,57 +9,24 @@ import { SharingPublicCryptoService } from './cryptoService';
  * service so it can be used in the same way in various modules that use shares.
  */
 export class SharingPublicSharesManager {
-    private promisePublicLinkRoot?: Promise<{
-        rootIds: { volumeId: string; rootNodeId: string; rootNodeUid: string };
-        shareKey: PrivateKey;
-    }>;
-
     constructor(
-        private apiService: SharingPublicAPIService,
-        private cryptoCache: SharingPublicCryptoCache,
-        private cryptoService: SharingPublicCryptoService,
         private account: ProtonDriveAccount,
-        private token: string,
+        private publicShareKey: PrivateKey,
+        private publicRootNodeUid: string,
     ) {
-        this.apiService = apiService;
-        this.cryptoCache = cryptoCache;
-        this.cryptoService = cryptoService;
         this.account = account;
-        this.token = token;
+        this.publicShareKey = publicShareKey;
+        this.publicRootNodeUid = publicRootNodeUid;
     }
 
     // TODO: Rename to getRootIDs everywhere.
     async getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string; rootNodeUid: string }> {
-        const { rootIds } = await this.getPublicLinkRoot();
-        return rootIds;
+        const { volumeId, nodeId: rootNodeId } = splitNodeUid(this.publicRootNodeUid);
+        return { volumeId, rootNodeId, rootNodeUid: this.publicRootNodeUid };
     }
 
     async getSharePrivateKey(): Promise<PrivateKey> {
-        const { shareKey } = await this.getPublicLinkRoot();
-        return shareKey;
-    }
-
-    private async getPublicLinkRoot(): Promise<{
-        rootIds: { volumeId: string; rootNodeId: string; rootNodeUid: string };
-        shareKey: PrivateKey;
-    }> {
-        if (!this.promisePublicLinkRoot) {
-            this.promisePublicLinkRoot = (async () => {
-                const { encryptedNode, encryptedShare } = await this.apiService.getPublicLinkRoot(this.token);
-
-                const { volumeId, nodeId: rootNodeId } = splitNodeUid(encryptedNode.uid);
-
-                const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
-                await this.cryptoCache.setShareKey(shareKey);
-
-                return {
-                    rootIds: { volumeId, rootNodeId, rootNodeUid: encryptedNode.uid },
-                    shareKey,
-                };
-            })();
-        }
-
-        return this.promisePublicLinkRoot;
+        return this.publicShareKey;
     }
 
     async getContextShareMemberEmailKey(): Promise<{

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/controller.ts

@@ -1,11 +1,23 @@
+import { AbortError } from '../../errors';
 import { waitForCondition } from '../wait';
 
 export class UploadController {
     private paused = false;
-    public promise?: Promise<{ nodeRevisionUid: string, nodeUid: string }>;
+    public promise?: Promise<{ nodeRevisionUid: string; nodeUid: string }>;
 
-    async waitIfPaused(): Promise<void> {
-        await waitForCondition(() => !this.paused);
+    constructor(private signal?: AbortSignal) {
+        this.signal = signal;
+    }
+
+    async waitWhilePaused(): Promise<void> {
+        try {
+            await waitForCondition(() => !this.paused, this.signal);
+        } catch (error) {
+            if (error instanceof AbortError) {
+                return;
+            }
+            throw error;
+        }
     }
 
     pause(): void {
@@ -16,7 +28,7 @@ export class UploadController {
         this.paused = false;
     }
 
-    async completion(): Promise<{ nodeRevisionUid: string, nodeUid: string }> {
+    async completion(): Promise<{ nodeRevisionUid: string; nodeUid: string }> {
         if (!this.promise) {
             throw new Error('UploadController.completion() called before upload started');
         }

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

@@ -43,7 +43,7 @@ class Uploader {
             });
         }
 
-        this.controller = new UploadController();
+        this.controller = new UploadController(this.abortController.signal);
     }
 
     async uploadFromFile(
@@ -120,7 +120,7 @@ class Uploader {
             this.metadata,
             onFinish,
             this.controller,
-            this.signal,
+            this.abortController,
         );
     }
 
@@ -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',