@protontech/drive-sdk 0.0.10

package/src/internal/nodes/nodesAccess.ts

@@ -0,0 +1,360 @@
+import { c } from 'ttag';
+
+import { PrivateKey, SessionKey } from "../../crypto";
+import { InvalidNameError, Logger, MissingNode, NodeType, Result, resultError, resultOk } from "../../interface";
+import { DecryptionError, ProtonDriveError } from "../../errors";
+import { getErrorMessage } from '../errors';
+import { BatchLoading } from "../batchLoading";
+import { makeNodeUid, splitNodeUid } from "../uids";
+import { NodeAPIService } from "./apiService";
+import { NodesCache } from "./cache"
+import { NodesCryptoCache } from "./cryptoCache";
+import { NodesCryptoService } from "./cryptoService";
+import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from "./extendedAttributes";
+import { SharesService, EncryptedNode, DecryptedUnparsedNode, DecryptedNode, DecryptedNodeKeys } from "./interface";
+import { validateNodeName } from "./validations";
+import { isProtonDocument, isProtonSheet } from './mediaTypes';
+
+/**
+ * Provides access to node metadata.
+ * 
+ * The node access module is responsible for fetching, decrypting and caching
+ * nodes metadata.
+ */
+export class NodesAccess {
+    constructor(
+        private logger: Logger,
+        private apiService: NodeAPIService,
+        private cache: NodesCache,
+        private cryptoCache: NodesCryptoCache,
+        private cryptoService: NodesCryptoService,
+        private shareService: SharesService,
+    ) {
+        this.logger = logger;
+        this.apiService = apiService;
+        this.cache = cache;
+        this.cryptoCache = cryptoCache;
+        this.cryptoService = cryptoService;
+        this.shareService = shareService;
+    }
+
+    async getMyFilesRootFolder() {
+        const { volumeId, rootNodeId } = await this.shareService.getMyFilesIDs();
+        const nodeUid = makeNodeUid(volumeId, rootNodeId);
+        return this.getNode(nodeUid);
+    }
+
+    async getNode(nodeUid: string): Promise<DecryptedNode> {
+        let cachedNode;
+        try {
+            cachedNode = await this.cache.getNode(nodeUid);
+        } catch { }
+
+        if (cachedNode && !cachedNode.isStale) {
+            return cachedNode;
+        }
+
+        this.logger.debug(`Node ${nodeUid} is ${cachedNode?.isStale ? 'stale' : 'not cached'}`);
+
+        const { node } = await this.loadNode(nodeUid);
+        return node;
+    }
+
+    async *iterateFolderChildren(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        // Ensure the parent is loaded and up-to-date.
+        const parentNode = await this.getNode(parentNodeUid);
+
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal) });
+
+        const areChildrenCached = await this.cache.isFolderChildrenLoaded(parentNodeUid);
+        if (areChildrenCached) {
+            for await (const node of this.cache.iterateChildren(parentNodeUid)) {
+                if (node.ok && !node.node.isStale) {
+                    yield node.node;
+                } else {
+                    yield* batchLoading.load(node.uid);
+                }
+            }
+            yield* batchLoading.loadRest();
+            return;
+        }
+
+        this.logger.debug(`Folder ${parentNodeUid} children are not cached`);
+        for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, signal)) {
+            let node;
+            try {
+                node = await this.cache.getNode(nodeUid);
+            } catch { }
+
+            if (node && !node.isStale) {
+                yield node;
+            } else {
+                this.logger.debug(`Node ${nodeUid} from ${parentNodeUid} is ${node?.isStale ? 'stale' : 'not cached'}`);
+                yield* batchLoading.load(nodeUid);
+            }
+        }
+        yield* batchLoading.loadRest();
+        await this.cache.setFolderChildrenLoaded(parentNodeUid);
+    }
+
+    // Improvement requested: keep status of loaded trash and leverage cache.
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        const { volumeId } = await this.shareService.getMyFilesIDs();
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.loadNodes(nodeUids, signal) });
+        for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
+            let node;
+            try {
+                node = await this.cache.getNode(nodeUid);
+            } catch { }
+
+            if (node && !node.isStale) {
+                yield node;
+            } else {
+                this.logger.debug(`Node ${nodeUid} trom trash is ${node?.isStale ? 'stale' : 'not cached'}`);
+                yield* batchLoading.load(nodeUid);
+            }
+        }
+        yield* batchLoading.loadRest();
+    }
+
+    async *iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
+        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({ iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, signal) });
+        for await (const result of this.cache.iterateNodes(nodeUids)) {
+            if (result.ok && !result.node.isStale) {
+                yield result.node;
+            } else {
+                yield* batchLoading.load(result.uid);
+            }
+        }
+        yield* batchLoading.loadRest();
+    }
+
+    private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
+        const encryptedNode = await this.apiService.getNode(nodeUid);
+        return this.decryptNode(encryptedNode);
+    }
+
+    private async* loadNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        for await (const result of this.loadNodesWithMissingReport(nodeUids, signal)) {
+            if ('missingUid' in result) {
+                continue;
+            }
+            yield result;
+        }
+    }
+
+    private async* loadNodesWithMissingReport(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
+        const returnedNodeUids: string[] = [];
+        const errors = [];
+
+        for await (const encryptedNode of this.apiService.iterateNodes(nodeUids, signal)) {
+            returnedNodeUids.push(encryptedNode.uid);
+            try {
+                const { node } = await this.decryptNode(encryptedNode);
+                yield node;
+            } catch (error: unknown) {
+                errors.push(error);
+            }
+        }
+
+        if (errors.length > 0) {
+            this.logger.error(`Failed to decrypt ${errors.length} nodes`, errors);
+            throw new ProtonDriveError(c('Error').t`Failed to decrypt some nodes`, { cause: errors });
+        }
+
+        const missingNodeUids = nodeUids.filter((nodeUid) => !returnedNodeUids.includes(nodeUid));
+
+        if (missingNodeUids.length) {
+            this.logger.debug(`Removing ${missingNodeUids.length} nodes from cache not existing on the API anymore`);
+            await this.cache.removeNodes(missingNodeUids);
+            for (const missingNodeUid of missingNodeUids) {
+                yield { missingUid: missingNodeUid };
+            }
+        }
+    }
+
+    private async decryptNode(encryptedNode: EncryptedNode): Promise<{ node: DecryptedNode, keys?: DecryptedNodeKeys }> {
+        let parentKey;
+        try {
+            const parentKeys = await this.getParentKeys(encryptedNode);
+            parentKey = parentKeys.key;
+        } catch (error: unknown) {
+            if (error instanceof DecryptionError) {
+                return {
+                    node: {
+                        ...encryptedNode,
+                        isStale: false,
+                        name: resultError(error),
+                        keyAuthor: resultError({
+                            claimedAuthor: encryptedNode.encryptedCrypto.signatureEmail,
+                            error: getErrorMessage(error),
+                        }),
+                        nameAuthor: resultError({
+                            claimedAuthor: encryptedNode.encryptedCrypto.nameSignatureEmail,
+                            error: getErrorMessage(error),
+                        }),
+                        errors: [error],
+                    },
+                };
+            }
+            throw error;
+        }
+
+        const { node: unparsedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
+        const node = await this.parseNode(unparsedNode);
+        try {
+            await this.cache.setNode(node);
+        } catch (error: unknown) {
+            this.logger.error(`Failed to cache node ${node.uid}`, error);
+        }
+        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, keys };
+    }
+
+    private async parseNode(unparsedNode: DecryptedUnparsedNode): Promise<DecryptedNode> {
+        let nodeName: Result<string, Error | InvalidNameError> = unparsedNode.name;
+        if (unparsedNode.name.ok) {
+            try {
+                validateNodeName(unparsedNode.name.value);
+            } catch (error: unknown) {
+                this.logger.warn(`Node name validation failed: ${error instanceof Error ? error.message : error}`);
+                nodeName = resultError({
+                    name: unparsedNode.name.value,
+                    error: error instanceof Error ? error.message : c('Error').t`Unknown error`,
+                });
+            }
+        }
+
+        if (unparsedNode.type === NodeType.File) {
+            const extendedAttributes = unparsedNode.activeRevision?.ok
+                ? parseFileExtendedAttributes(this.logger, unparsedNode.activeRevision.value.extendedAttributes)
+                : undefined;
+
+            return {
+                ...unparsedNode,
+                isStale: false,
+                activeRevision: !unparsedNode.activeRevision?.ok ? unparsedNode.activeRevision : resultOk({
+                    uid: unparsedNode.activeRevision.value.uid,
+                    state: unparsedNode.activeRevision.value.state,
+                    creationTime: unparsedNode.activeRevision.value.creationTime,
+                    storageSize: unparsedNode.activeRevision.value.storageSize,
+                    contentAuthor: unparsedNode.activeRevision.value.contentAuthor,
+                    thumbnails: unparsedNode.activeRevision.value.thumbnails,
+                    ...extendedAttributes,
+                }),
+                folder: undefined,
+            }
+        }
+
+        const extendedAttributes = unparsedNode.folder?.extendedAttributes
+            ? parseFolderExtendedAttributes(this.logger, unparsedNode.folder.extendedAttributes)
+            : undefined;
+        return {
+            ...unparsedNode,
+            name: nodeName,
+            isStale: false,
+            activeRevision: undefined,
+            folder: extendedAttributes ? {
+                ...extendedAttributes,
+            } : undefined,
+        }
+    }
+
+    async getParentKeys(node: Pick<DecryptedNode, 'parentUid' | 'shareId'>): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+        if (node.parentUid) {
+            try {
+                return await this.getNodeKeys(node.parentUid);
+            } catch (error: unknown) {
+                if (error instanceof DecryptionError) {
+                    // Change the error message to be more specific.
+                    // Original error message is referring to node, while here
+                    // it referes to as parent to follow the method context.
+                    throw new DecryptionError(c('Error').t`Parent cannot be decrypted`);
+                }
+                throw error;
+            }
+        }
+        if (node.shareId) {
+            return {
+                key: await this.shareService.getSharePrivateKey(node.shareId),
+            }
+        }
+        // This is bug that should not happen.
+        // API cannot provide node without parent or share.
+        throw new Error('Node has neither parent node nor share');
+    }
+
+    async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
+        try {
+            return await this.cryptoCache.getNodeKeys(nodeUid);
+        } catch {
+            const { keys } = await this.loadNode(nodeUid);
+            if (!keys) {
+                throw new DecryptionError(c('Error').t`Item cannot be decrypted`);
+            }
+            return keys;
+        }
+    }
+
+    async getNodePrivateAndSessionKeys(nodeUid: string): Promise<{
+        key: PrivateKey,
+        passphrase: string,
+        passphraseSessionKey: SessionKey,
+        contentKeyPacketSessionKey?: SessionKey,
+        nameSessionKey: SessionKey,
+    }> {
+        const node = await this.getNode(nodeUid);
+        const { key: parentKey } = await this.getParentKeys(node);
+        const { key, passphrase, passphraseSessionKey, contentKeyPacketSessionKey } = await this.getNodeKeys(nodeUid);
+        const nameSessionKey = await this.cryptoService.getNameSessionKey(node, parentKey);
+        return {
+            key,
+            passphrase,
+            passphraseSessionKey,
+            contentKeyPacketSessionKey,
+            nameSessionKey,
+        };
+    }
+
+    async getRootNodeEmailKey(nodeUid: string): Promise<{
+        email: string,
+        addressId: string,
+        addressKey: PrivateKey,
+        addressKeyId: string,
+    }> {
+        const rootNode = await this.getRootNode(nodeUid);
+        if (!rootNode.shareId) {
+            throw new Error(`Node "${nodeUid}" is not accessible - missing root shareId`);
+        }
+        return this.shareService.getContextShareMemberEmailKey(rootNode.shareId);
+    }
+
+    async getNodeUrl(nodeUid: string): Promise<string> {
+        const node = await this.getNode(nodeUid);
+        if (isProtonDocument(node.mediaType) || isProtonSheet(node.mediaType)) {
+            const { volumeId, nodeId } = splitNodeUid(nodeUid);
+            const type = isProtonDocument(node.mediaType) ? 'doc' : 'sheet';
+            return `https://docs.proton.me/doc?type=${type}&mode=open&volumeId=${volumeId}&linkId=${nodeId}`;
+        }
+
+        const rootNode = await this.getRootNode(nodeUid);
+        if (!rootNode.shareId) {
+            throw new ProtonDriveError(c('Error').t`Node is not accessible`);
+        }
+        const { nodeId } = splitNodeUid(nodeUid);
+        const type = node.type === NodeType.File ? 'file' : 'folder';
+
+        return `https://drive.proton.me/${rootNode.shareId}/${type}/${nodeId}`;
+    }
+
+    private async getRootNode(nodeUid: string): Promise<DecryptedNode> {
+        const node = await this.getNode(nodeUid);
+        return node.parentUid ? this.getRootNode(node.parentUid) : node;
+    };
+}

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

@@ -0,0 +1,221 @@
+import { NodeAPIService } from "./apiService";
+import { NodesCryptoCache } from "./cryptoCache";
+import { NodesCryptoService } from "./cryptoService";
+import { NodesAccess } from './nodesAccess';
+import { NodesEvents } from './events';
+import { DecryptedNode } from './interface';
+import { NodesManagement } from './nodesManagement';
+
+describe('NodesManagement', () => {
+    let apiService: NodeAPIService;
+    let cryptoCache: NodesCryptoCache;
+    let cryptoService: NodesCryptoService;
+    let nodesAccess: NodesAccess;
+    let nodesEvents: NodesEvents;
+    let management: NodesManagement;
+
+    let nodes: { [uid: string]: DecryptedNode };
+
+    beforeEach(() => {
+        nodes = {
+            nodeUid: {
+                uid: 'nodeUid',
+                parentUid: 'parentUid',
+                name: { ok: true, value: 'old name' },
+                keyAuthor: { ok: true, value: 'keyAauthor' },
+                nameAuthor: { ok: true, value: 'nameAuthor' },
+                hash: 'hash',
+                mediaType: 'mediaType',
+            } as DecryptedNode,
+            anonymousNodeUid: {
+                uid: 'anonymousNodeUid',
+                parentUid: 'parentUid',
+                name: { ok: true, value: 'old name' },
+                keyAuthor: { ok: true, value: null },
+                nameAuthor: { ok: true, value: 'nameAuthor' },
+                hash: 'hash',
+                mediaType: 'mediaType',
+            } as DecryptedNode,
+            parentUid: {
+                uid: 'parentUid',
+                name: { ok: true, value: 'parent' },
+            } as DecryptedNode,
+            newParentUid: {
+                uid: 'newParentUid',
+                name: { ok: true, value: 'new parent' },
+            } as DecryptedNode,
+        };
+
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {
+            renameNode: jest.fn(),
+            moveNode: jest.fn(),
+            trashNodes: jest.fn(),
+            restoreNodes: jest.fn(),
+            deleteNodes: jest.fn(),
+            createFolder: jest.fn(),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoCache = {
+            setNodeKeys: jest.fn(),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoService = {
+            encryptNewName: jest.fn().mockResolvedValue({
+                signatureEmail: 'newSignatureEmail',
+                armoredNodeName: 'newArmoredNodeName',
+                hash: 'newHash',
+            }),
+            moveNode: jest.fn(),
+            createFolder: jest.fn(),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesAccess = {
+            getNode: jest.fn().mockImplementation((uid: string) => nodes[uid]),
+            getNodeKeys: jest.fn().mockImplementation((uid) => ({
+                key: `${uid}-key`,
+                hashKey: `${uid}-hashKey`,
+                passphrase: `${uid}-passphrase`,
+                passphraseSessionKey: `${uid}-passphraseSessionKey`,
+            })),
+            getParentKeys: jest.fn().mockImplementation(({ uid }) => ({
+                key: `${nodes[uid].parentUid}-key`,
+                hashKey: `${nodes[uid].parentUid}-hashKey`,
+            })),
+            iterateNodes: jest.fn(),
+            getNodePrivateAndSessionKeys: jest.fn().mockImplementation((uid) => Promise.resolve({
+                key: `${uid}-key`,
+                passphrase: `${uid}-passphrase`,
+                passphraseSessionKey: `${uid}-passphraseSessionKey`,
+                contentKeyPacketSessionKey: `${uid}-contentKeyPacketSessionKey`,
+                nameSessionKey: `${uid}-nameSessionKey`,
+            })),
+            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: "root-email", addressKey: "root-key" }),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesEvents = {
+            nodeCreated: jest.fn(),
+            nodeUpdated: jest.fn(),
+            nodesDeleted: jest.fn(),
+        }
+
+        management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess, nodesEvents);
+    });
+
+    it('renameNode manages rename and updates cache', async () => {
+        const newNode = await management.renameNode('nodeUid', 'new name');
+
+        expect(newNode).toEqual({
+            ...nodes.nodeUid,
+            name: { ok: true, value: 'new name' },
+            nameAuthor: { ok: true, value: 'newSignatureEmail' },
+            hash: 'newHash',
+        });
+        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('nodeUid');
+        expect(cryptoService.encryptNewName).toHaveBeenCalledWith(
+            'nodeUid-nameSessionKey',
+            { email: "root-email", addressKey: "root-key" },
+            'parentUid-hashKey',
+            'new name',
+        );
+        expect(apiService.renameNode).toHaveBeenCalledWith(
+            nodes.nodeUid.uid,
+            { hash: nodes.nodeUid.hash },
+            { encryptedName: 'newArmoredNodeName', nameSignatureEmail: 'newSignatureEmail', hash: 'newHash' }
+        );
+        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+    });
+
+    it('moveNode manages move and updates cache', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'movedArmoredNodeName',
+            hash: 'movedHash',
+            armoredNodePassphrase: 'movedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'movedArmoredNodePassphraseSignature',
+            signatureEmail: 'movedSignatureEmail',
+            nameSignatureEmail: 'movedNameSignatureEmail',
+        }
+        cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newNode = await management.moveNode('nodeUid', 'newParentNodeUid');
+
+        expect(newNode).toEqual({
+            ...nodes.nodeUid,
+            parentUid: 'newParentNodeUid',
+            hash: 'movedHash',
+            keyAuthor: { ok: true, value: 'movedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
+        });
+        expect(nodesAccess.getRootNodeEmailKey).toHaveBeenCalledWith('newParentNodeUid');
+        expect(cryptoService.moveNode).toHaveBeenCalledWith(
+            nodes.nodeUid,
+            expect.objectContaining({ 
+                key: 'nodeUid-key',
+                passphrase: 'nodeUid-passphrase', 
+                passphraseSessionKey: 'nodeUid-passphraseSessionKey',
+                contentKeyPacketSessionKey: 'nodeUid-contentKeyPacketSessionKey',
+                nameSessionKey: 'nodeUid-nameSessionKey'
+            }),
+            expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
+            { email: "root-email", addressKey: "root-key" },
+        );
+        expect(apiService.moveNode).toHaveBeenCalledWith(
+            'nodeUid',
+            {
+                hash: nodes.nodeUid.hash,
+            },
+            {
+                parentUid: 'newParentNodeUid',
+                ...encryptedCrypto,
+                armoredNodePassphraseSignature: undefined,
+                signatureEmail: undefined,
+            },
+        );
+        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+    });
+
+    it('moveNode manages move of anonymous node', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'movedArmoredNodeName',
+            hash: 'movedHash',
+            armoredNodePassphrase: 'movedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'movedArmoredNodePassphraseSignature',
+            signatureEmail: 'movedSignatureEmail',
+            nameSignatureEmail: 'movedNameSignatureEmail',
+        }
+        cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newNode = await management.moveNode('anonymousNodeUid', 'newParentNodeUid');
+        
+        expect(cryptoService.moveNode).toHaveBeenCalledWith(
+            nodes.anonymousNodeUid,
+            expect.objectContaining({ 
+                key: 'anonymousNodeUid-key',
+                passphrase: 'anonymousNodeUid-passphrase', 
+                passphraseSessionKey: 'anonymousNodeUid-passphraseSessionKey',
+                contentKeyPacketSessionKey: 'anonymousNodeUid-contentKeyPacketSessionKey',
+                nameSessionKey: 'anonymousNodeUid-nameSessionKey'
+            }),
+            expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
+            { email: "root-email", addressKey: "root-key" },
+        );
+        expect(newNode).toEqual({
+            ...nodes.anonymousNodeUid,
+            parentUid: 'newParentNodeUid',
+            hash: 'movedHash',
+            keyAuthor: { ok: true, value: 'movedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
+        });
+        expect(apiService.moveNode).toHaveBeenCalledWith(
+            'anonymousNodeUid',
+            {
+                hash: nodes.nodeUid.hash,
+            },
+            {
+                parentUid: 'newParentNodeUid',
+                ...encryptedCrypto
+            },
+        );
+        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+    });
+});