@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/internal/nodes/apiService.ts

@@ -1,57 +1,108 @@
-import { c } from "ttag";
-
-import { ProtonDriveError, ValidationError } from "../../errors";
-import { Logger, NodeResult } from "../../interface";
-import { MemberRole, RevisionState } from "../../interface/nodes";
-import { DriveAPIService, drivePaths, isCodeOk, nodeTypeNumberToNodeType, permissionsToDirectMemberRole } from "../apiService";
-import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from "../uids";
-import { EncryptedNode, EncryptedRevision, Thumbnail } from "./interface";
-
-type PostLoadLinksMetadataRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostLoadLinksMetadataResponse = drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
-
-type GetChildrenResponse = drivePaths['/drive/v2/volumes/{volumeID}/folders/{linkID}/children']['get']['responses']['200']['content']['application/json'];
-
-type GetTrashedNodesResponse = drivePaths['/drive/volumes/{volumeID}/trash']['get']['responses']['200']['content']['application/json'];
-
-type PutRenameNodeRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/rename']['put']['requestBody'], { 'content': object }>['content']['application/json'];
-type PutRenameNodeResponse = drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/rename']['put']['responses']['200']['content']['application/json'];
-
-type PutMoveNodeRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['requestBody'], { 'content': object }>['content']['application/json'];
-type PutMoveNodeResponse = drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['responses']['200']['content']['application/json'];
-
-type PostTrashNodesRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostTrashNodesResponse = drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['responses']['200']['content']['application/json'];
-
-type PutRestoreNodesRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/trash/restore_multiple']['put']['requestBody'], { 'content': object }>['content']['application/json'];
-type PutRestoreNodesResponse = drivePaths['/drive/v2/volumes/{volumeID}/trash/restore_multiple']['put']['responses']['200']['content']['application/json'];
-
-type PostDeleteNodesRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/trash/delete_multiple']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostDeleteNodesResponse = drivePaths['/drive/v2/volumes/{volumeID}/trash/delete_multiple']['post']['responses']['200']['content']['application/json'];
-
-type PostCreateFolderRequest = Extract<drivePaths['/drive/v2/volumes/{volumeID}/folders']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCreateFolderResponse = drivePaths['/drive/v2/volumes/{volumeID}/folders']['post']['responses']['200']['content']['application/json'];
-
-type GetRevisionResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['get']['responses']['200']['content']['application/json'];
-type GetRevisionsResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions']['get']['responses']['200']['content']['application/json'];
+import { c } from 'ttag';
+
+import { ProtonDriveError, ValidationError } from '../../errors';
+import { Logger, NodeResult } from '../../interface';
+import { MemberRole, RevisionState } from '../../interface/nodes';
+import {
+    DriveAPIService,
+    drivePaths,
+    isCodeOk,
+    nodeTypeNumberToNodeType,
+    permissionsToDirectMemberRole,
+} from '../apiService';
+import { asyncIteratorRace } from '../asyncIteratorRace';
+import { batch } from '../batch';
+import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from '../uids';
+import { EncryptedNode, EncryptedRevision, Thumbnail } from './interface';
+
+// This is the number of calls to the API that are made in parallel.
+const API_CONCURRENCY = 15;
+
+// This is the number of nodes that are loaded from the API in one call.
+const API_NODES_BATCH_SIZE = 100;
+
+type PostLoadLinksMetadataRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostLoadLinksMetadataResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
+
+type GetChildrenResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/folders/{linkID}/children']['get']['responses']['200']['content']['application/json'];
+
+type GetTrashedNodesResponse =
+    drivePaths['/drive/volumes/{volumeID}/trash']['get']['responses']['200']['content']['application/json'];
+
+type PutRenameNodeRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/rename']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PutRenameNodeResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/rename']['put']['responses']['200']['content']['application/json'];
+
+type PutMoveNodeRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PutMoveNodeResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['responses']['200']['content']['application/json'];
+
+type PostTrashNodesRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostTrashNodesResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['responses']['200']['content']['application/json'];
+
+type PutRestoreNodesRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/trash/restore_multiple']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PutRestoreNodesResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/trash/restore_multiple']['put']['responses']['200']['content']['application/json'];
+
+type PostDeleteNodesRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/trash/delete_multiple']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostDeleteNodesResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/trash/delete_multiple']['post']['responses']['200']['content']['application/json'];
+
+type PostCreateFolderRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/folders']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateFolderResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/folders']['post']['responses']['200']['content']['application/json'];
+
+type GetRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['get']['responses']['200']['content']['application/json'];
+type GetRevisionsResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions']['get']['responses']['200']['content']['application/json'];
 enum APIRevisionState {
     Draft = 0,
     Active = 1,
     Obsolete = 2,
 }
 
-type PostRestoreRevisionResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}/restore']['post']['responses']['202']['content']['application/json'];
+type PostRestoreRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}/restore']['post']['responses']['202']['content']['application/json'];
 
-type DeleteRevisionResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['delete']['responses']['200']['content']['application/json'];
+type DeleteRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['delete']['responses']['200']['content']['application/json'];
 
 /**
  * Provides API communication for fetching and manipulating nodes metadata.
- * 
+ *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
 export class NodeAPIService {
-    constructor(private logger: Logger, private apiService: DriveAPIService) {
+    constructor(
+        private logger: Logger,
+        private apiService: DriveAPIService,
+    ) {
         this.logger = logger;
         this.apiService = apiService;
     }
@@ -59,12 +110,11 @@ 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();
-        await nodesGenerator.return("finish");
+        await nodesGenerator.return('finish');
         return result.value;
     }
 
-    // Improvement requested: split into multiple calls for many nodes.
-    async* iterateNodes(nodeUids: string[], ownVolumeId: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
+    async *iterateNodes(nodeUids: string[], ownVolumeId: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
         const allNodeIds = nodeUids.map(splitNodeUid);
 
         const nodeIdsByVolumeId = new Map<string, string[]>();
@@ -78,18 +128,50 @@ export class NodeAPIService {
         // If the API returns node that is not recognised, it is returned as
         // an error, but first all nodes that are recognised are yielded.
         // Thus we capture all errors and throw them at the end of iteration.
-        const errors = [];
+        const errors: unknown[] = [];
+
+        const iterateNodesPerVolume = this.iterateNodesPerVolume.bind(this);
+        const iterateNodesPerVolumeGenerator = async function* () {
+            for (const [volumeId, nodeIds] of nodeIdsByVolumeId.entries()) {
+                const isAdmin = volumeId === ownVolumeId;
+
+                yield (async function* () {
+                    const errorsPerVolume = yield* iterateNodesPerVolume(volumeId, nodeIds, isAdmin, signal);
+                    if (errorsPerVolume.length) {
+                        errors.push(...errorsPerVolume);
+                    }
+                })();
+            }
+        };
+
+        yield* asyncIteratorRace(iterateNodesPerVolumeGenerator(), API_CONCURRENCY);
 
-        for (const [volumeId, nodeIds] of nodeIdsByVolumeId.entries()) {
-            const isAdmin = volumeId === ownVolumeId;
+        if (errors.length) {
+            this.logger.warn(`Failed to load ${errors.length} nodes`);
+            throw new ProtonDriveError(c('Error').t`Failed to load some nodes`, { cause: errors });
+        }
+    }
 
-            const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(`drive/v2/volumes/${volumeId}/links`, {
-                LinkIDs: nodeIds,
-            }, signal);
+    private async *iterateNodesPerVolume(
+        volumeId: string,
+        nodeIds: string[],
+        isOwnVolumeId: boolean,
+        signal?: AbortSignal,
+    ): AsyncGenerator<EncryptedNode, unknown[]> {
+        const errors: unknown[] = [];
+
+        for (const nodeIdsBatch of batch(nodeIds, API_NODES_BATCH_SIZE)) {
+            const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(
+                `drive/v2/volumes/${volumeId}/links`,
+                {
+                    LinkIDs: nodeIdsBatch,
+                },
+                signal,
+            );
 
             for (const link of response.Links) {
                 try {
-                    yield linkToEncryptedNode(this.logger, volumeId, link, isAdmin);
+                    yield linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
                 } catch (error: unknown) {
                     this.logger.error(`Failed to transform node ${link.Link.LinkID}`, error);
                     errors.push(error);
@@ -97,24 +179,23 @@ export class NodeAPIService {
             }
         }
 
-
-        if (errors.length) {
-            this.logger.warn(`Failed to load ${errors.length} nodes`);
-            throw new ProtonDriveError(c('Error').t`Failed to load some nodes`, { cause: errors });
-        }
+        return errors;
     }
 
     // Improvement requested: load next page sooner before all IDs are yielded.
     async *iterateChildrenNodeUids(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<string> {
         const { volumeId, nodeId } = splitNodeUid(parentNodeUid);
 
-        let anchor = "";
+        let anchor = '';
         while (true) {
-            const response = await this.apiService.get<GetChildrenResponse>(`drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${anchor ? `AnchorID=${anchor}` : ''}`, signal);
+            const response = await this.apiService.get<GetChildrenResponse>(
+                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${anchor ? `AnchorID=${anchor}` : ''}`,
+                signal,
+            );
             for (const linkID of response.LinkIDs) {
                 yield makeNodeUid(volumeId, linkID);
             }
-    
+
             if (!response.More || !response.AnchorID) {
                 break;
             }
@@ -126,8 +207,11 @@ export class NodeAPIService {
     async *iterateTrashedNodeUids(volumeId: string, signal?: AbortSignal): AsyncGenerator<string> {
         let page = 0;
         while (true) {
-            const response = await this.apiService.get<GetTrashedNodesResponse>(`drive/volumes/${volumeId}/trash?Page=${page}`, signal);
-            
+            const response = await this.apiService.get<GetTrashedNodesResponse>(
+                `drive/volumes/${volumeId}/trash?Page=${page}`,
+                signal,
+            );
+
             // The API returns items per shares which is not straightforward to
             // count if there is another page. We had mistakes in the past, thus
             // we rather end when the page is fully empty.
@@ -142,7 +226,7 @@ export class NodeAPIService {
                     hasItems = true;
                 }
             }
-    
+
             if (!hasItems) {
                 break;
             }
@@ -153,110 +237,115 @@ export class NodeAPIService {
     async renameNode(
         nodeUid: string,
         originalNode: {
-            hash?: string,
+            hash?: string;
         },
         newNode: {
-            encryptedName: string,
-            nameSignatureEmail: string,
-            hash?: string,
+            encryptedName: string;
+            nameSignatureEmail: string;
+            hash?: string;
         },
         signal?: AbortSignal,
     ): Promise<void> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
 
-        await this.apiService.put<
-            Omit<PutRenameNodeRequest, "SignatureAddress" | "MIMEType">,
-            PutRenameNodeResponse
-        >(`drive/v2/volumes/${volumeId}/links/${nodeId}/rename`, {
-            Name: newNode.encryptedName,
-            NameSignatureEmail: newNode.nameSignatureEmail,
-            Hash: newNode.hash,
-            OriginalHash: originalNode.hash || null,
-        }, signal);
+        await this.apiService.put<Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>, PutRenameNodeResponse>(
+            `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
+            {
+                Name: newNode.encryptedName,
+                NameSignatureEmail: newNode.nameSignatureEmail,
+                Hash: newNode.hash,
+                OriginalHash: originalNode.hash || null,
+            },
+            signal,
+        );
     }
 
     async moveNode(
         nodeUid: string,
         oldNode: {
-            hash: string,
+            hash: string;
         },
         newNode: {
-            parentUid: string,
-            armoredNodePassphrase: string,
-            armoredNodePassphraseSignature?: string,
-            signatureEmail?: string,
-            encryptedName: string,
-            nameSignatureEmail?: string,
-            hash: string,
-            contentHash?: string,
+            parentUid: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature?: string;
+            signatureEmail?: string;
+            encryptedName: string;
+            nameSignatureEmail?: string;
+            hash: string;
+            contentHash?: string;
         },
         signal?: AbortSignal,
     ): Promise<void> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
         const { nodeId: newParentNodeId } = splitNodeUid(newNode.parentUid);
 
-        await this.apiService.put<
-            Omit<PutMoveNodeRequest, "SignatureAddress" | "MIMEType">,
-            PutMoveNodeResponse
-        >(`drive/v2/volumes/${volumeId}/links/${nodeId}/move`, {
-            ParentLinkID: newParentNodeId,
-            NodePassphrase: newNode.armoredNodePassphrase,
-            // @ts-expect-error: API accepts NodePassphraseSignature as optional.
-            NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
-            // @ts-expect-error: API accepts SignatureEmail as optional.
-            SignatureEmail: newNode.signatureEmail,
-            Name: newNode.encryptedName,
-            // @ts-expect-error: API accepts NameSignatureEmail as optional.
-            NameSignatureEmail: newNode.nameSignatureEmail,
-            Hash: newNode.hash,
-            OriginalHash: oldNode.hash,
-            ContentHash: newNode.contentHash || null,
-        }, signal);
+        await this.apiService.put<Omit<PutMoveNodeRequest, 'SignatureAddress' | 'MIMEType'>, PutMoveNodeResponse>(
+            `drive/v2/volumes/${volumeId}/links/${nodeId}/move`,
+            {
+                ParentLinkID: newParentNodeId,
+                NodePassphrase: newNode.armoredNodePassphrase,
+                // @ts-expect-error: API accepts NodePassphraseSignature as optional.
+                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                // @ts-expect-error: API accepts SignatureEmail as optional.
+                SignatureEmail: newNode.signatureEmail,
+                Name: newNode.encryptedName,
+                // @ts-expect-error: API accepts NameSignatureEmail as optional.
+                NameSignatureEmail: newNode.nameSignatureEmail,
+                Hash: newNode.hash,
+                OriginalHash: oldNode.hash,
+                ContentHash: newNode.contentHash || null,
+            },
+            signal,
+        );
     }
 
     // Improvement requested: split into multiple calls for many nodes.
-    async* trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         const nodeIds = nodeUids.map(splitNodeUid);
         const volumeId = assertAndGetSingleVolumeId(c('Operation').t`Trashing items`, nodeIds);
 
-        const response = await this.apiService.post<
-            PostTrashNodesRequest,
-            PostTrashNodesResponse
-        >(`drive/v2/volumes/${volumeId}/trash_multiple`, {
-            LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
-        }, signal);
+        const response = await this.apiService.post<PostTrashNodesRequest, PostTrashNodesResponse>(
+            `drive/v2/volumes/${volumeId}/trash_multiple`,
+            {
+                LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
+            },
+            signal,
+        );
 
         // TODO: remove `as` when backend fixes OpenAPI schema.
         yield* handleResponseErrors(nodeUids, volumeId, response.Responses as LinkResponse[]);
     }
 
     // Improvement requested: split into multiple calls for many nodes.
-    async* restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         const nodeIds = nodeUids.map(splitNodeUid);
         const volumeId = assertAndGetSingleVolumeId(c('Operation').t`Restoring items`, nodeIds);
 
-        const response = await this.apiService.put<
-            PutRestoreNodesRequest,
-            PutRestoreNodesResponse
-        >(`drive/v2/volumes/${volumeId}/trash/restore_multiple`, {
-            LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
-        }, signal);
+        const response = await this.apiService.put<PutRestoreNodesRequest, PutRestoreNodesResponse>(
+            `drive/v2/volumes/${volumeId}/trash/restore_multiple`,
+            {
+                LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
+            },
+            signal,
+        );
 
         // TODO: remove `as` when backend fixes OpenAPI schema.
         yield* handleResponseErrors(nodeUids, volumeId, response.Responses as LinkResponse[]);
     }
 
     // Improvement requested: split into multiple calls for many nodes.
-    async* deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         const nodeIds = nodeUids.map(splitNodeUid);
         const volumeId = assertAndGetSingleVolumeId(c('Operation').t`Deleting items`, nodeIds);
 
-        const response = await this.apiService.post<
-            PostDeleteNodesRequest,
-            PostDeleteNodesResponse
-        >(`drive/v2/volumes/${volumeId}/trash/delete_multiple`, {
-            LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
-        }, signal);
+        const response = await this.apiService.post<PostDeleteNodesRequest, PostDeleteNodesResponse>(
+            `drive/v2/volumes/${volumeId}/trash/delete_multiple`,
+            {
+                LinkIDs: nodeIds.map(({ nodeId }) => nodeId),
+            },
+            signal,
+        );
 
         // TODO: remove `as` when backend fixes OpenAPI schema.
         yield* handleResponseErrors(nodeUids, volumeId, response.Responses as LinkResponse[]);
@@ -265,33 +354,33 @@ export class NodeAPIService {
     async createFolder(
         parentUid: string,
         newNode: {
-            armoredKey: string,
-            armoredHashKey: string,
-            armoredNodePassphrase: string,
-            armoredNodePassphraseSignature: string,
-            signatureEmail: string,
-            encryptedName: string,
-            hash: string,
-            armoredExtendedAttributes?: string,
+            armoredKey: string;
+            armoredHashKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            signatureEmail: string;
+            encryptedName: string;
+            hash: string;
+            armoredExtendedAttributes?: string;
         },
     ): Promise<string> {
         const { volumeId, nodeId: parentId } = splitNodeUid(parentUid);
 
-        const response = await this.apiService.post<
-            PostCreateFolderRequest,
-            PostCreateFolderResponse
-        >(`drive/v2/volumes/${volumeId}/folders`, {
-            ParentLinkID: parentId,
-            NodeKey: newNode.armoredKey,
-            NodeHashKey: newNode.armoredHashKey,
-            NodePassphrase: newNode.armoredNodePassphrase,
-            NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
-            SignatureEmail: newNode.signatureEmail,
-            Name: newNode.encryptedName,
-            Hash: newNode.hash,
-            // @ts-expect-error: XAttr is optional as undefined.
-            XAttr: newNode.armoredExtendedAttributes,
-        });
+        const response = await this.apiService.post<PostCreateFolderRequest, PostCreateFolderResponse>(
+            `drive/v2/volumes/${volumeId}/folders`,
+            {
+                ParentLinkID: parentId,
+                NodeKey: newNode.armoredKey,
+                NodeHashKey: newNode.armoredHashKey,
+                NodePassphrase: newNode.armoredNodePassphrase,
+                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                SignatureEmail: newNode.signatureEmail,
+                Name: newNode.encryptedName,
+                Hash: newNode.hash,
+                // @ts-expect-error: XAttr is optional as undefined.
+                XAttr: newNode.armoredExtendedAttributes,
+            },
+        );
 
         return makeNodeUid(volumeId, response.Folder.ID);
     }
@@ -299,32 +388,39 @@ export class NodeAPIService {
     async getRevision(nodeRevisionUid: string, signal?: AbortSignal): Promise<EncryptedRevision> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
 
-        const response = await this.apiService.get<GetRevisionResponse>(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}?NoBlockUrls=true`, signal);
+        const response = await this.apiService.get<GetRevisionResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}?NoBlockUrls=true`,
+            signal,
+        );
         return transformRevisionResponse(volumeId, nodeId, response.Revision);
     }
 
     async getRevisions(nodeUid: string, signal?: AbortSignal): Promise<EncryptedRevision[]> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
 
-        const response = await this.apiService.get<GetRevisionsResponse>(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions`, signal);
-        return response.Revisions
-            .filter((revision) => revision.State === APIRevisionState.Active || revision.State === APIRevisionState.Obsolete)
-            .map((revision) => transformRevisionResponse(volumeId, nodeId, revision));
+        const response = await this.apiService.get<GetRevisionsResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions`,
+            signal,
+        );
+        return response.Revisions.filter(
+            (revision) => revision.State === APIRevisionState.Active || revision.State === APIRevisionState.Obsolete,
+        ).map((revision) => transformRevisionResponse(volumeId, nodeId, revision));
     }
 
     async restoreRevision(nodeRevisionUid: string): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
 
-        await this.apiService.post<
-            undefined,
-            PostRestoreRevisionResponse
-        >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}/restore`);
+        await this.apiService.post<undefined, PostRestoreRevisionResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}/restore`,
+        );
     }
 
     async deleteRevision(nodeRevisionUid: string): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
 
-        await this.apiService.delete<DeleteRevisionResponse>(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`);
+        await this.apiService.delete<DeleteRevisionResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`,
+        );
     }
 }
 
@@ -338,14 +434,18 @@ function assertAndGetSingleVolumeId(operationForErrorMessage: string, nodeIds: {
 }
 
 type LinkResponse = {
-    LinkID: string,
+    LinkID: string;
     Response: {
-        Code?: number,
-        Error?: string,
-    }
+        Code?: number;
+        Error?: string;
+    };
 };
 
-function* handleResponseErrors(nodeUids: string[], volumeId: string, responses: LinkResponse[] = []): Generator<NodeResult> {
+function* handleResponseErrors(
+    nodeUids: string[],
+    volumeId: string,
+    responses: LinkResponse[] = [],
+): Generator<NodeResult> {
     const errors = new Map();
 
     responses.forEach((response) => {
@@ -365,7 +465,12 @@ function* handleResponseErrors(nodeUids: string[], volumeId: string, responses:
     }
 }
 
-function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLinksMetadataResponse['Links'][0], isAdmin: boolean): EncryptedNode {
+function linkToEncryptedNode(
+    logger: Logger,
+    volumeId: string,
+    link: PostLoadLinksMetadataResponse['Links'][0],
+    isAdmin: boolean,
+): EncryptedNode {
     const baseNodeMetadata = {
         // Internal metadata
         hash: link.Link.NameHash || undefined,
@@ -375,21 +480,23 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
         uid: makeNodeUid(volumeId, link.Link.LinkID),
         parentUid: link.Link.ParentLinkID ? makeNodeUid(volumeId, link.Link.ParentLinkID) : undefined,
         type: nodeTypeNumberToNodeType(logger, link.Link.Type),
-        creationTime: new Date(link.Link.CreateTime*1000),
-        trashTime: link.Link.TrashTime ? new Date(link.Link.TrashTime*1000) : undefined,
+        creationTime: new Date(link.Link.CreateTime * 1000),
+        trashTime: link.Link.TrashTime ? new Date(link.Link.TrashTime * 1000) : undefined,
 
         // Sharing node metadata
         shareId: link.Sharing?.ShareID || undefined,
         isShared: !!link.Sharing,
-        directMemberRole: isAdmin ? MemberRole.Admin : permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
-    }
+        directMemberRole: isAdmin
+            ? MemberRole.Admin
+            : permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
+    };
     const baseCryptoNodeMetadata = {
         signatureEmail: link.Link.SignatureEmail || undefined,
         nameSignatureEmail: link.Link.NameSignatureEmail || undefined,
         armoredKey: link.Link.NodeKey,
         armoredNodePassphrase: link.Link.NodePassphrase,
         armoredNodePassphraseSignature: link.Link.NodePassphraseSignature,
-    }
+    };
 
     if (link.Link.Type === 1 && link.Folder) {
         return {
@@ -401,7 +508,7 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
                     armoredHashKey: link.Folder.NodeHashKey as string,
                 },
             },
-        }
+        };
     }
 
     if (link.Link.Type === 2 && link.File && link.File.ActiveRevision) {
@@ -418,14 +525,17 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
                 activeRevision: {
                     uid: makeNodeRevisionUid(volumeId, link.Link.LinkID, link.File.ActiveRevision.RevisionID),
                     state: RevisionState.Active,
-                    creationTime: new Date(link.File.ActiveRevision.CreateTime*1000),
+                    creationTime: new Date(link.File.ActiveRevision.CreateTime * 1000),
                     storageSize: link.File.ActiveRevision.EncryptedSize,
                     signatureEmail: link.File.ActiveRevision.SignatureEmail || undefined,
                     armoredExtendedAttributes: link.File.ActiveRevision.XAttr || undefined,
-                    thumbnails: link.File.ActiveRevision.Thumbnails?.map((thumbnail) => transformThumbnail(volumeId, link.Link.LinkID, thumbnail)) || [],
+                    thumbnails:
+                        link.File.ActiveRevision.Thumbnails?.map((thumbnail) =>
+                            transformThumbnail(volumeId, link.Link.LinkID, thumbnail),
+                        ) || [],
                 },
             },
-        }
+        };
     }
 
     if (link.Link.Type === 3) {
@@ -434,7 +544,7 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
             encryptedCrypto: {
                 ...baseCryptoNodeMetadata,
             },
-        }
+        };
     }
 
     throw new Error(`Unknown node type: ${link.Link.Type}`);
@@ -449,19 +559,23 @@ function transformRevisionResponse(
         uid: makeNodeRevisionUid(volumeId, nodeId, revision.ID),
         state: revision.State === APIRevisionState.Active ? RevisionState.Active : RevisionState.Superseded,
         // @ts-expect-error: API doc is wrong, CreateTime is not optional.
-        creationTime: new Date(revision.CreateTime*1000),
+        creationTime: new Date(revision.CreateTime * 1000),
         storageSize: revision.Size,
         signatureEmail: revision.SignatureEmail || undefined,
         armoredExtendedAttributes: revision.XAttr || undefined,
         thumbnails: revision.Thumbnails?.map((thumbnail) => transformThumbnail(volumeId, nodeId, thumbnail)) || [],
-    }
+    };
 }
 
-function transformThumbnail(volumeId: string, nodeId: string, thumbnail: { ThumbnailID: string | null, Type: 1 | 2 | 3}): Thumbnail {
+function transformThumbnail(
+    volumeId: string,
+    nodeId: string,
+    thumbnail: { ThumbnailID: string | null; Type: 1 | 2 | 3 },
+): Thumbnail {
     return {
         // TODO: Legacy thumbnails didn't have ID but we don't have them anymore. Remove typing once API doc is updated.
         uid: makeNodeThumbnailUid(volumeId, nodeId, thumbnail.ThumbnailID as string),
         // TODO: We don't support any other thumbnail type yet.
         type: thumbnail.Type as 1 | 2,
-    }
+    };
 }