@protontech/drive-sdk 0.4.1 → 0.5.0

package/src/internal/nodes/debouncer.ts

@@ -0,0 +1,93 @@
+import { Logger } from "../../interface";
+import { LoggerWithPrefix } from '../../telemetry';
+
+/**
+ * The timeout for which the node is considered to be loading.
+ * If the node is not loaded after this timeout, it is considered to be
+ * loaded or failed to be loaded, and allowed other places to proceed.
+ *
+ * Decrypting many nodes in parallel can take a lot of time, so we allow
+ * more time for this.
+ */
+const DEBOUNCE_TIMEOUT = 5000;
+
+/**
+ * Helper to avoid loading the same node twice.
+ *
+ * Each place that loads a node should report it is being loaded,
+ * and when it is finished, it should report it is finished.
+ * The finish must be called even if the node fails to be loaded
+ * to clear the promise.
+ *
+ * Each place that loads a node from cache should first wait for
+ * the node to be loaded if that is the case.
+ */
+export class NodesDebouncer {
+    private promises: Map<
+        string,
+        {
+            promise: Promise<void>;
+            resolve: () => void;
+            timeout: NodeJS.Timeout;
+        }
+    > = new Map();
+
+    constructor(private logger: Logger) {
+        this.logger = new LoggerWithPrefix(logger, 'debouncer');
+    }
+
+    loadingNodes(nodeUids: string[]) {
+        for (const nodeUid of nodeUids) {
+            this.loadingNode(nodeUid);
+        }
+    }
+
+    loadingNode(nodeUid: string) {
+        const { promise, resolve } = Promise.withResolvers<void>();
+        if (this.promises.has(nodeUid)) {
+            this.logger.warn(`Loading twice for: ${nodeUid}`);
+            return;
+        }
+
+        const timeout = setTimeout(() => {
+            this.logger.warn(`Timeout for: ${nodeUid}`);
+            this.finishedLoadingNode(nodeUid);
+        }, DEBOUNCE_TIMEOUT);
+        this.promises.set(nodeUid, { promise, resolve, timeout });
+    }
+
+    finishedLoadingNodes(nodeUids: string[]) {
+        for (const nodeUid of nodeUids) {
+            this.finishedLoadingNode(nodeUid);
+        }
+    }
+
+    finishedLoadingNode(nodeUid: string) {
+        const result = this.promises.get(nodeUid);
+        if (!result) {
+            return;
+        }
+
+        clearTimeout(result.timeout);
+        result.resolve();
+        this.promises.delete(nodeUid);
+    }
+
+    async waitForLoadingNode(nodeUid: string) {
+        const result = this.promises.get(nodeUid);
+        if (!result) {
+            return;
+        }
+
+        this.logger.debug(`Wait for: ${nodeUid}`);
+        await result.promise;
+    }
+
+    clear() {
+        for (const result of this.promises.values()) {
+            clearTimeout(result.timeout);
+            result.resolve();
+        }
+        this.promises.clear();
+    }
+}

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

@@ -352,7 +352,7 @@ describe('nodesAccess', () => {
                 expect(cache.setFolderChildrenLoaded).not.toHaveBeenCalled();
             });
 
-            it.only('should return only filtered nodes from API', async () => {
+            it('should return only filtered nodes from API', async () => {
                 cache.isFolderChildrenLoaded = jest.fn().mockResolvedValue(false);
                 cache.getNode = jest.fn().mockImplementation((uid: string) => {
                     if (uid === parentNode.uid) {
@@ -444,7 +444,7 @@ describe('nodesAccess', () => {
             const node1 = { uid: 'volumeId~node1', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
             const node2 = { uid: 'volumeId~node2', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
             const node3 = { uid: 'volumeId~node3', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
-            const node4 = { uid: 'volume~node4', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
+            const node4 = { uid: 'volumeId~node4', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
 
             it('should serve fully from cache', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {

package/src/internal/nodes/nodesAccess.ts

@@ -11,6 +11,7 @@ import { NodeAPIService } from './apiService';
 import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { NodesDebouncer } from './debouncer';
 import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from './extendedAttributes';
 import {
     SharesService,
@@ -40,13 +41,18 @@ const DECRYPTION_CONCURRENCY = 30;
  * nodes metadata.
  */
 export class NodesAccess {
+    private debouncer: NodesDebouncer;
+
     constructor(
         private logger: Logger,
         private apiService: NodeAPIService,
         private cache: NodesCache,
         private cryptoCache: NodesCryptoCache,
         private cryptoService: NodesCryptoService,
-        private shareService: SharesService,
+        private shareService: Pick<
+            SharesService,
+            'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
+        >,
     ) {
         this.logger = logger;
         this.apiService = apiService;
@@ -54,6 +60,7 @@ export class NodesAccess {
         this.cryptoCache = cryptoCache;
         this.cryptoService = cryptoService;
         this.shareService = shareService;
+        this.debouncer = new NodesDebouncer(this.logger);
     }
 
     async getVolumeRootFolder() {
@@ -65,6 +72,7 @@ export class NodesAccess {
     async getNode(nodeUid: string): Promise<DecryptedNode> {
         let cachedNode;
         try {
+            await this.debouncer.waitForLoadingNode(nodeUid);
             cachedNode = await this.cache.getNode(nodeUid);
         } catch {}
 
@@ -112,6 +120,7 @@ export class NodesAccess {
         for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, onlyFolders, signal)) {
             let node;
             try {
+                await this.debouncer.waitForLoadingNode(nodeUid);
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
@@ -143,6 +152,7 @@ export class NodesAccess {
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
             let node;
             try {
+                await this.debouncer.waitForLoadingNode(nodeUid);
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
@@ -208,9 +218,14 @@ export class NodesAccess {
     }
 
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
-        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
-        const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
-        return this.decryptNode(encryptedNode);
+        this.debouncer.loadingNode(nodeUid);
+        try {
+            const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+            const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
+            return this.decryptNode(encryptedNode);
+        } finally {
+            this.debouncer.finishedLoadingNode(nodeUid);
+        }
     }
 
     private async *loadNodes(
@@ -236,7 +251,14 @@ export class NodesAccess {
 
         const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
 
-        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
+        const apiNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
+
+        const debouncedNodeMapper = async (encryptedNode: EncryptedNode): Promise<EncryptedNode> => {
+            this.debouncer.loadingNode(encryptedNode.uid);
+            return encryptedNode;
+        };
+        const encryptedNodesIterator = asyncIteratorMap(apiNodesIterator, debouncedNodeMapper, 1);
+
         const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {
@@ -250,6 +272,7 @@ export class NodesAccess {
             encryptedNodesIterator,
             decryptNodeMapper,
             DECRYPTION_CONCURRENCY,
+            signal,
         );
         for await (const node of decryptedNodesIterator) {
             if (node.ok) {
@@ -329,6 +352,7 @@ export class NodesAccess {
                 this.logger.error(`Failed to cache node keys ${node.uid}`, error);
             }
         }
+        this.debouncer.finishedLoadingNode(node.uid);
         return { node, keys };
     }
 
@@ -360,6 +384,7 @@ export class NodesAccess {
 
     async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
         try {
+            await this.debouncer.waitForLoadingNode(nodeUid);
             return await this.cryptoCache.getNodeKeys(nodeUid);
         } catch {
             const { keys } = await this.loadNode(nodeUid);

package/src/internal/photos/upload.ts

@@ -5,6 +5,7 @@ import { generateFileExtendedAttributes } from '../nodes';
 import { splitNodeRevisionUid } from '../uids';
 import { UploadAPIService } from '../upload/apiService';
 import { BlockVerifier } from '../upload/blockVerifier';
+import { UploadController } from '../upload/controller';
 import { UploadCryptoService } from '../upload/cryptoService';
 import { FileUploader } from '../upload/fileUploader';
 import { NodeRevisionDraft, NodesService } from '../upload/interface';
@@ -62,6 +63,7 @@ export class PhotoFileUploader extends FileUploader {
             revisionDraft,
             this.photoMetadata,
             onFinish,
+            this.controller,
             this.signal,
         );
     }
@@ -80,9 +82,10 @@ export class PhotoStreamUploader extends StreamUploader {
         revisionDraft: NodeRevisionDraft,
         metadata: PhotoUploadMetadata,
         onFinish: (failure: boolean) => Promise<void>,
+        controller: UploadController,
         signal?: AbortSignal,
     ) {
-        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, signal);
+        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, controller, signal);
         this.photoUploadManager = uploadManager;
         this.photoMetadata = metadata;
     }

package/src/internal/sharingPublic/apiService.ts

@@ -1,15 +1,11 @@
 import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
 import { Logger, MemberRole } from '../../interface';
-import { makeNodeUid, splitNodeUid } from '../uids';
-import { EncryptedShareCrypto, EncryptedNode } from './interface';
-
-const PAGE_SIZE = 50;
+import { makeNodeUid } from '../uids';
+import { EncryptedNode } from '../nodes/interface';
+import { EncryptedShareCrypto } from './interface';
 
 type GetTokenInfoResponse = drivePaths['/drive/urls/{token}']['get']['responses']['200']['content']['application/json'];
 
-type GetTokenFolderChildrenResponse =
-    drivePaths['/drive/urls/{token}/folders/{linkID}/children']['get']['responses']['200']['content']['application/json'];
-
 /**
  * Provides API communication for accessing public link data.
  *
@@ -41,27 +37,6 @@ export class SharingPublicAPIService {
             },
         };
     }
-
-    async *iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
-        const { volumeId: token, nodeId } = splitNodeUid(parentUid);
-
-        let page = 0;
-        while (true) {
-            const response = await this.apiService.get<GetTokenFolderChildrenResponse>(
-                `drive/urls/${token}/folders/${nodeId}/children?Page=${page}&PageSize=${PAGE_SIZE}`,
-                signal,
-            );
-
-            for (const link of response.Links) {
-                yield linkToEncryptedNode(this.logger, token, link);
-            }
-
-            if (response.Links.length < PAGE_SIZE) {
-                break;
-            }
-            page++;
-        }
-    }
 }
 
 function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token']): EncryptedNode {
@@ -70,7 +45,7 @@ function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token
         encryptedName: token.Name,
 
         // Basic node metadata
-        uid: makeNodeUid(token.Token, token.LinkID),
+        uid: makeNodeUid(token.VolumeID, token.LinkID),
         parentUid: undefined,
         type: nodeTypeNumberToNodeType(logger, token.LinkType),
         creationTime: new Date(), // TODO
@@ -115,61 +90,3 @@ function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token
 
     throw new Error(`Unknown node type: ${token.LinkType}`);
 }
-
-function linkToEncryptedNode(
-    logger: Logger,
-    token: string,
-    link: GetTokenFolderChildrenResponse['Links'][0],
-): EncryptedNode {
-    const baseNodeMetadata = {
-        // Internal metadata
-        hash: link.Hash || undefined,
-        encryptedName: link.Name,
-
-        // Basic node metadata
-        uid: makeNodeUid(token, link.LinkID),
-        parentUid: link.ParentLinkID ? makeNodeUid(token, link.ParentLinkID) : undefined,
-        type: nodeTypeNumberToNodeType(logger, link.Type),
-        creationTime: new Date(), // TODO
-        totalStorageSize: link.TotalSize,
-
-        isShared: false,
-        isSharedPublicly: false,
-        directRole: MemberRole.Viewer, // TODO
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: link.SignatureEmail || undefined,
-        armoredKey: link.NodeKey,
-        armoredNodePassphrase: link.NodePassphrase,
-        armoredNodePassphraseSignature: link.NodePassphraseSignature || undefined,
-    };
-
-    if (link.Type === 1 && link.FolderProperties) {
-        return {
-            ...baseNodeMetadata,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                folder: {
-                    armoredHashKey: link.FolderProperties.NodeHashKey as string,
-                },
-            },
-        };
-    }
-
-    if (link.Type === 2 && link.FileProperties?.ContentKeyPacket) {
-        return {
-            ...baseNodeMetadata,
-            totalStorageSize: link.FileProperties.ActiveRevision?.Size || undefined,
-            mediaType: link.MIMEType || undefined,
-            encryptedCrypto: {
-                ...baseCryptoNodeMetadata,
-                file: {
-                    base64ContentKeyPacket: link.FileProperties.ContentKeyPacket,
-                },
-            },
-        };
-    }
-
-    throw new Error(`Unknown node type: ${link.Type}`);
-}

package/src/internal/sharingPublic/cryptoCache.ts

@@ -1,6 +1,5 @@
 import { PrivateKey } from '../../crypto';
 import { ProtonDriveCryptoCache, Logger } from '../../interface';
-import { DecryptedNodeKeys } from './interface';
 
 /**
  * Provides caching for public link crypto material.
@@ -39,41 +38,8 @@ export class SharingPublicCryptoCache {
         }
         return shareKeyData.publicShareKey.key;
     }
-
-    async setNodeKeys(nodeUid: string, keys: DecryptedNodeKeys): Promise<void> {
-        const cacheUid = getNodeCacheKey(nodeUid);
-        await this.driveCache.setEntity(cacheUid, {
-            nodeKeys: keys,
-        });
-    }
-
-    async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
-        const nodeKeysData = await this.driveCache.getEntity(getNodeCacheKey(nodeUid));
-        if (!nodeKeysData.nodeKeys) {
-            try {
-                await this.removeNodeKeys([nodeUid]);
-            } catch (removingError: unknown) {
-                // The node keys will not be returned, thus SDK will re-fetch
-                // and re-cache it. Setting it again should then fix the problem.
-                this.logger.warn(
-                    `Failed to remove corrupted public node keys from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
-                );
-            }
-            throw new Error(`Failed to deserialize public node keys`);
-        }
-        return nodeKeysData.nodeKeys;
-    }
-
-    async removeNodeKeys(nodeUids: string[]): Promise<void> {
-        const cacheUids = nodeUids.map(getNodeCacheKey);
-        await this.driveCache.removeEntities(cacheUids);
-    }
 }
 
 function getShareKeyCacheKey() {
     return 'publicShareKey';
 }
-
-function getNodeCacheKey(nodeUid: string) {
-    return `publicNodeKeys-${nodeUid}`;
-}

package/src/internal/sharingPublic/cryptoReporter.ts

@@ -0,0 +1,73 @@
+import { c } from 'ttag';
+
+import { VERIFICATION_STATUS } from '../../crypto';
+import { getVerificationMessage } from '../errors';
+import {
+    resultOk,
+    resultError,
+    Author,
+    AnonymousUser,
+    ProtonDriveTelemetry,
+    MetricVerificationErrorField,
+    MetricVolumeType,
+    MetricsDecryptionErrorField,
+    Logger,
+} from '../../interface';
+
+export class SharingPublicCryptoReporter {
+    private logger: Logger;
+    private telemetry: ProtonDriveTelemetry;
+
+    constructor(telemetry: ProtonDriveTelemetry) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('sharingPublic-crypto');
+    }
+
+    async handleClaimedAuthor(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys = false,
+    ): Promise<Author> {
+        if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
+            return resultOk(claimedAuthor || (null as AnonymousUser));
+        }
+
+        return resultError({
+            claimedAuthor,
+            error: !claimedAuthor
+                ? c('Info').t`Author is not provided on public link`
+                : getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+        });
+    }
+
+    reportDecryptionError(
+        node: { uid: string; creationTime: Date },
+        field: MetricsDecryptionErrorField,
+        error: unknown,
+    ) {
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+
+        this.logger.error(
+            `Failed to decrypt public link node ${node.uid} (from before 2024: ${fromBefore2024})`,
+            error,
+        );
+
+        this.telemetry.recordMetric({
+            eventName: 'decryptionError',
+            volumeType: MetricVolumeType.SharedPublic,
+            field,
+            fromBefore2024,
+            error,
+            uid: node.uid,
+        });
+    }
+
+    reportVerificationError() {
+        // Authors or signatures are not provided on public links.
+        // We do not report any signature verification errors at this moment.
+    }
+}

package/src/internal/sharingPublic/cryptoService.ts

@@ -1,30 +1,12 @@
-import { c } from 'ttag';
-
-import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
-import { getVerificationMessage } from '../errors';
-import {
-    resultOk,
-    resultError,
-    Author,
-    AnonymousUser,
-    ProtonDriveTelemetry,
-    MetricVerificationErrorField,
-    MetricVolumeType,
-    MetricsDecryptionErrorField,
-    Logger,
-    ProtonDriveAccount,
-} from '../../interface';
-import { NodesCryptoService } from '../nodes/cryptoService';
+import { DriveCrypto, PrivateKey } from '../../crypto';
 import { EncryptedShareCrypto } from './interface';
 
-export class SharingPublicCryptoService extends NodesCryptoService {
+export class SharingPublicCryptoService {
     constructor(
-        telemetry: ProtonDriveTelemetry,
-        driveCrypto: DriveCrypto,
-        account: ProtonDriveAccount,
+        private driveCrypto: DriveCrypto,
         private password: string,
     ) {
-        super(telemetry, driveCrypto, account, new SharingPublicCryptoReporter(telemetry));
+        this.driveCrypto = driveCrypto;
         this.password = password;
     }
 
@@ -38,61 +20,3 @@ export class SharingPublicCryptoService extends NodesCryptoService {
         return shareKey;
     }
 }
-
-class SharingPublicCryptoReporter {
-    private logger: Logger;
-    private telemetry: ProtonDriveTelemetry;
-
-    constructor(telemetry: ProtonDriveTelemetry) {
-        this.telemetry = telemetry;
-        this.logger = telemetry.getLogger('sharingPublic-crypto');
-    }
-
-    async handleClaimedAuthor(
-        node: { uid: string; creationTime: Date },
-        field: MetricVerificationErrorField,
-        signatureType: string,
-        verified: VERIFICATION_STATUS,
-        verificationErrors?: Error[],
-        claimedAuthor?: string,
-        notAvailableVerificationKeys = false,
-    ): Promise<Author> {
-        if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
-            return resultOk(claimedAuthor || (null as AnonymousUser));
-        }
-
-        return resultError({
-            claimedAuthor,
-            error: !claimedAuthor
-                ? c('Info').t`Author is not provided on public link`
-                : getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
-        });
-    }
-
-    reportDecryptionError(
-        node: { uid: string; creationTime: Date },
-        field: MetricsDecryptionErrorField,
-        error: unknown,
-    ) {
-        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
-
-        this.logger.error(
-            `Failed to decrypt public link node ${node.uid} (from before 2024: ${fromBefore2024})`,
-            error,
-        );
-
-        this.telemetry.recordMetric({
-            eventName: 'decryptionError',
-            volumeType: MetricVolumeType.SharedPublic,
-            field,
-            fromBefore2024,
-            error,
-            uid: node.uid,
-        });
-    }
-
-    reportVerificationError() {
-        // Authors or signatures are not provided on public links.
-        // We do not report any signature verification errors at this moment.
-    }
-}

package/src/internal/sharingPublic/index.ts

@@ -1,10 +1,22 @@
 import { DriveCrypto } from '../../crypto';
-import { ProtonDriveCryptoCache, ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
+import {
+    ProtonDriveCryptoCache,
+    ProtonDriveTelemetry,
+    ProtonDriveAccount,
+    ProtonDriveEntitiesCache,
+} from '../../interface';
 import { DriveAPIService } from '../apiService';
+import { NodeAPIService } from '../nodes/apiService';
+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 { SharingPublicManager } from './manager';
+import { SharingPublicNodesAccess } from './nodes';
+import { SharingPublicSharesManager } from './shares';
 
 export { SharingPublicSessionManager } from './session/manager';
 
@@ -20,22 +32,72 @@ export { SharingPublicSessionManager } from './session/manager';
 export function initSharingPublicModule(
     telemetry: ProtonDriveTelemetry,
     apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
     driveCryptoCache: ProtonDriveCryptoCache,
     driveCrypto: DriveCrypto,
     account: ProtonDriveAccount,
+    url: string,
     token: string,
     password: string,
 ) {
     const api = new SharingPublicAPIService(telemetry.getLogger('sharingPublic-api'), apiService);
     const cryptoCache = new SharingPublicCryptoCache(telemetry.getLogger('sharingPublic-crypto'), driveCryptoCache);
-    const cryptoService = new SharingPublicCryptoService(telemetry, driveCrypto, account, password);
-    const manager = new SharingPublicManager(
-        telemetry.getLogger('sharingPublic-nodes'),
+    const cryptoService = new SharingPublicCryptoService(driveCrypto, password);
+    const shares = new SharingPublicSharesManager(api, cryptoCache, cryptoService, account, token);
+    const nodes = initSharingPublicNodesModule(
+        telemetry,
+        apiService,
+        driveEntitiesCache,
+        driveCryptoCache,
+        driveCrypto,
+        account,
+        shares,
+        url,
+        token,
+    );
+
+    return {
+        shares,
+        nodes,
+    };
+}
+
+/**
+ * Provides facade for the public link nodes module.
+ *
+ * The public link nodes initializes the core nodes module, but uses public
+ * link shares or crypto reporter instead.
+ */
+export function initSharingPublicNodesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    driveCrypto: DriveCrypto,
+    account: ProtonDriveAccount,
+    sharesService: SharingPublicSharesManager,
+    url: string,
+    token: string,
+) {
+    const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
+    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'),
         api,
+        cache,
         cryptoCache,
         cryptoService,
+        sharesService,
+        url,
         token,
     );
+    const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 
-    return manager;
+    return {
+        access: nodesAccess,
+        revisions: nodesRevisions,
+    };
 }