@protontech/drive-sdk 0.0.13 → 0.1.1

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

@@ -1,20 +1,24 @@
-import { MemoryCache } from "../../cache";
-import { NodeType, MemberRole, RevisionState, resultOk, Result } from "../../interface";
-import { getMockLogger } from "../../tests/logger";
-import { CACHE_TAG_KEYS, NodesCache } from "./cache";
-import { DecryptedNode, DecryptedRevision } from "./interface";
-
-function generateNode(uid: string, parentUid='root', params: Partial<DecryptedNode> & { volumeId?: string } = {}): DecryptedNode {
+import { MemoryCache } from '../../cache';
+import { NodeType, MemberRole, RevisionState, resultOk, Result } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { CACHE_TAG_KEYS, NodesCache } from './cache';
+import { DecryptedNode, DecryptedRevision } from './interface';
+
+function generateNode(
+    uid: string,
+    parentUid = 'root',
+    params: Partial<DecryptedNode> & { volumeId?: string } = {},
+): DecryptedNode {
     return {
-        uid: `${params.volumeId || "volumeId"}~:${uid}`,
-        parentUid: `${params.volumeId || "volumeId"}~:${parentUid}`,
+        uid: `${params.volumeId || 'volumeId'}~:${uid}`,
+        parentUid: `${params.volumeId || 'volumeId'}~:${parentUid}`,
         directMemberRole: MemberRole.Admin,
         type: NodeType.File,
-        mediaType: "text",
+        mediaType: 'text',
         isShared: false,
         creationTime: new Date(),
         trashTime: undefined,
-        volumeId: "volumeId",
+        volumeId: 'volumeId',
         isStale: false,
         activeRevision: undefined,
         folder: undefined,
@@ -108,7 +112,7 @@ describe('nodesCache', () => {
             creationTime: new Date('2021-01-01'),
             storageSize: 100,
             contentAuthor: resultOk('test@test.com'),
-            claimedModificationTime: new Date('2021-02-01')
+            claimedModificationTime: new Date('2021-02-01'),
         });
         const node = generateNode('node1', '', { activeRevision });
 
@@ -135,7 +139,9 @@ describe('nodesCache', () => {
             await cache.getNode('badObject');
             fail('Should have thrown an error');
         } catch (error) {
-            expect(`${error}`).toBe('Error: Failed to deserialise node: Unexpected token \'a\', \"aaa\" is not valid JSON');
+            expect(`${error}`).toBe(
+                'Error: Failed to deserialise node: Unexpected token \'a\', \"aaa\" is not valid JSON',
+            );
         }
 
         try {
@@ -153,7 +159,7 @@ describe('nodesCache', () => {
             cache,
             ['node1', 'node1a', 'node1b', 'node1c', 'node1c-alpha', 'node1c-beta', 'node2', 'node2a', 'node2b'],
             ['node3'],
-        )
+        );
     });
 
     it('should remove node and its children', async () => {
@@ -162,8 +168,8 @@ describe('nodesCache', () => {
         await verifyNodesCache(
             cache,
             ['node1', 'node1a', 'node1b', 'node1c', 'node1c-alpha', 'node1c-beta', 'node3'],
-            ['node2', 'node2a', 'node2b',],
-        )
+            ['node2', 'node2a', 'node2b'],
+        );
     });
 
     it('should remove node and its children recursively', async () => {
@@ -198,9 +204,21 @@ describe('nodesCache', () => {
         expect(nodeUids).toStrictEqual(['volumeId~:node1', 'volumeId~:node2', 'volumeId~:node3']);
         await verifyNodesCache(
             cache,
-            ['root', 'node1', 'node1a', 'node1b', 'node1c', 'node1c-alpha', 'node1c-beta', 'node2', 'node2a', 'node2b', 'node3'],
+            [
+                'root',
+                'node1',
+                'node1a',
+                'node1b',
+                'node1c',
+                'node1c-alpha',
+                'node1c-beta',
+                'node2',
+                'node2a',
+                'node2b',
+                'node3',
+            ],
             ['badObject'],
-        )
+        );
     });
 
     it('should iterate trashed nodes', async () => {
@@ -224,8 +242,18 @@ describe('nodesCache', () => {
         await generateTreeStructure(cache);
         await cache.setNodesStaleFromVolume('volumeId');
 
-        const staleNodeUids = ['node1', 'node1a', 'node1b', 'node1c', 'node1c-alpha', 'node1c-beta', 'node2', 'node2a', 'node2b', 'node3']
-            .map((uid) => `volumeId~:${uid}`);
+        const staleNodeUids = [
+            'node1',
+            'node1a',
+            'node1b',
+            'node1c',
+            'node1c-alpha',
+            'node1c-beta',
+            'node2',
+            'node2a',
+            'node2b',
+            'node3',
+        ].map((uid) => `volumeId~:${uid}`);
         const result = await Array.fromAsync(cache.iterateNodes([...staleNodeUids, 'volume2~:root-otherVolume']));
         const got = result.map((item) => ({ uid: item.uid, isStale: item.ok ? item.node.isStale : item.error }));
         const expected = [

package/src/internal/nodes/cache.ts

@@ -1,28 +1,29 @@
-import { EntityResult } from "../../cache";
-import { ProtonDriveEntitiesCache, Logger, resultOk, Result } from "../../interface";
-import { splitNodeUid } from "../uids";
-import { DecryptedNode, DecryptedRevision } from "./interface";
+import { EntityResult } from '../../cache';
+import { ProtonDriveEntitiesCache, Logger, resultOk, Result } from '../../interface';
+import { splitNodeUid } from '../uids';
+import { DecryptedNode, DecryptedRevision } from './interface';
 
 export enum CACHE_TAG_KEYS {
     ParentUid = 'nodeParentUid',
     Trashed = 'nodeTrashed',
+    Roots = 'nodeRoot',
 }
 
-type DecryptedNodeResult = (
-    {uid: string, ok: true, node: DecryptedNode} |
-    {uid: string, ok: false, error: string}
-);
+type DecryptedNodeResult = { uid: string; ok: true; node: DecryptedNode } | { uid: string; ok: false; error: string };
 
 /**
  * Provides caching for nodes metadata.
- * 
+ *
  * The cache is responsible for serialising and deserialising node metadata,
  * recording parent-child relationships, and recursively removing nodes.
- * 
+ *
  * The cache of node metadata should not contain any crypto material.
  */
 export class NodesCache {
-    constructor(private logger: Logger, private driveCache: ProtonDriveEntitiesCache) {
+    constructor(
+        private logger: Logger,
+        private driveCache: ProtonDriveEntitiesCache,
+    ) {
         this.logger = logger;
         this.driveCache = driveCache;
     }
@@ -34,10 +35,12 @@ export class NodesCache {
 
         const tags = [`volume:${volumeId}`];
         if (node.parentUid) {
-            tags.push(`${CACHE_TAG_KEYS.ParentUid}:${node.parentUid}`)
+            tags.push(`${CACHE_TAG_KEYS.ParentUid}:${node.parentUid}`);
+        } else {
+            tags.push(`${CACHE_TAG_KEYS.Roots}:${volumeId}`);
         }
         if (node.trashTime) {
-            tags.push(`${CACHE_TAG_KEYS.Trashed}`)
+            tags.push(`${CACHE_TAG_KEYS.Trashed}`);
         }
 
         await this.driveCache.setEntity(key, nodeData, tags);
@@ -50,7 +53,7 @@ export class NodesCache {
             return deserialiseNode(nodeData);
         } catch (error: unknown) {
             await this.removeCorruptedNode({ nodeUid }, error);
-            throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`)
+            throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`);
         }
     }
 
@@ -74,13 +77,27 @@ export class NodesCache {
         }
     }
 
+    /**
+     * Remove all entries associated with a volume.
+     *
+     * This is needed when a user looses access to a volume.
+     */
+    async removeVolume(volumeId: string): Promise<void> {
+        for await (const result of this.iterateRootNodeUids(volumeId)) {
+            await this.removeNodes([result.key]);
+        }
+    }
+
     /**
      * Remove corrupted node never throws, but it logs so we can know
      * about issues and fix them. It is crucial to remove corrupted
      * nodes and rather let SDK re-fetch them than to auotmatically
      * fix issues and do not bother user with it.
      */
-    private async removeCorruptedNode({ nodeUid, cacheUid }: { nodeUid?: string, cacheUid?: string }, corruptionError: unknown): Promise<void> {
+    private async removeCorruptedNode(
+        { nodeUid, cacheUid }: { nodeUid?: string; cacheUid?: string },
+        corruptionError: unknown,
+    ): Promise<void> {
         this.logger.error(`Removing corrupted nodes from the cache`, corruptionError);
         try {
             if (nodeUid) {
@@ -92,7 +109,9 @@ export class NodesCache {
             // The node 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 node from the cache: ${removingError instanceof Error ? removingError.message : removingError}`);
+            this.logger.warn(
+                `Failed to remove corrupted node from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
+            );
         }
     }
 
@@ -115,7 +134,9 @@ export class NodesCache {
 
     private async getRecursiveChildrenCacheUids(parentNodeUid: string): Promise<string[]> {
         const cacheUids = [];
-        for await (const result of this.driveCache.iterateEntitiesByTag(`${CACHE_TAG_KEYS.ParentUid}:${parentNodeUid}`)) {
+        for await (const result of this.driveCache.iterateEntitiesByTag(
+            `${CACHE_TAG_KEYS.ParentUid}:${parentNodeUid}`,
+        )) {
             cacheUids.push(result.key);
             const childrenCacheUids = await this.getRecursiveChildrenCacheUids(getNodeUid(result.key));
             cacheUids.push(...childrenCacheUids);
@@ -134,7 +155,9 @@ export class NodesCache {
     }
 
     async *iterateChildren(parentNodeUid: string): AsyncGenerator<DecryptedNodeResult> {
-        for await (const result of this.driveCache.iterateEntitiesByTag(`${CACHE_TAG_KEYS.ParentUid}:${parentNodeUid}`)) {
+        for await (const result of this.driveCache.iterateEntitiesByTag(
+            `${CACHE_TAG_KEYS.ParentUid}:${parentNodeUid}`,
+        )) {
             const node = await this.convertCacheResult(result);
             if (node && (!node.ok || !node.node.trashTime)) {
                 yield node;
@@ -142,6 +165,10 @@ export class NodesCache {
         }
     }
 
+    async *iterateRootNodeUids(volumeId: string): AsyncGenerator<EntityResult<string>> {
+        yield* this.driveCache.iterateEntitiesByTag(`${CACHE_TAG_KEYS.Roots}:${volumeId}`);
+    }
+
     async *iterateTrashedNodes(): AsyncGenerator<DecryptedNodeResult> {
         for await (const result of this.driveCache.iterateEntitiesByTag(CACHE_TAG_KEYS.Trashed)) {
             const node = await this.convertCacheResult(result);
@@ -160,13 +187,13 @@ export class NodesCache {
         try {
             nodeUid = getNodeUid(result.key);
         } catch (error: unknown) {
-            await this.removeCorruptedNode({ cacheUid: result.key }, error)
+            await this.removeCorruptedNode({ cacheUid: result.key }, error);
             return null;
         }
         if (result.ok) {
             let node;
             try {
-                node = deserialiseNode(result.value)
+                node = deserialiseNode(result.value);
             } catch (error: unknown) {
                 await this.removeCorruptedNode({ nodeUid }, error);
                 return null;
@@ -175,7 +202,7 @@ export class NodesCache {
                 uid: nodeUid,
                 ok: true,
                 node,
-            }
+            };
         } else {
             return {
                 ...result,
@@ -221,31 +248,38 @@ function serialiseNode(node: DecryptedNode) {
 function deserialiseNode(nodeData: string): DecryptedNode {
     const node = JSON.parse(nodeData);
     if (
-       !node || typeof node !== 'object' ||
-       !node.uid || typeof node.uid !== 'string' ||
-       !node.directMemberRole || typeof node.directMemberRole !== 'string' ||
-       !node.type || typeof node.type !== 'string' ||
-       (typeof node.mediaType !== 'string' && node.mediaType !== undefined) ||
-       typeof node.isShared !== 'boolean' ||
-       !node.creationTime || typeof node.creationTime !== 'string' ||
-       (typeof node.trashTime !== 'string' && node.trashTime !== undefined) ||
-       (typeof node.folder !== 'object' && node.folder !== undefined) ||
-       (typeof node.folder?.claimedModificationTime !== 'string' && node.folder?.claimedModificationTime !== undefined)
-   ) {
-       throw new Error(`Invalid node data: ${nodeData}`);
-   }
-   return {
-       ...node,
-       creationTime: new Date(node.creationTime),
-       trashTime: node.trashTime ? new Date(node.trashTime) : undefined,
-       activeRevision: node.activeRevision ? deserialiseRevision(node.activeRevision) : undefined,
-       folder: node.folder
+        !node ||
+        typeof node !== 'object' ||
+        !node.uid ||
+        typeof node.uid !== 'string' ||
+        !node.directMemberRole ||
+        typeof node.directMemberRole !== 'string' ||
+        !node.type ||
+        typeof node.type !== 'string' ||
+        (typeof node.mediaType !== 'string' && node.mediaType !== undefined) ||
+        typeof node.isShared !== 'boolean' ||
+        !node.creationTime ||
+        typeof node.creationTime !== 'string' ||
+        (typeof node.trashTime !== 'string' && node.trashTime !== undefined) ||
+        (typeof node.folder !== 'object' && node.folder !== undefined) ||
+        (typeof node.folder?.claimedModificationTime !== 'string' && node.folder?.claimedModificationTime !== undefined)
+    ) {
+        throw new Error(`Invalid node data: ${nodeData}`);
+    }
+    return {
+        ...node,
+        creationTime: new Date(node.creationTime),
+        trashTime: node.trashTime ? new Date(node.trashTime) : undefined,
+        activeRevision: node.activeRevision ? deserialiseRevision(node.activeRevision) : undefined,
+        folder: node.folder
             ? {
-                ...node.folder,
-                claimedModificationTime: node.folder.claimedModificationTime ? new Date(node.folder.claimedModificationTime) : undefined,
-            }
+                  ...node.folder,
+                  claimedModificationTime: node.folder.claimedModificationTime
+                      ? new Date(node.folder.claimedModificationTime)
+                      : undefined,
+              }
             : undefined,
-   };
+    };
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -261,7 +295,7 @@ function deserialiseRevision(revision: any): Result<DecryptedRevision, Error> {
         return resultOk({
             ...revision.value,
             creationTime: new Date(revision.value.creationTime),
-            claimedModificationTime: new Date(revision.value.claimedModificationTime)
+            claimedModificationTime: new Date(revision.value.claimedModificationTime),
         });
     }
 

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

@@ -1,20 +1,20 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { MemoryCache } from "../../cache";
-import { CachedCryptoMaterial } from "../../interface";
-import { getMockLogger } from "../../tests/logger";
-import { NodesCryptoCache } from "./cryptoCache";
+import { PrivateKey, SessionKey } from '../../crypto';
+import { MemoryCache } from '../../cache';
+import { CachedCryptoMaterial } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { NodesCryptoCache } from './cryptoCache';
 
 describe('nodesCryptoCache', () => {
     let memoryCache: MemoryCache<CachedCryptoMaterial>;
     let cache: NodesCryptoCache;
 
     const generatePrivateKey = (name: string) => {
-        return name as unknown as PrivateKey
-    }
+        return name as unknown as PrivateKey;
+    };
 
     const generateSessionKey = (name: string) => {
-        return name as unknown as SessionKey
-    }
+        return name as unknown as SessionKey;
+    };
 
     beforeEach(async () => {
         memoryCache = new MemoryCache();
@@ -28,7 +28,12 @@ describe('nodesCryptoCache', () => {
 
     it('should store and retrieve keys', async () => {
         const nodeId = 'newNodeId';
-        const keys = { passphrase: 'pass', key: generatePrivateKey('privateKey'), passphraseSessionKey: generateSessionKey('sessionKey'), hashKey: undefined };
+        const keys = {
+            passphrase: 'pass',
+            key: generatePrivateKey('privateKey'),
+            passphraseSessionKey: generateSessionKey('sessionKey'),
+            hashKey: undefined,
+        };
 
         await cache.setNodeKeys(nodeId, keys);
         const result = await cache.getNodeKeys(nodeId);
@@ -38,8 +43,18 @@ describe('nodesCryptoCache', () => {
 
     it('should replace and retrieve new keys', async () => {
         const nodeId = 'newNodeId';
-        const keys1 = { passphrase: 'pass', key: generatePrivateKey('privateKey1'), passphraseSessionKey: generateSessionKey('sessionKey1'), hashKey: undefined };
-        const keys2 = { passphrase: 'pass', key: generatePrivateKey('privateKey2'), passphraseSessionKey: generateSessionKey('sessionKey2'), hashKey: undefined };
+        const keys1 = {
+            passphrase: 'pass',
+            key: generatePrivateKey('privateKey1'),
+            passphraseSessionKey: generateSessionKey('sessionKey1'),
+            hashKey: undefined,
+        };
+        const keys2 = {
+            passphrase: 'pass',
+            key: generatePrivateKey('privateKey2'),
+            passphraseSessionKey: generateSessionKey('sessionKey2'),
+            hashKey: undefined,
+        };
 
         await cache.setNodeKeys(nodeId, keys1);
         await cache.setNodeKeys(nodeId, keys2);
@@ -50,7 +65,12 @@ describe('nodesCryptoCache', () => {
 
     it('should remove keys', async () => {
         const nodeId = 'newNodeId';
-        const keys = { passphrase: 'pass', key: generatePrivateKey('privateKey'), passphraseSessionKey: generateSessionKey('sessionKey'), hashKey: undefined };
+        const keys = {
+            passphrase: 'pass',
+            key: generatePrivateKey('privateKey'),
+            passphraseSessionKey: generateSessionKey('sessionKey'),
+            hashKey: undefined,
+        };
 
         await cache.setNodeKeys(nodeId, keys);
         await cache.removeNodeKeys([nodeId]);
@@ -89,4 +109,4 @@ describe('nodesCryptoCache', () => {
             expect(`${error}`).toBe('Error: Entity not found');
         }
     });
-});
+});

package/src/internal/nodes/cryptoCache.ts

@@ -1,14 +1,17 @@
-import { ProtonDriveCryptoCache, Logger } from "../../interface";
-import { DecryptedNodeKeys } from "./interface";
+import { ProtonDriveCryptoCache, Logger } from '../../interface';
+import { DecryptedNodeKeys } from './interface';
 
 /**
  * Provides caching for node crypto material.
- * 
+ *
  * The cache is responsible for serialising and deserialising node
  * crypto material.
  */
 export class NodesCryptoCache {
-    constructor(private logger: Logger, private driveCache: ProtonDriveCryptoCache) {
+    constructor(
+        private logger: Logger,
+        private driveCache: ProtonDriveCryptoCache,
+    ) {
         this.logger = logger;
         this.driveCache = driveCache;
     }
@@ -26,7 +29,9 @@ export class NodesCryptoCache {
             } 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 node keys from the cache: ${removingError instanceof Error ? removingError.message : removingError}`);
+                this.logger.warn(
+                    `Failed to remove corrupted node keys from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
+                );
             }
             throw new Error(`Failed to deserialize node keys: missing passphrase`);
         }