@protontech/drive-sdk 0.2.0 → 0.3.0

package/src/diagnostic/sdkDiagnostic.ts

@@ -1,6 +1,6 @@
 import { Author, FileDownloader, MaybeNode, NodeType, Revision, ThumbnailType } from '../interface';
 import { ProtonDriveClient } from '../protonDriveClient';
-import { Diagnostic, DiagnosticOptions, DiagnosticResult } from './interface';
+import { Diagnostic, DiagnosticOptions, DiagnosticResult, NodeDetails } from './interface';
 import { IntegrityVerificationStream } from './integrityVerificationStream';
 
 /**
@@ -43,32 +43,19 @@ export class SDKDiagnostic implements Diagnostic {
     }
 
     private async *verifyNode(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
-        const nodeUid = node.ok ? node.value.uid : node.error.uid;
-
         if (!node.ok) {
             yield {
                 type: 'degraded_node',
-                nodeUid,
-                node: node.error,
+                ...getNodeDetails(node),
             };
         }
 
+        yield* this.verifyAuthor(node.ok ? node.value.keyAuthor : node.error.keyAuthor, 'key', node);
+        yield* this.verifyAuthor(node.ok ? node.value.nameAuthor : node.error.nameAuthor, 'name', node);
+
         const activeRevision = getActiveRevision(node);
-        const nodeInfo = {
-            ...getNodeUids(node),
-            node,
-        };
-
-        yield* this.verifyAuthor(node.ok ? node.value.keyAuthor : node.error.keyAuthor, {
-            ...nodeInfo,
-            authorType: 'key',
-        });
-        yield* this.verifyAuthor(node.ok ? node.value.nameAuthor : node.error.nameAuthor, {
-            ...nodeInfo,
-            authorType: 'name',
-        });
         if (activeRevision) {
-            yield* this.verifyAuthor(activeRevision.contentAuthor, { ...nodeInfo, authorType: 'content' });
+            yield* this.verifyAuthor(activeRevision.contentAuthor, 'content', node);
         }
 
         yield* this.verifyFileExtendedAttributes(node);
@@ -81,16 +68,14 @@ export class SDKDiagnostic implements Diagnostic {
         }
     }
 
-    private async *verifyAuthor(
-        author: Author,
-        info: { nodeUid: string; authorType: string; revisionUid?: string; node: MaybeNode },
-    ): AsyncGenerator<DiagnosticResult> {
+    private async *verifyAuthor(author: Author, authorType: string, node: MaybeNode): AsyncGenerator<DiagnosticResult> {
         if (!author.ok) {
             yield {
                 type: 'unverified_author',
+                authorType,
                 claimedAuthor: author.error.claimedAuthor,
                 error: author.error.error,
-                ...info,
+                ...getNodeDetails(node),
             };
         }
     }
@@ -104,17 +89,17 @@ export class SDKDiagnostic implements Diagnostic {
         if (claimedSha1 && !/^[0-9a-f]{40}$/i.test(claimedSha1)) {
             yield {
                 type: 'extended_attributes_error',
-                ...getNodeUids(node),
                 field: 'sha1',
                 value: claimedSha1,
+                ...getNodeDetails(node),
             };
         }
 
         if (expectedAttributes && !claimedSha1) {
             yield {
                 type: 'extended_attributes_missing_field',
-                ...getNodeUids(node),
                 missingField: 'sha1',
+                ...getNodeDetails(node),
             };
         }
     }
@@ -127,7 +112,7 @@ export class SDKDiagnostic implements Diagnostic {
         if (!activeRevision) {
             yield {
                 type: 'content_file_missing_revision',
-                nodeUid: node.ok ? node.value.uid : node.error.uid,
+                ...getNodeDetails(node),
             };
             return;
         }
@@ -158,18 +143,18 @@ export class SDKDiagnostic implements Diagnostic {
             if (claimedSha1 !== computedSha1 || claimedSizeInBytes !== computedSizeInBytes) {
                 yield {
                     type: 'content_integrity_error',
-                    ...getNodeUids(node),
                     claimedSha1,
                     computedSha1,
                     claimedSizeInBytes,
                     computedSizeInBytes,
+                    ...getNodeDetails(node),
                 };
             }
         } catch (error: unknown) {
             yield {
                 type: 'content_download_error',
-                ...getNodeUids(node),
                 error,
+                ...getNodeDetails(node),
             };
         }
     }
@@ -197,8 +182,8 @@ export class SDKDiagnostic implements Diagnostic {
             if (!result[0].ok && result[0].error !== 'Node has no thumbnail') {
                 yield {
                     type: 'thumbnails_error',
-                    nodeUid,
                     error: result[0].error,
+                    ...getNodeDetails(node),
                 };
             }
         } catch (error: unknown) {
@@ -226,6 +211,49 @@ export class SDKDiagnostic implements Diagnostic {
     }
 }
 
+function getNodeDetails(node: MaybeNode): NodeDetails {
+    const errors: {
+        field: string;
+        error: unknown;
+    }[] = [];
+
+    if (!node.ok) {
+        const degradedNode = node.error;
+        if (!degradedNode.name.ok) {
+            errors.push({
+                field: 'name',
+                error: degradedNode.name.error,
+            });
+        }
+        if (degradedNode.activeRevision?.ok === false) {
+            errors.push({
+                field: 'activeRevision',
+                error: degradedNode.activeRevision.error,
+            });
+        }
+        for (const error of degradedNode.errors ?? []) {
+            if (error instanceof Error) {
+                errors.push({
+                    field: 'error',
+                    error,
+                });
+            }
+        }
+    }
+
+    return {
+        safeNodeDetails: {
+            ...getNodeUids(node),
+            nodeType: getNodeType(node),
+            nodeCreationTime: node.ok ? node.value.creationTime : node.error.creationTime,
+            keyAuthor: node.ok ? node.value.keyAuthor : node.error.keyAuthor,
+            nameAuthor: node.ok ? node.value.nameAuthor : node.error.nameAuthor,
+            errors,
+        },
+        sensitiveNodeDetails: node,
+    };
+}
+
 function getNodeUids(node: MaybeNode): { nodeUid: string; revisionUid?: string } {
     const activeRevision = getActiveRevision(node);
     return {

package/src/errors.ts

@@ -70,17 +70,17 @@ export class ValidationError extends ProtonDriveError {
  * or choose another name. The available name is provided in the `availableName`
  * property (that will contain original name with the index that can be used).
  */
-export class NodeAlreadyExistsValidationError extends ValidationError {
-    name = 'NodeAlreadyExistsValidationError';
+export class NodeWithSameNameExistsValidationError extends ValidationError {
+    name = 'NodeWithSameNameExistsValidationError';
 
     public readonly existingNodeUid?: string;
 
-    public readonly ongoingUploadByOtherClient: boolean;
+    public readonly isUnfinishedUpload: boolean;
 
-    constructor(message: string, code: number, existingNodeUid?: string, ongoingUploadByOtherClient = false) {
+    constructor(message: string, code: number, existingNodeUid?: string, isUnfinishedUpload = false) {
         super(message, code);
         this.existingNodeUid = existingNodeUid;
-        this.ongoingUploadByOtherClient = ongoingUploadByOtherClient;
+        this.isUnfinishedUpload = isUnfinishedUpload;
     }
 }
 

package/src/interface/author.ts

@@ -24,6 +24,6 @@ export type AnonymousUser = null;
  * the claimed author and the verification error.
  */
 export type UnverifiedAuthorError = {
-    claimedAuthor?: string;
+    claimedAuthor?: string | AnonymousUser;
     error: string;
 };

package/src/interface/events.ts

@@ -20,13 +20,7 @@ export interface LatestEventIdProvider {
  */
 export type DriveListener = (event: DriveEvent) => Promise<void>;
 
-export type DriveEvent =
-    | NodeEvent
-    | FastForwardEvent
-    | TreeRefreshEvent
-    | TreeRemovalEvent
-    | FastForwardEvent
-    | SharedWithMeUpdated;
+export type DriveEvent = NodeEvent | FastForwardEvent | TreeRefreshEvent | TreeRemovalEvent | SharedWithMeUpdated;
 
 export type NodeEvent =
     | {

package/src/interface/sharing.ts

@@ -51,6 +51,7 @@ export type Bookmark = {
     uid: string;
     creationTime: Date;
     url: string;
+    customPassword?: string;
     node: {
         name: string;
         type: NodeType;
@@ -65,8 +66,9 @@ export type Bookmark = {
  * SDK to represent the bookmark in a way that is easy to work with. Whenever
  * any field cannot be decrypted, it is returned as `DegradedBookmark` type.
  */
-export type DegradedBookmark = Omit<Bookmark, 'url' | 'node'> & {
+export type DegradedBookmark = Omit<Bookmark, 'url' | 'customPassword' | 'node'> & {
     url: Result<string, Error>;
+    customPassword: Result<string | undefined, Error>;
     node: Omit<Bookmark['node'], 'name'> & {
         name: Result<string, Error | InvalidNameError>;
     };

package/src/internal/apiService/apiService.ts

@@ -239,7 +239,11 @@ export class DriveAPIService {
             throw new AbortError(c('Error').t`Request aborted`);
         }
 
-        this.logger.debug(`${request.method} ${request.url}`);
+        if (attempt > 0) {
+            this.logger.debug(`${request.method} ${request.url}: retry ${attempt}`);
+        } else {
+            this.logger.debug(`${request.method} ${request.url}`);
+        }
 
         if (this.hasReachedServerErrorLimit) {
             this.logger.warn('Server errors limit reached');
@@ -250,6 +254,8 @@ export class DriveAPIService {
             throw new RateLimitedError(c('Error').t`Too many server requests, please try again later`);
         }
 
+        const start = Date.now();
+
         let response;
         try {
             response = await callback();
@@ -276,10 +282,13 @@ export class DriveAPIService {
             throw error;
         }
 
+        const end = Date.now();
+        const duration = end - start;
+
         if (response.ok) {
-            this.logger.info(`${request.method} ${request.url}: ${response.status}`);
+            this.logger.info(`${request.method} ${request.url}: ${response.status} (${duration}ms)`);
         } else {
-            this.logger.warn(`${request.method} ${request.url}: ${response.status}`);
+            this.logger.warn(`${request.method} ${request.url}: ${response.status} (${duration}ms)`);
         }
 
         if (response.status === HTTPErrorCode.TOO_MANY_REQUESTS) {

package/src/internal/apiService/errorCodes.ts

@@ -17,6 +17,7 @@ export const enum ErrorCode {
     OK = 1000,
     OK_MANY = 1001,
     OK_ASYNC = 1002,
+    INVALID_VALUE = 2001,
     NOT_ENOUGH_PERMISSIONS = 2011,
     NOT_ENOUGH_PERMISSIONS_TO_GRANT_PERMISSIONS = 2026,
     // Following codes takes name from the API documentation.

package/src/internal/apiService/errors.ts

@@ -46,6 +46,7 @@ export function apiErrorFactory({ response, result }: { response: Response; resu
         // Here we convert only general enough codes. Specific cases that are
         // not clear from the code itself must be handled by each module
         // separately.
+        case ErrorCode.INVALID_VALUE:
         case ErrorCode.NOT_ENOUGH_PERMISSIONS:
         case ErrorCode.NOT_ENOUGH_PERMISSIONS_TO_GRANT_PERMISSIONS:
         case ErrorCode.ALREADY_EXISTS:

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

@@ -173,6 +173,34 @@ describe('nodeAPIService', () => {
         api = new NodeAPIService(getMockLogger(), apiMock);
     });
 
+    describe('getNode', () => {
+        it('should get node', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Links: [generateAPIFolderNode()],
+                }),
+            );
+
+            const node = await api.getNode('volumeId~nodeId', 'volumeId');
+
+            expect(node).toStrictEqual(generateFolderNode());
+        });
+
+        it('should throw error if node is not found', async () => {
+            // @ts-expect-error Mocking for testing purposes
+            apiMock.post = jest.fn(async () =>
+                Promise.resolve({
+                    Links: [],
+                }),
+            );
+
+            const promise = api.getNode('volumeId~nodeId', 'volumeId');
+
+            await expect(promise).rejects.toThrow('Node not found');
+        });
+    });
+
     describe('iterateNodes', () => {
         async function testIterateNodes(mockedLink: any, expectedNode: any, ownVolumeId = 'volumeId') {
             // @ts-expect-error Mocking for testing purposes

package/src/internal/nodes/apiService.ts

@@ -110,6 +110,9 @@ export class NodeAPIService {
     async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
         const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, signal);
         const result = await nodesGenerator.next();
+        if (!result.value) {
+            throw new ValidationError(c('Error').t`Node not found`);
+        }
         await nodesGenerator.return('finish');
         return result.value;
     }

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

@@ -118,6 +118,34 @@ describe('nodesCache', () => {
             storageSize: 100,
             contentAuthor: resultOk('test@test.com'),
             claimedModificationTime: new Date('2021-02-01'),
+            claimedSize: 100,
+            claimedDigests: {
+                sha1: 'hash',
+            },
+            claimedBlockSizes: [100],
+            claimedAdditionalMetadata: {
+                media: { width: 100, height: 100 },
+            },
+        });
+        const node = generateNode('node1', '', { activeRevision });
+
+        await cache.setNode(node);
+        const result = await cache.getNode(node.uid);
+
+        expect(result).toStrictEqual({
+            ...node,
+            activeRevision,
+        });
+    });
+
+    it('should store and retrieve node with active revision with no claimed data', async () => {
+        const activeRevision: Result<DecryptedRevision, Error> = resultOk({
+            uid: 'revision1',
+            state: RevisionState.Active,
+            creationTime: new Date('2021-01-01'),
+            storageSize: 100,
+            contentAuthor: resultOk('test@test.com'),
+            claimedModificationTime: undefined,
         });
         const node = generateNode('node1', '', { activeRevision });
 

package/src/internal/nodes/cache.ts

@@ -302,7 +302,9 @@ function deserialiseRevision(revision: any): Result<DecryptedRevision, Error> {
         return resultOk({
             ...revision.value,
             creationTime: new Date(revision.value.creationTime),
-            claimedModificationTime: new Date(revision.value.claimedModificationTime),
+            claimedModificationTime: revision.value.claimedModificationTime
+                ? new Date(revision.value.claimedModificationTime)
+                : undefined,
         });
     }
 

package/src/internal/nodes/cryptoService.ts

@@ -61,6 +61,8 @@ export class NodesCryptoService {
         node: EncryptedNode,
         parentKey: PrivateKey,
     ): Promise<{ node: DecryptedUnparsedNode; keys?: DecryptedNodeKeys }> {
+        const start = Date.now();
+
         const commonNodeMetadata = {
             ...node,
             encryptedCrypto: undefined,
@@ -89,16 +91,17 @@ export class NodesCryptoService {
                 : nodeParentKeys;
         }
 
-        const { name, author: nameAuthor } = await this.decryptName(node, parentKey, nameVerificationKeys);
-
-        let membership;
-        if (node.membership) {
-            membership = await this.decryptMembership(node);
-        }
+        // Start promises early, but await them only when required to do
+        // as much work as possible in parallel.
+        const [membershipPromise, namePromise, keyPromise] = [
+            node.membership ? this.decryptMembership(node) : undefined,
+            this.decryptName(node, parentKey, nameVerificationKeys),
+            this.decryptKey(node, parentKey, keyVerificationKeys),
+        ];
 
         let passphrase, key, passphraseSessionKey, keyAuthor;
         try {
-            const keyResult = await this.decryptKey(node, parentKey, keyVerificationKeys);
+            const keyResult = await keyPromise;
             passphrase = keyResult.passphrase;
             key = keyResult.key;
             passphraseSessionKey = keyResult.passphraseSessionKey;
@@ -107,12 +110,17 @@ export class NodesCryptoService {
             void this.reportDecryptionError(node, 'nodeKey', error);
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt node key: ${message}`;
+            const { name, author: nameAuthor } = await namePromise;
+            const membership = await membershipPromise;
             return {
                 node: {
                     ...commonNodeMetadata,
                     name,
                     keyAuthor: resultError({
-                        claimedAuthor: node.encryptedCrypto.signatureEmail,
+                        claimedAuthor: getClaimedAuthor(
+                            node.encryptedCrypto.signatureEmail,
+                            keyVerificationKeys.length === 0,
+                        ),
                         error: errorMessage,
                     }),
                     nameAuthor,
@@ -131,8 +139,23 @@ export class NodesCryptoService {
         let folder;
         let folderExtendedAttributesAuthor;
         if ('folder' in node.encryptedCrypto) {
+            const folderExtendedAttributesVerificationKeys = node.encryptedCrypto.signatureEmail
+                ? signatureEmailKeys
+                : [key];
+
+            const [hashKeyPromise, folderExtendedAttributesPromise] = [
+                this.decryptHashKey(node, key, signatureEmailKeys),
+                this.decryptExtendedAttributes(
+                    node,
+                    node.encryptedCrypto.folder.armoredExtendedAttributes,
+                    key,
+                    folderExtendedAttributesVerificationKeys,
+                    node.encryptedCrypto.signatureEmail,
+                ),
+            ];
+
             try {
-                const hashKeyResult = await this.decryptHashKey(node, key, signatureEmailKeys);
+                const hashKeyResult = await hashKeyPromise;
                 hashKey = hashKeyResult.hashKey;
                 hashKeyAuthor = hashKeyResult.author;
             } catch (error: unknown) {
@@ -141,16 +164,7 @@ export class NodesCryptoService {
             }
 
             try {
-                const folderExtendedAttributesVerificationKeys = node.encryptedCrypto.signatureEmail
-                    ? signatureEmailKeys
-                    : [key];
-                const extendedAttributesResult = await this.decryptExtendedAttributes(
-                    node,
-                    node.encryptedCrypto.folder.armoredExtendedAttributes,
-                    key,
-                    folderExtendedAttributesVerificationKeys,
-                    node.encryptedCrypto.signatureEmail,
-                );
+                const extendedAttributesResult = await folderExtendedAttributesPromise;
                 folder = {
                     extendedAttributes: extendedAttributesResult.extendedAttributes,
                 };
@@ -165,10 +179,20 @@ export class NodesCryptoService {
         let contentKeyPacketSessionKey;
         let contentKeyPacketAuthor;
         if ('file' in node.encryptedCrypto) {
+            const [activeRevisionPromise, contentKeyPacketSessionKeyPromise] = [
+                this.decryptRevision(node.uid, node.encryptedCrypto.activeRevision, key),
+                this.driveCrypto.decryptAndVerifySessionKey(
+                    node.encryptedCrypto.file.base64ContentKeyPacket,
+                    node.encryptedCrypto.file.armoredContentKeyPacketSignature,
+                    key,
+                    // Content key packet is signed with the node key, but
+                    // in the past some clients signed with the address key.
+                    [key, ...keyVerificationKeys],
+                ),
+            ];
+
             try {
-                activeRevision = resultOk(
-                    await this.decryptRevision(node.uid, node.encryptedCrypto.activeRevision, key),
-                );
+                activeRevision = resultOk(await activeRevisionPromise);
             } catch (error: unknown) {
                 void this.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 const message = getErrorMessage(error);
@@ -177,18 +201,10 @@ export class NodesCryptoService {
             }
 
             try {
-                const keySessionKeyResult = await this.driveCrypto.decryptAndVerifySessionKey(
-                    node.encryptedCrypto.file.base64ContentKeyPacket,
-                    node.encryptedCrypto.file.armoredContentKeyPacketSignature,
-                    key,
-                    // Content key packet is signed with the node key, but
-                    // in the past some clients signed with the address key.
-                    [key, ...keyVerificationKeys],
-                );
-
+                const keySessionKeyResult = await contentKeyPacketSessionKeyPromise;
                 contentKeyPacketSessionKey = keySessionKeyResult.sessionKey;
                 contentKeyPacketAuthor =
-                    keySessionKeyResult.verified &&
+                    keySessionKeyResult.verified !== undefined &&
                     (await this.handleClaimedAuthor(
                         node,
                         'nodeContentKey',
@@ -230,6 +246,13 @@ export class NodesCryptoService {
             finalKeyAuthor = keyAuthor;
         }
 
+        const { name, author: nameAuthor } = await namePromise;
+        const membership = await membershipPromise;
+
+        const end = Date.now();
+        const duration = end - start;
+        this.logger.debug(`Node ${node.uid} decrypted in ${duration}ms`);
+
         return {
             node: {
                 ...commonNodeMetadata,
@@ -319,7 +342,7 @@ export class NodesCryptoService {
             return {
                 name: resultError(new Error(errorMessage)),
                 author: resultError({
-                    claimedAuthor: nameSignatureEmail,
+                    claimedAuthor: getClaimedAuthor(nameSignatureEmail, verificationKeys.length === 0),
                     error: errorMessage,
                 }),
             };
@@ -635,6 +658,7 @@ export class NodesCryptoService {
         if (this.reportedVerificationErrors.has(node.uid)) {
             return;
         }
+        this.reportedVerificationErrors.add(node.uid);
 
         const fromBefore2024 = node.creationTime < new Date('2024-01-01');
 
@@ -661,7 +685,6 @@ export class NodesCryptoService {
             error: verificationErrors?.map((e) => e.message).join(', '),
             uid: node.uid,
         });
-        this.reportedVerificationErrors.add(node.uid);
     }
 
     private async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
@@ -716,3 +739,14 @@ function handleClaimedAuthor(
         error: getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
     });
 }
+
+function getClaimedAuthor(
+    claimedAuthor?: string,
+    notAvailableVerificationKeys = false,
+): string | AnonymousUser | undefined {
+    if (!claimedAuthor && notAvailableVerificationKeys) {
+        return null as AnonymousUser;
+    }
+
+    return claimedAuthor;
+}

package/src/internal/nodes/nodesAccess.ts

@@ -24,7 +24,7 @@ const BATCH_LOADING_SIZE = 30;
 // It is a trade-off between performance and memory usage.
 // Higher number means more memory usage, but faster decryption.
 // Lower number means less memory usage, but slower decryption.
-const DECRYPTION_CONCURRENCY = 15;
+const DECRYPTION_CONCURRENCY = 30;
 
 /**
  * Provides access to node metadata.
@@ -234,7 +234,7 @@ export class NodesAccess {
 
         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 });
+            throw new DecryptionError(c('Error').t`Failed to decrypt some nodes`, { cause: errors });
         }
 
         const missingNodeUids = nodeUids.filter((nodeUid) => !returnedNodeUids.includes(nodeUid));

package/src/internal/nodes/nodesManagement.ts

@@ -189,11 +189,8 @@ export class NodesManagement {
     }
 
     async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const deletedNodeUids = [];
-
         for await (const result of this.apiService.deleteNodes(nodeUids, signal)) {
             if (result.ok) {
-                deletedNodeUids.push(result.uid);
                 await this.nodesAccess.notifyNodeDeleted(result.uid);
             }
             yield result;