@protontech/drive-sdk 0.4.0 → 0.5.0

package/src/protonDrivePublicLinkClient.ts

@@ -1,3 +1,4 @@
+import { MemoryCache } from './cache';
 import { getConfig } from './config';
 import { DriveCrypto, OpenPGPCrypto, SRPModule, SessionKey } from './crypto';
 import {
@@ -5,14 +6,26 @@ import {
     ProtonDriveTelemetry,
     ProtonDriveConfig,
     Logger,
-    ProtonDriveCryptoCache,
     NodeOrUid,
     ProtonDriveAccount,
     MaybeNode,
+    NodeType,
+    CachedCryptoMaterial,
+    MaybeMissingNode,
+    FileDownloader,
+    ThumbnailType,
+    ThumbnailResult,
 } from './interface';
 import { Telemetry } from './telemetry';
-import { getUid, convertInternalNodePromise, convertInternalNodeIterator } from './transformers';
+import {
+    getUid,
+    convertInternalNodePromise,
+    convertInternalNodeIterator,
+    convertInternalMissingNodeIterator,
+    getUids,
+} from './transformers';
 import { DriveAPIService } from './internal/apiService';
+import { initDownloadModule } from './internal/download';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharingPublicModule } from './internal/sharingPublic';
 
@@ -33,6 +46,7 @@ export class ProtonDrivePublicLinkClient {
     private logger: Logger;
     private sdkEvents: SDKEvents;
     private sharingPublic: ReturnType<typeof initSharingPublicModule>;
+    private download: ReturnType<typeof initDownloadModule>;
 
     public experimental: {
         /**
@@ -53,22 +67,22 @@ export class ProtonDrivePublicLinkClient {
 
     constructor({
         httpClient,
-        cryptoCache,
         account,
         openPGPCryptoModule,
         srpModule,
         config,
         telemetry,
+        url,
         token,
         password,
     }: {
         httpClient: ProtonDriveHTTPClient;
-        cryptoCache: ProtonDriveCryptoCache;
         account: ProtonDriveAccount;
         openPGPCryptoModule: OpenPGPCrypto;
         srpModule: SRPModule;
         config?: ProtonDriveConfig;
         telemetry?: ProtonDriveTelemetry;
+        url: string;
         token: string;
         password: string;
     }) {
@@ -77,6 +91,10 @@ export class ProtonDrivePublicLinkClient {
         }
         this.logger = telemetry.getLogger('interface');
 
+        // Use only in memory cache for public link as there are no events to keep it up to date if persisted.
+        const entitiesCache = new MemoryCache<string>();
+        const cryptoCache = new MemoryCache<CachedCryptoMaterial>();
+
         const fullConfig = getConfig(config);
         this.sdkEvents = new SDKEvents(telemetry);
 
@@ -87,26 +105,36 @@ export class ProtonDrivePublicLinkClient {
             fullConfig.baseUrl,
             fullConfig.language,
         );
-        const driveCrypto = new DriveCrypto(openPGPCryptoModule, srpModule);
+        const cryptoModule = new DriveCrypto(openPGPCryptoModule, srpModule);
         this.sharingPublic = initSharingPublicModule(
             telemetry,
             apiService,
+            entitiesCache,
             cryptoCache,
-            driveCrypto,
+            cryptoModule,
             account,
+            url,
             token,
             password,
         );
+        this.download = initDownloadModule(
+            telemetry,
+            apiService,
+            cryptoModule,
+            account,
+            this.sharingPublic.shares,
+            this.sharingPublic.nodes.access,
+            this.sharingPublic.nodes.revisions,
+        );
 
         this.experimental = {
             getNodeUrl: async (nodeUid: NodeOrUid) => {
                 this.logger.debug(`Getting node URL for ${getUid(nodeUid)}`);
-                // TODO: public node has different URL
-                return '';
+                return this.sharingPublic.nodes.access.getNodeUrl(getUid(nodeUid));
             },
             getDocsKey: async (nodeUid: NodeOrUid) => {
                 this.logger.debug(`Getting docs keys for ${getUid(nodeUid)}`);
-                const keys = await this.sharingPublic.getNodeKeys(getUid(nodeUid));
+                const keys = await this.sharingPublic.nodes.access.getNodeKeys(getUid(nodeUid));
                 if (!keys.contentKeyPacketSessionKey) {
                     throw new Error('Node does not have a content key packet session key');
                 }
@@ -120,7 +148,8 @@ export class ProtonDrivePublicLinkClient {
      */
     async getRootNode(): Promise<MaybeNode> {
         this.logger.info(`Getting root node`);
-        return convertInternalNodePromise(this.sharingPublic.getRootNode());
+        const { rootNodeUid } = await this.sharingPublic.shares.getOwnVolumeIDs();
+        return convertInternalNodePromise(this.sharingPublic.nodes.access.getNode(rootNodeUid));
     }
 
     /**
@@ -128,8 +157,60 @@ export class ProtonDrivePublicLinkClient {
      *
      * See `ProtonDriveClient.iterateFolderChildren` for more information.
      */
-    async *iterateFolderChildren(parentUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateFolderChildren(
+        parentUid: NodeOrUid,
+        filterOptions?: { type?: NodeType },
+        signal?: AbortSignal,
+    ): AsyncGenerator<MaybeNode> {
         this.logger.info(`Iterating children of ${getUid(parentUid)}`);
-        yield * convertInternalNodeIterator(this.sharingPublic.iterateFolderChildren(getUid(parentUid), signal));
+        yield* convertInternalNodeIterator(
+            this.sharingPublic.nodes.access.iterateFolderChildren(getUid(parentUid), filterOptions, signal),
+        );
+    }
+
+    /**
+     * Iterates the nodes by their UIDs.
+     *
+     * See `ProtonDriveClient.iterateNodes` for more information.
+     */
+    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingNode> {
+        this.logger.info(`Iterating ${nodeUids.length} nodes`);
+        yield* convertInternalMissingNodeIterator(
+            this.sharingPublic.nodes.access.iterateNodes(getUids(nodeUids), signal),
+        );
+    }
+
+    /**
+     * Get the node by its UID.
+     *
+     * See `ProtonDriveClient.getNode` for more information.
+     */
+    async getNode(nodeUid: NodeOrUid): Promise<MaybeNode> {
+        this.logger.info(`Getting node ${getUid(nodeUid)}`);
+        return convertInternalNodePromise(this.sharingPublic.nodes.access.getNode(getUid(nodeUid)));
+    }
+
+    /**
+     * Get the file downloader to download the node content.
+     *
+     * See `ProtonDriveClient.getFileDownloader` for more information.
+     */
+    async getFileDownloader(nodeUid: NodeOrUid, signal?: AbortSignal): Promise<FileDownloader> {
+        this.logger.info(`Getting file downloader for ${getUid(nodeUid)}`);
+        return this.download.getFileDownloader(getUid(nodeUid), signal);
+    }
+
+    /**
+     * Iterates the thumbnails of the given nodes.
+     *
+     * See `ProtonDriveClient.iterateThumbnails` for more information.
+     */
+    async *iterateThumbnails(
+        nodeUids: NodeOrUid[],
+        thumbnailType?: ThumbnailType,
+        signal?: AbortSignal,
+    ): AsyncGenerator<ThumbnailResult> {
+        this.logger.info(`Iterating ${nodeUids.length} thumbnails`);
+        yield* this.download.iterateThumbnails(getUids(nodeUids), thumbnailType, signal);
     }
 }

package/src/transformers.ts

@@ -23,6 +23,7 @@ type InternalPartialNode = Pick<
     | 'type'
     | 'mediaType'
     | 'isShared'
+    | 'isSharedPublicly'
     | 'creationTime'
     | 'trashTime'
     | 'activeRevision'
@@ -90,6 +91,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         type: node.type,
         mediaType: node.mediaType,
         isShared: node.isShared,
+        isSharedPublicly: node.isSharedPublicly,
         creationTime: node.creationTime,
         trashTime: node.trashTime,
         totalStorageSize: node.totalStorageSize,

package/dist/internal/sharingPublic/manager.d.ts

@@ -1,19 +0,0 @@
-import { Logger } from '../../interface';
-import { SharingPublicAPIService } from './apiService';
-import { SharingPublicCryptoCache } from './cryptoCache';
-import { SharingPublicCryptoService } from './cryptoService';
-import { DecryptedNode, DecryptedNodeKeys } from './interface';
-export declare class SharingPublicManager {
-    private logger;
-    private api;
-    private cryptoCache;
-    private cryptoService;
-    private token;
-    constructor(logger: Logger, api: SharingPublicAPIService, cryptoCache: SharingPublicCryptoCache, cryptoService: SharingPublicCryptoService, token: string);
-    getRootNode(): Promise<DecryptedNode>;
-    iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode>;
-    private decryptShare;
-    private decryptNode;
-    private getParentKey;
-    getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys>;
-}

package/dist/internal/sharingPublic/manager.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharingPublicManager = void 0;
-const nodesAccess_1 = require("../nodes/nodesAccess");
-// TODO: comment
-class SharingPublicManager {
-    logger;
-    api;
-    cryptoCache;
-    cryptoService;
-    token;
-    constructor(logger, api, cryptoCache, cryptoService, token) {
-        this.logger = logger;
-        this.api = api;
-        this.cryptoCache = cryptoCache;
-        this.cryptoService = cryptoService;
-        this.token = token;
-        this.logger = logger;
-        this.api = api;
-        this.cryptoCache = cryptoCache;
-        this.cryptoService = cryptoService;
-        this.token = token;
-    }
-    async getRootNode() {
-        const { encryptedNode, encryptedShare } = await this.api.getPublicLinkRoot(this.token);
-        await this.decryptShare(encryptedShare);
-        return this.decryptNode(encryptedNode);
-    }
-    async *iterateFolderChildren(parentUid, signal) {
-        // TODO: optimise this - decrypt in parallel
-        for await (const node of this.api.iterateFolderChildren(parentUid, signal)) {
-            const decryptedNode = await this.decryptNode(node);
-            yield decryptedNode;
-        }
-    }
-    async decryptShare(encryptedShare) {
-        const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
-        await this.cryptoCache.setShareKey(shareKey);
-    }
-    async decryptNode(encryptedNode) {
-        const parentKey = await this.getParentKey(encryptedNode);
-        const { node: unparsedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
-        const node = await (0, nodesAccess_1.parseNode)(this.logger, unparsedNode);
-        // TODO: cache of metadata?
-        if (keys) {
-            try {
-                await this.cryptoCache.setNodeKeys(node.uid, keys);
-            }
-            catch (error) {
-                this.logger.error(`Failed to cache node keys ${node.uid}`, error);
-            }
-        }
-        return node;
-    }
-    async getParentKey(node) {
-        if (node.parentUid) {
-            // TODO: try-catch
-            const keys = await this.getNodeKeys(node.parentUid);
-            return keys.key;
-        }
-        try {
-            return await this.cryptoCache.getShareKey();
-        }
-        catch {
-            await this.getRootNode();
-            return this.cryptoCache.getShareKey();
-        }
-    }
-    async getNodeKeys(nodeUid) {
-        try {
-            const keys = await this.cryptoCache.getNodeKeys(nodeUid);
-            return keys;
-        }
-        catch {
-            // TODO: handle this
-            throw new Error('Node key not found in cache');
-        }
-    }
-}
-exports.SharingPublicManager = SharingPublicManager;
-//# sourceMappingURL=manager.js.map

package/dist/internal/sharingPublic/manager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/manager.ts"],"names":[],"mappings":"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"}

package/src/internal/sharingPublic/manager.ts

@@ -1,86 +0,0 @@
-import { PrivateKey } from '../../crypto';
-import { Logger } from '../../interface';
-import { parseNode } from '../nodes/nodesAccess';
-import { SharingPublicAPIService } from './apiService';
-import { SharingPublicCryptoCache } from './cryptoCache';
-import { SharingPublicCryptoService } from './cryptoService';
-import { EncryptedShareCrypto, EncryptedNode, DecryptedNode, DecryptedNodeKeys } from './interface';
-
-// TODO: comment
-export class SharingPublicManager {
-    constructor(
-        private logger: Logger,
-        private api: SharingPublicAPIService,
-        private cryptoCache: SharingPublicCryptoCache,
-        private cryptoService: SharingPublicCryptoService,
-        private token: string,
-    ) {
-        this.logger = logger;
-        this.api = api;
-        this.cryptoCache = cryptoCache;
-        this.cryptoService = cryptoService;
-        this.token = token;
-    }
-
-    async getRootNode(): Promise<DecryptedNode> {
-        const { encryptedNode, encryptedShare } = await this.api.getPublicLinkRoot(this.token);
-        await this.decryptShare(encryptedShare);
-        return this.decryptNode(encryptedNode);
-    }
-
-    async *iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        // TODO: optimise this - decrypt in parallel
-        for await (const node of this.api.iterateFolderChildren(parentUid, signal)) {
-            const decryptedNode = await this.decryptNode(node);
-            yield decryptedNode;
-        }
-    }
-
-    private async decryptShare(encryptedShare: EncryptedShareCrypto): Promise<void> {
-        const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
-        await this.cryptoCache.setShareKey(shareKey);
-    }
-
-    private async decryptNode(encryptedNode: EncryptedNode): Promise<DecryptedNode> {
-        const parentKey = await this.getParentKey(encryptedNode);
-
-        const { node: unparsedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
-        const node = await parseNode(this.logger, unparsedNode);
-
-        // TODO: cache of metadata?
-        if (keys) {
-            try {
-                await this.cryptoCache.setNodeKeys(node.uid, keys);
-            } catch (error: unknown) {
-                this.logger.error(`Failed to cache node keys ${node.uid}`, error);
-            }
-        }
-
-        return node;
-    }
-
-    private async getParentKey(node: Pick<DecryptedNode, 'parentUid'>): Promise<PrivateKey> {
-        if (node.parentUid) {
-            // TODO: try-catch
-            const keys = await this.getNodeKeys(node.parentUid);
-            return keys.key;
-        }
-
-        try {
-            return await this.cryptoCache.getShareKey();
-        } catch {
-            await this.getRootNode();
-            return this.cryptoCache.getShareKey();
-        }
-    }
-
-    async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
-        try {
-            const keys = await this.cryptoCache.getNodeKeys(nodeUid);
-            return keys;
-        } catch {
-            // TODO: handle this
-            throw new Error('Node key not found in cache');
-        }
-    }
-}