@protontech/drive-sdk 0.4.1 → 0.5.1

package/src/protonDrivePublicLinkClient.ts

@@ -1,18 +1,31 @@
+import { MemoryCache } from './cache';
 import { getConfig } from './config';
-import { DriveCrypto, OpenPGPCrypto, SRPModule, SessionKey } from './crypto';
+import { DriveCrypto, OpenPGPCrypto, PrivateKey, SRPModule, SessionKey } from './crypto';
 import {
     ProtonDriveHTTPClient,
     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,30 +67,36 @@ export class ProtonDrivePublicLinkClient {
 
     constructor({
         httpClient,
-        cryptoCache,
         account,
         openPGPCryptoModule,
         srpModule,
         config,
         telemetry,
+        url,
         token,
-        password,
+        publicShareKey,
+        publicRootNodeUid,
     }: {
         httpClient: ProtonDriveHTTPClient;
-        cryptoCache: ProtonDriveCryptoCache;
         account: ProtonDriveAccount;
         openPGPCryptoModule: OpenPGPCrypto;
         srpModule: SRPModule;
         config?: ProtonDriveConfig;
         telemetry?: ProtonDriveTelemetry;
+        url: string;
         token: string;
-        password: string;
+        publicShareKey: PrivateKey;
+        publicRootNodeUid: string;
     }) {
         if (!telemetry) {
             telemetry = new Telemetry();
         }
         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 +107,37 @@ 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,
+            publicShareKey,
+            publicRootNodeUid,
+        );
+        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 +151,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 +160,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/tests/telemetry.ts

@@ -1,9 +1,12 @@
-import { ProtonDriveTelemetry } from '../interface';
+import { Logger, ProtonDriveTelemetry } from '../interface';
 import { getMockLogger } from './logger';
 
-export function getMockTelemetry(): ProtonDriveTelemetry {
+export function getMockTelemetry(): ProtonDriveTelemetry & { mockLogger: Logger } {
+    const mockLogger = getMockLogger();
+
     return {
-        getLogger: getMockLogger,
+        mockLogger,
+        getLogger: () => mockLogger,
         recordMetric: jest.fn(),
     };
 }

package/src/transformers.ts

@@ -121,6 +121,14 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
     } as PublicNodeEntity);
 }
 
+export async function* convertInternalRevisionIterator(
+    revisionIterator: AsyncGenerator<InternalRevision>,
+): AsyncGenerator<PublicRevision> {
+    for await (const revision of revisionIterator) {
+        yield convertInternalRevision(revision);
+    }
+}
+
 function convertInternalRevision(revision: InternalRevision): PublicRevision {
     return {
         uid: revision.uid,

package/dist/diagnostic/sdkDiagnosticFull.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdkDiagnosticFull.js","sourceRoot":"","sources":["../../src/diagnostic/sdkDiagnosticFull.ts"],"names":[],"mappings":";;;AAIA,mDAAgD;AAEhD;;;GAGG;AACH,MAAa,iBAAiB;IAEd;IACA;IACA;IAHZ,YACY,UAAsB,EACtB,SAA8B,EAC9B,UAAgC;QAFhC,eAAU,GAAV,UAAU,CAAY;QACtB,cAAS,GAAT,SAAS,CAAqB;QAC9B,eAAU,GAAV,UAAU,CAAsB;QAExC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,CAAC,aAAa,CAAC,OAA2B;QAC5C,KAAK,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,CAAC,cAAc,CAAC,IAAe,EAAE,OAA2B;QAC9D,KAAK,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3E,CAAC;IAEO,KAAK,CAAC,CAAC,WAAW,CAAC,SAA2C;QAClE,KAAK,CAAC,CAAC,IAAA,6BAAa,EAAC,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;IACzF,CAAC;IAEO,KAAK,CAAC,CAAC,iBAAiB;QAC5B,KAAK,CAAC,CAAC,IAAA,6BAAa,EAAC,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,CAAC;IAC1F,CAAC;CACJ;AA1BD,8CA0BC"}

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

@@ -1,19 +0,0 @@
-import { PrivateKey } from '../../crypto';
-import { ProtonDriveCryptoCache, Logger } from '../../interface';
-import { DecryptedNodeKeys } from './interface';
-/**
- * Provides caching for public link crypto material.
- *
- * The cache is responsible for serialising and deserialising public link
- * crypto material.
- */
-export declare class SharingPublicCryptoCache {
-    private logger;
-    private driveCache;
-    constructor(logger: Logger, driveCache: ProtonDriveCryptoCache);
-    setShareKey(shareKey: PrivateKey): Promise<void>;
-    getShareKey(): Promise<PrivateKey>;
-    setNodeKeys(nodeUid: string, keys: DecryptedNodeKeys): Promise<void>;
-    getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys>;
-    removeNodeKeys(nodeUids: string[]): Promise<void>;
-}

package/dist/internal/sharingPublic/cryptoCache.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharingPublicCryptoCache = void 0;
-/**
- * Provides caching for public link crypto material.
- *
- * The cache is responsible for serialising and deserialising public link
- * crypto material.
- */
-class SharingPublicCryptoCache {
-    logger;
-    driveCache;
-    constructor(logger, driveCache) {
-        this.logger = logger;
-        this.driveCache = driveCache;
-        this.logger = logger;
-        this.driveCache = driveCache;
-    }
-    async setShareKey(shareKey) {
-        await this.driveCache.setEntity(getShareKeyCacheKey(), {
-            publicShareKey: {
-                key: shareKey,
-            },
-        });
-    }
-    async getShareKey() {
-        const shareKeyData = await this.driveCache.getEntity(getShareKeyCacheKey());
-        if (!shareKeyData.publicShareKey) {
-            try {
-                await this.driveCache.removeEntities([getShareKeyCacheKey()]);
-            }
-            catch (removingError) {
-                this.logger.warn(`Failed to remove corrupted public share key from the cache: ${removingError instanceof Error ? removingError.message : removingError}`);
-            }
-            throw new Error('Failed to deserialize public share key');
-        }
-        return shareKeyData.publicShareKey.key;
-    }
-    async setNodeKeys(nodeUid, keys) {
-        const cacheUid = getNodeCacheKey(nodeUid);
-        await this.driveCache.setEntity(cacheUid, {
-            nodeKeys: keys,
-        });
-    }
-    async getNodeKeys(nodeUid) {
-        const nodeKeysData = await this.driveCache.getEntity(getNodeCacheKey(nodeUid));
-        if (!nodeKeysData.nodeKeys) {
-            try {
-                await this.removeNodeKeys([nodeUid]);
-            }
-            catch (removingError) {
-                // 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) {
-        const cacheUids = nodeUids.map(getNodeCacheKey);
-        await this.driveCache.removeEntities(cacheUids);
-    }
-}
-exports.SharingPublicCryptoCache = SharingPublicCryptoCache;
-function getShareKeyCacheKey() {
-    return 'publicShareKey';
-}
-function getNodeCacheKey(nodeUid) {
-    return `publicNodeKeys-${nodeUid}`;
-}
-//# sourceMappingURL=cryptoCache.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"cryptoCache.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/cryptoCache.ts"],"names":[],"mappings":";;;AAIA;;;;;GAKG;AACH,MAAa,wBAAwB;IAErB;IACA;IAFZ,YACY,MAAc,EACd,UAAkC;QADlC,WAAM,GAAN,MAAM,CAAQ;QACd,eAAU,GAAV,UAAU,CAAwB;QAE1C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,QAAoB;QAClC,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,mBAAmB,EAAE,EAAE;YACnD,cAAc,EAAE;gBACZ,GAAG,EAAE,QAAQ;aAChB;SACJ,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,WAAW;QACb,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAC5E,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACD,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YAClE,CAAC;YAAC,OAAO,aAAsB,EAAE,CAAC;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,+DAA+D,aAAa,YAAY,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,CAC1I,CAAC;YACN,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,YAAY,CAAC,cAAc,CAAC,GAAG,CAAC;IAC3C,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAe,EAAE,IAAuB;QACtD,MAAM,QAAQ,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;QAC1C,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,EAAE;YACtC,QAAQ,EAAE,IAAI;SACjB,CAAC,CAAC;IACP,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,OAAe;QAC7B,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YACzB,IAAI,CAAC;gBACD,MAAM,IAAI,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;YACzC,CAAC;YAAC,OAAO,aAAsB,EAAE,CAAC;gBAC9B,6DAA6D;gBAC7D,iEAAiE;gBACjE,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ,+DAA+D,aAAa,YAAY,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa,EAAE,CAC1I,CAAC;YACN,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;QAC9D,CAAC;QACD,OAAO,YAAY,CAAC,QAAQ,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,QAAkB;QACnC,MAAM,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAChD,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;CACJ;AA5DD,4DA4DC;AAED,SAAS,mBAAmB;IACxB,OAAO,gBAAgB,CAAC;AAC5B,CAAC;AAED,SAAS,eAAe,CAAC,OAAe;IACpC,OAAO,kBAAkB,OAAO,EAAE,CAAC;AACvC,CAAC"}

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

@@ -1,9 +0,0 @@
-import { DriveCrypto, PrivateKey } from '../../crypto';
-import { ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
-import { NodesCryptoService } from '../nodes/cryptoService';
-import { EncryptedShareCrypto } from './interface';
-export declare class SharingPublicCryptoService extends NodesCryptoService {
-    private password;
-    constructor(telemetry: ProtonDriveTelemetry, driveCrypto: DriveCrypto, account: ProtonDriveAccount, password: string);
-    decryptPublicLinkShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey>;
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"cryptoService.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/cryptoService.ts"],"names":[],"mappings":";;;AAAA,+BAAyB;AAEzB,yCAA4E;AAC5E,sCAAmD;AACnD,+CAWyB;AACzB,0DAA4D;AAG5D,MAAa,0BAA2B,SAAQ,kCAAkB;IAKlD;IAJZ,YACI,SAA+B,EAC/B,WAAwB,EACxB,OAA2B,EACnB,QAAgB;QAExB,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,2BAA2B,CAAC,SAAS,CAAC,CAAC,CAAC;QAF3E,aAAQ,GAAR,QAAQ,CAAQ;QAGxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,yBAAyB,CAAC,cAAoC;QAChE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,yBAAyB,CACtE,IAAI,CAAC,QAAQ,EACb,cAAc,CAAC,qBAAqB,EACpC,cAAc,CAAC,UAAU,EACzB,cAAc,CAAC,iBAAiB,CACnC,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;CACJ;AApBD,gEAoBC;AAED,MAAM,2BAA2B;IACrB,MAAM,CAAS;IACf,SAAS,CAAuB;IAExC,YAAY,SAA+B;QACvC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,mBAAmB,CACrB,IAAyC,EACzC,KAAmC,EACnC,aAAqB,EACrB,QAA6B,EAC7B,kBAA4B,EAC5B,aAAsB,EACtB,4BAA4B,GAAG,KAAK;QAEpC,IAAI,QAAQ,KAAK,4BAAmB,CAAC,gBAAgB,EAAE,CAAC;YACpD,OAAO,IAAA,oBAAQ,EAAC,aAAa,IAAK,IAAsB,CAAC,CAAC;QAC9D,CAAC;QAED,OAAO,IAAA,uBAAW,EAAC;YACf,aAAa;YACb,KAAK,EAAE,CAAC,aAAa;gBACjB,CAAC,CAAC,IAAA,QAAC,EAAC,MAAM,CAAC,CAAC,CAAC,CAAA,uCAAuC;gBACpD,CAAC,CAAC,IAAA,+BAAsB,EAAC,QAAQ,EAAE,kBAAkB,EAAE,aAAa,EAAE,4BAA4B,CAAC;SAC1G,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CACjB,IAAyC,EACzC,KAAkC,EAClC,KAAc;QAEd,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC;QAElE,IAAI,CAAC,MAAM,CAAC,KAAK,CACb,sCAAsC,IAAI,CAAC,GAAG,uBAAuB,cAAc,GAAG,EACtF,KAAK,CACR,CAAC;QAEF,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YACxB,SAAS,EAAE,iBAAiB;YAC5B,UAAU,EAAE,4BAAgB,CAAC,YAAY;YACzC,KAAK;YACL,cAAc;YACd,KAAK;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;SAChB,CAAC,CAAC;IACP,CAAC;IAED,uBAAuB;QACnB,0DAA0D;QAC1D,qEAAqE;IACzE,CAAC;CACJ"}

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

@@ -1,6 +0,0 @@
-export type { EncryptedNode, EncryptedNodeFolderCrypto, EncryptedNodeFileCrypto, DecryptedNode, DecryptedNodeKeys, } from '../nodes/interface';
-export interface EncryptedShareCrypto {
-    base64UrlPasswordSalt: string;
-    armoredKey: string;
-    armoredPassphrase: string;
-}

package/dist/internal/sharingPublic/interface.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=interface.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/interface.ts"],"names":[],"mappings":""}

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

@@ -1,79 +0,0 @@
-import { PrivateKey } from '../../crypto';
-import { ProtonDriveCryptoCache, Logger } from '../../interface';
-import { DecryptedNodeKeys } from './interface';
-
-/**
- * Provides caching for public link crypto material.
- *
- * The cache is responsible for serialising and deserialising public link
- * crypto material.
- */
-export class SharingPublicCryptoCache {
-    constructor(
-        private logger: Logger,
-        private driveCache: ProtonDriveCryptoCache,
-    ) {
-        this.logger = logger;
-        this.driveCache = driveCache;
-    }
-
-    async setShareKey(shareKey: PrivateKey): Promise<void> {
-        await this.driveCache.setEntity(getShareKeyCacheKey(), {
-            publicShareKey: {
-                key: shareKey,
-            },
-        });
-    }
-
-    async getShareKey(): Promise<PrivateKey> {
-        const shareKeyData = await this.driveCache.getEntity(getShareKeyCacheKey());
-        if (!shareKeyData.publicShareKey) {
-            try {
-                await this.driveCache.removeEntities([getShareKeyCacheKey()]);
-            } catch (removingError: unknown) {
-                this.logger.warn(
-                    `Failed to remove corrupted public share key from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
-                );
-            }
-            throw new Error('Failed to deserialize public share key');
-        }
-        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/interface.ts

@@ -1,14 +0,0 @@
-// TODO: use them directly, or avoid them completely
-export type {
-    EncryptedNode,
-    EncryptedNodeFolderCrypto,
-    EncryptedNodeFileCrypto,
-    DecryptedNode,
-    DecryptedNodeKeys,
-} from '../nodes/interface';
-
-export interface EncryptedShareCrypto {
-    base64UrlPasswordSalt: string;
-    armoredKey: string;
-    armoredPassphrase: string;
-}

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');
-        }
-    }
-}