@protontech/drive-sdk 0.7.0 → 0.7.2

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

@@ -26,6 +26,7 @@ function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<
         isShared: false,
         isSharedPublicly: false,
         creationTime: new Date(),
+        modificationTime: new Date(),
         trashTime: undefined,
         isStale: false,
         ...params,

package/src/internal/nodes/interface.ts

@@ -33,6 +33,7 @@ interface BaseNode {
     type: NodeType;
     mediaType?: string;
     creationTime: Date; // created on the server
+    modificationTime: Date; // modified on server
     trashTime?: Date;
     totalStorageSize?: number;
 

package/src/internal/nodes/nodesAccess.ts

@@ -16,8 +16,8 @@ import { asyncIteratorMap } from '../asyncIteratorMap';
 import { getErrorMessage } from '../errors';
 import { BatchLoading } from '../batchLoading';
 import { makeNodeUid, splitNodeUid } from '../uids';
-import { NodeAPIService } from './apiService';
-import { NodesCache } from './cache';
+import { NodeAPIServiceBase } from './apiService';
+import { NodesCacheBase } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
 import { NodesDebouncer } from './debouncer';
@@ -50,17 +50,21 @@ const DECRYPTION_CONCURRENCY = 30;
  * The node access module is responsible for fetching, decrypting and caching
  * nodes metadata.
  */
-export class NodesAccess {
-    private logger: Logger;
-    private debouncer: NodesDebouncer;
+export abstract class NodesAccessBase<
+    TEncryptedNode extends EncryptedNode = EncryptedNode,
+    TDecryptedNode extends DecryptedNode = DecryptedNode,
+    TCryptoService extends NodesCryptoService = NodesCryptoService,
+> {
+    protected logger: Logger;
+    protected debouncer: NodesDebouncer;
 
     constructor(
-        private telemetry: ProtonDriveTelemetry,
-        private apiService: NodeAPIService,
-        private cache: NodesCache,
-        private cryptoCache: NodesCryptoCache,
-        private cryptoService: NodesCryptoService,
-        private shareService: Pick<
+        protected telemetry: ProtonDriveTelemetry,
+        protected apiService: NodeAPIServiceBase<TEncryptedNode>,
+        protected cache: NodesCacheBase<TDecryptedNode>,
+        protected cryptoCache: NodesCryptoCache,
+        protected cryptoService: TCryptoService,
+        protected shareService: Pick<
             SharesService,
             'getRootIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
         >,
@@ -80,7 +84,7 @@ export class NodesAccess {
         return this.getNode(nodeUid);
     }
 
-    async getNode(nodeUid: string): Promise<DecryptedNode> {
+    async getNode(nodeUid: string): Promise<TDecryptedNode> {
         let cachedNode;
         try {
             await this.debouncer.waitForLoadingNode(nodeUid);
@@ -101,11 +105,11 @@ export class NodesAccess {
         parentNodeUid: string,
         filterOptions?: FilterOptions,
         signal?: AbortSignal,
-    ): AsyncGenerator<DecryptedNode> {
+    ): AsyncGenerator<TDecryptedNode> {
         // Ensure the parent is loaded and up-to-date.
         const parentNode = await this.getNode(parentNodeUid);
 
-        const batchLoading = new BatchLoading<string, DecryptedNode>({
+        const batchLoading = new BatchLoading<string, TDecryptedNode>({
             iterateItems: (nodeUids) => this.loadNodes(nodeUids, filterOptions, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
@@ -154,9 +158,9 @@ export class NodesAccess {
     }
 
     // Improvement requested: keep status of loaded trash and leverage cache.
-    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<TDecryptedNode> {
         const { volumeId } = await this.shareService.getRootIDs();
-        const batchLoading = new BatchLoading<string, DecryptedNode>({
+        const batchLoading = new BatchLoading<string, TDecryptedNode>({
             iterateItems: (nodeUids) => this.loadNodes(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
@@ -177,8 +181,8 @@ export class NodesAccess {
         yield* batchLoading.loadRest();
     }
 
-    async *iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode> {
-        const batchLoading = new BatchLoading<string, DecryptedNode | MissingNode>({
+    async *iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<TDecryptedNode | MissingNode> {
+        const batchLoading = new BatchLoading<string, TDecryptedNode | MissingNode>({
             iterateItems: (nodeUids) => this.loadNodesWithMissingReport(nodeUids, undefined, signal),
             batchSize: BATCH_LOADING_SIZE,
         });
@@ -228,7 +232,7 @@ export class NodesAccess {
         await this.cache.removeNodes([nodeUid]);
     }
 
-    private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
+    private async loadNode(nodeUid: string): Promise<{ node: TDecryptedNode; keys?: DecryptedNodeKeys }> {
         this.debouncer.loadingNode(nodeUid);
         try {
             const { volumeId: ownVolumeId } = await this.shareService.getRootIDs();
@@ -243,7 +247,7 @@ export class NodesAccess {
         nodeUids: string[],
         filterOptions?: FilterOptions,
         signal?: AbortSignal,
-    ): AsyncGenerator<DecryptedNode> {
+    ): AsyncGenerator<TDecryptedNode> {
         for await (const result of this.loadNodesWithMissingReport(nodeUids, filterOptions, signal)) {
             if ('missingUid' in result) {
                 continue;
@@ -256,7 +260,7 @@ export class NodesAccess {
         nodeUids: string[],
         filterOptions?: FilterOptions,
         signal?: AbortSignal,
-    ): AsyncGenerator<DecryptedNode | MissingNode> {
+    ): AsyncGenerator<TDecryptedNode | MissingNode> {
         const returnedNodeUids: string[] = [];
         const errors = [];
 
@@ -264,13 +268,13 @@ export class NodesAccess {
 
         const apiNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
 
-        const debouncedNodeMapper = async (encryptedNode: EncryptedNode): Promise<EncryptedNode> => {
+        const debouncedNodeMapper = async (encryptedNode: TEncryptedNode): Promise<TEncryptedNode> => {
             this.debouncer.loadingNode(encryptedNode.uid);
             return encryptedNode;
         };
         const encryptedNodesIterator = asyncIteratorMap(apiNodesIterator, debouncedNodeMapper, 1);
 
-        const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
+        const decryptNodeMapper = async (encryptedNode: TEncryptedNode): Promise<Result<TDecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {
                 const { node } = await this.decryptNode(encryptedNode);
@@ -310,8 +314,8 @@ export class NodesAccess {
     }
 
     private async decryptNode(
-        encryptedNode: EncryptedNode,
-    ): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
+        encryptedNode: TEncryptedNode,
+    ): Promise<{ node: TDecryptedNode; keys?: DecryptedNodeKeys }> {
         let parentKey;
         try {
             const parentKeys = await this.getParentKeys(encryptedNode);
@@ -319,38 +323,14 @@ export class NodesAccess {
         } 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),
-                        }),
-                        membership: encryptedNode.membership
-                            ? {
-                                  role: encryptedNode.membership.role,
-                                  inviteTime: encryptedNode.membership.inviteTime,
-                                  sharedBy: resultError({
-                                      claimedAuthor: encryptedNode.encryptedCrypto.membership?.inviterEmail,
-                                      error: getErrorMessage(error),
-                                  }),
-                              }
-                            : undefined,
-                        errors: [error],
-                        treeEventScopeId: splitNodeUid(encryptedNode.uid).volumeId,
-                    },
+                    node: this.getDegradedUndecryptableNode(encryptedNode, error),
                 };
             }
             throw error;
         }
 
         const { node: unparsedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
-        const node = await parseNode(this.logger, unparsedNode);
+        const node = this.parseNode(unparsedNode);
         try {
             await this.cache.setNode(node);
         } catch (error: unknown) {
@@ -367,8 +347,45 @@ export class NodesAccess {
         return { node, keys };
     }
 
+    protected abstract getDegradedUndecryptableNode(
+        encryptedNode: TEncryptedNode,
+        error: DecryptionError,
+    ): TDecryptedNode;
+
+    protected getDegradedUndecryptableNodeBase(encryptedNode: EncryptedNode, error: DecryptionError): DecryptedNode {
+        return {
+            ...encryptedNode,
+            isStale: false,
+            name: resultError(error),
+            keyAuthor: resultError({
+                claimedAuthor: encryptedNode.encryptedCrypto.signatureEmail,
+                error: getErrorMessage(error),
+            }),
+            nameAuthor: resultError({
+                claimedAuthor: encryptedNode.encryptedCrypto.nameSignatureEmail,
+                error: getErrorMessage(error),
+            }),
+            membership: encryptedNode.membership
+                ? {
+                      role: encryptedNode.membership.role,
+                      inviteTime: encryptedNode.membership.inviteTime,
+                      sharedBy: resultError({
+                          claimedAuthor: encryptedNode.encryptedCrypto.membership?.inviterEmail,
+                          error: getErrorMessage(error),
+                      }),
+                  }
+                : undefined,
+            errors: [error],
+            treeEventScopeId: splitNodeUid(encryptedNode.uid).volumeId,
+        };
+    }
+
+    protected abstract parseNode(
+        unparsedNode: Awaited<ReturnType<TCryptoService['decryptNode']>>['node'],
+    ): TDecryptedNode;
+
     async getParentKeys(
-        node: Pick<DecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
+        node: Pick<TDecryptedNode, 'uid' | 'parentUid' | 'shareId'>,
     ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
         if (node.parentUid) {
             try {
@@ -473,13 +490,23 @@ export class NodesAccess {
         return `https://drive.proton.me/${rootNode.shareId}/${type}/${nodeId}`;
     }
 
-    private async getRootNode(nodeUid: string): Promise<DecryptedNode> {
+    private async getRootNode(nodeUid: string): Promise<TDecryptedNode> {
         const node = await this.getNode(nodeUid);
         return node.parentUid ? this.getRootNode(node.parentUid) : node;
     }
 }
 
-export async function parseNode(logger: Logger, unparsedNode: DecryptedUnparsedNode): Promise<DecryptedNode> {
+export class NodesAccess extends NodesAccessBase {
+    protected getDegradedUndecryptableNode(encryptedNode: EncryptedNode, error: DecryptionError): DecryptedNode {
+        return this.getDegradedUndecryptableNodeBase(encryptedNode, error);
+    }
+
+    protected parseNode(unparsedNode: DecryptedUnparsedNode): DecryptedNode {
+        return parseNode(this.logger, unparsedNode);
+    }
+}
+
+export function parseNode(logger: Logger, unparsedNode: DecryptedUnparsedNode): DecryptedNode {
     let nodeName: Result<string, Error | InvalidNameError> = unparsedNode.name;
     if (unparsedNode.name.ok) {
         try {
@@ -526,6 +553,7 @@ export async function parseNode(logger: Logger, unparsedNode: DecryptedUnparsedN
     const extendedAttributes = unparsedNode.folder?.extendedAttributes
         ? parseFolderExtendedAttributes(logger, unparsedNode.folder.extendedAttributes)
         : undefined;
+
     return {
         ...unparsedNode,
         name: nodeName,

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

@@ -6,6 +6,7 @@ import { DecryptedNode } from './interface';
 import { NodesManagement } from './nodesManagement';
 import { NodeResult } from '../../interface';
 import { NodeOutOfSyncError } from './errors';
+import { ValidationError } from '../../errors';
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;
@@ -191,7 +192,7 @@ describe('NodesManagement', () => {
             parentNodeUid: 'newParentNodeUid',
         });
         expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
-            nodes.nodeUid,
+            nodes.nodeUid.name,
             expect.objectContaining({
                 key: 'nodeUid-key',
                 passphrase: 'nodeUid-passphrase',
@@ -231,7 +232,7 @@ describe('NodesManagement', () => {
         const newNode = await management.moveNode('anonymousNodeUid', 'newParentNodeUid');
 
         expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
-            nodes.anonymousNodeUid,
+            nodes.anonymousNodeUid.name,
             expect.objectContaining({
                 key: 'anonymousNodeUid-key',
                 passphrase: 'anonymousNodeUid-passphrase',
@@ -289,7 +290,7 @@ describe('NodesManagement', () => {
             parentNodeUid: 'newParentNodeUid',
         });
         expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
-            nodes.nodeUid,
+            nodes.nodeUid.name,
             expect.objectContaining({
                 key: 'nodeUid-key',
                 passphrase: 'nodeUid-passphrase',
@@ -324,7 +325,7 @@ describe('NodesManagement', () => {
         const newNode = await management.copyNode('anonymousNodeUid', 'newParentNodeUid');
 
         expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
-            nodes.anonymousNodeUid,
+            nodes.anonymousNodeUid.name,
             expect.objectContaining({
                 key: 'anonymousNodeUid-key',
                 passphrase: 'anonymousNodeUid-passphrase',
@@ -350,6 +351,49 @@ describe('NodesManagement', () => {
         });
     });
 
+    it('copyNode manages copy of node with new name', async () => {
+        const encryptedCrypto = {
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            armoredNodePassphrase: 'copiedArmoredNodePassphrase',
+            armoredNodePassphraseSignature: 'copiedArmoredNodePassphraseSignature',
+            signatureEmail: 'copiedSignatureEmail',
+            nameSignatureEmail: 'copiedNameSignatureEmail',
+        };
+        cryptoService.encryptNodeWithNewParent = jest.fn().mockResolvedValue(encryptedCrypto);
+
+        const newName = 'new name';
+        const newNode = await management.copyNode('nodeUid', 'newParentNodeUid', newName);
+
+        expect(newNode).toEqual({
+            ...nodes.nodeUid,
+            name: { ok: true, value: newName },
+            uid: 'newCopiedNodeUid',
+            parentUid: 'newParentNodeUid',
+            encryptedName: 'copiedArmoredNodeName',
+            hash: 'copiedHash',
+            keyAuthor: { ok: true, value: 'copiedSignatureEmail' },
+            nameAuthor: { ok: true, value: 'copiedNameSignatureEmail' },
+        });
+        expect(cryptoService.encryptNodeWithNewParent).toHaveBeenCalledWith(
+            { ok: true, value: newName },
+            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' }),
+            { type: 'userAddress', email: 'root-email', addressId: 'root-addressId', key: 'root-key' },
+        );
+    });
+
+    it('copyNode throws error if name is invalid', async () => {
+        const promise = management.copyNode('nodeUid', 'newParentNodeUid', 'invalid/name');
+        await expect(promise).rejects.toThrow(ValidationError);
+    });
+
     it('trashes node and updates cache', async () => {
         const uids = ['v1~n1', 'v1~n2'];
         const trashed = new Set();

package/src/internal/nodes/nodesManagement.ts

@@ -1,17 +1,17 @@
 import { c } from 'ttag';
 
-import { MemberRole, NodeType, NodeResult, NodeResultWithNewUid, resultOk } from '../../interface';
+import { MemberRole, NodeType, NodeResult, NodeResultWithNewUid, resultOk, InvalidNameError } from '../../interface';
 import { AbortError, ValidationError } from '../../errors';
-import { getErrorMessage } from '../errors';
+import { createErrorFromUnknown, getErrorMessage } from '../errors';
 import { splitNodeUid } from '../uids';
-import { NodeAPIService } from './apiService';
+import { NodeAPIServiceBase } from './apiService';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
 import { NodeOutOfSyncError } from './errors';
 import { generateFolderExtendedAttributes } from './extendedAttributes';
-import { DecryptedNode } from './interface';
+import { DecryptedNode, EncryptedNode } from './interface';
 import { splitExtension, joinNameAndExtension } from './nodeName';
-import { NodesAccess } from './nodesAccess';
+import { NodesAccessBase } from './nodesAccess';
 import { validateNodeName } from './validations';
 
 const AVAILABLE_NAME_BATCH_SIZE = 10;
@@ -26,12 +26,16 @@ const AVAILABLE_NAME_LIMIT = 1000;
  * This module uses other modules providing low-level operations, such
  * as API service, cache, crypto service, etc.
  */
-export class NodesManagement {
+export abstract class NodesManagementBase<
+    TEncryptedNode extends EncryptedNode = EncryptedNode,
+    TDecryptedNode extends DecryptedNode = DecryptedNode,
+    TNodesCryptoService extends NodesCryptoService = NodesCryptoService,
+> {
     constructor(
-        protected apiService: NodeAPIService,
+        protected apiService: NodeAPIServiceBase<TEncryptedNode>,
         protected cryptoCache: NodesCryptoCache,
         protected cryptoService: NodesCryptoService,
-        protected nodesAccess: NodesAccess,
+        protected nodesAccess: NodesAccessBase<TEncryptedNode, TDecryptedNode, TNodesCryptoService>,
     ) {
         this.apiService = apiService;
         this.cryptoCache = cryptoCache;
@@ -43,7 +47,7 @@ export class NodesManagement {
         nodeUid: string,
         newName: string,
         options = { allowRenameRootNode: false },
-    ): Promise<DecryptedNode> {
+    ): Promise<TDecryptedNode> {
         validateNodeName(newName);
 
         const node = await this.nodesAccess.getNode(nodeUid);
@@ -91,7 +95,7 @@ export class NodesManagement {
         }
 
         await this.nodesAccess.notifyNodeChanged(nodeUid);
-        const newNode: DecryptedNode = {
+        const newNode: TDecryptedNode = {
             ...node,
             name: resultOk(newName),
             encryptedName: armoredNodeName,
@@ -123,7 +127,7 @@ export class NodesManagement {
         }
     }
 
-    async moveNode(nodeUid: string, newParentUid: string): Promise<DecryptedNode> {
+    async moveNode(nodeUid: string, newParentUid: string): Promise<TDecryptedNode> {
         const node = await this.nodesAccess.getNode(nodeUid);
 
         const [keys, newParentKeys, signingKeys] = await Promise.all([
@@ -140,7 +144,7 @@ export class NodesManagement {
         }
 
         const encryptedCrypto = await this.cryptoService.encryptNodeWithNewParent(
-            node,
+            node.name,
             keys,
             { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
             signingKeys,
@@ -172,7 +176,7 @@ export class NodesManagement {
                 // TODO: When moving photos, we need to pass content hash.
             },
         );
-        const newNode: DecryptedNode = {
+        const newNode: TDecryptedNode = {
             ...node,
             encryptedName: encryptedCrypto.encryptedName,
             parentUid: newParentUid,
@@ -186,16 +190,18 @@ export class NodesManagement {
 
     // Improvement requested: copy nodes in parallel using copy_multiple endpoint
     async *copyNodes(
-        nodeUids: string[],
+        nodeUidsOrWithNames: (string | { uid: string; name: string })[],
         newParentNodeUid: string,
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResultWithNewUid> {
-        for (const nodeUid of nodeUids) {
+        for (const nodeUidOrWithName of nodeUidsOrWithNames) {
             if (signal?.aborted) {
                 throw new AbortError(c('Error').t`Copy operation aborted`);
             }
+            const nodeUid = typeof nodeUidOrWithName === 'string' ? nodeUidOrWithName : nodeUidOrWithName.uid;
+            const name = typeof nodeUidOrWithName === 'string' ? undefined : nodeUidOrWithName.name;
             try {
-                const { uid: newNodeUid } = await this.copyNode(nodeUid, newParentNodeUid);
+                const { uid: newNodeUid } = await this.copyNode(nodeUid, newParentNodeUid, name);
                 yield {
                     uid: nodeUid,
                     newUid: newNodeUid,
@@ -205,14 +211,19 @@ export class NodesManagement {
                 yield {
                     uid: nodeUid,
                     ok: false,
-                    error: getErrorMessage(error),
+                    error: createErrorFromUnknown(error),
                 };
             }
         }
     }
 
-    async copyNode(nodeUid: string, newParentUid: string): Promise<DecryptedNode> {
+    async copyNode(nodeUid: string, newParentUid: string, name?: string): Promise<TDecryptedNode> {
+        if (name) {
+            validateNodeName(name);
+        }
+
         const node = await this.nodesAccess.getNode(nodeUid);
+        const nodeName = name ? resultOk<string, Error | InvalidNameError>(name) : node.name;
 
         const [keys, newParentKeys, signingKeys] = await Promise.all([
             this.nodesAccess.getNodePrivateAndSessionKeys(nodeUid),
@@ -225,7 +236,7 @@ export class NodesManagement {
         }
 
         const encryptedCrypto = await this.cryptoService.encryptNodeWithNewParent(
-            node,
+            nodeName,
             keys,
             { key: newParentKeys.key, hashKey: newParentKeys.hashKey },
             signingKeys,
@@ -250,8 +261,9 @@ export class NodesManagement {
             nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
             hash: encryptedCrypto.hash,
         });
-        const newNode: DecryptedNode = {
+        const newNode: TDecryptedNode = {
             ...node,
+            name: nodeName,
             uid: newNodeUid,
             encryptedName: encryptedCrypto.encryptedName,
             parentUid: newParentUid,
@@ -291,7 +303,7 @@ export class NodesManagement {
     }
 
     // FIXME create test for create folder
-    async createFolder(parentNodeUid: string, folderName: string, modificationTime?: Date): Promise<DecryptedNode> {
+    async createFolder(parentNodeUid: string, folderName: string, modificationTime?: Date): Promise<TDecryptedNode> {
         validateNodeName(folderName);
 
         const parentKeys = await this.nodesAccess.getNodeKeys(parentNodeUid);
@@ -320,8 +332,33 @@ export class NodesManagement {
         });
 
         await this.nodesAccess.notifyChildCreated(parentNodeUid);
+        const node = this.generateNodeFolder(nodeUid, parentNodeUid, folderName, encryptedCrypto);
+        await this.cryptoCache.setNodeKeys(nodeUid, keys);
+        return node;
+    }
 
-        const node: DecryptedNode = {
+    protected abstract generateNodeFolder(
+        nodeUid: string,
+        parentUid: string,
+        name: string,
+        encryptedCrypto: {
+            hash: string;
+            encryptedName: string;
+            signatureEmail: string | null;
+        },
+    ): TDecryptedNode;
+
+    protected generateNodeFolderBase(
+        nodeUid: string,
+        parentNodeUid: string,
+        name: string,
+        encryptedCrypto: {
+            hash: string;
+            encryptedName: string;
+            signatureEmail: string | null;
+        },
+    ): DecryptedNode {
+        return {
             // Internal metadata
             hash: encryptedCrypto.hash,
             encryptedName: encryptedCrypto.encryptedName,
@@ -332,6 +369,7 @@ export class NodesManagement {
             type: NodeType.Folder,
             mediaType: 'Folder',
             creationTime: new Date(),
+            modificationTime: new Date(),
 
             // Share node metadata
             isShared: false,
@@ -342,12 +380,9 @@ export class NodesManagement {
             isStale: false,
             keyAuthor: resultOk(encryptedCrypto.signatureEmail || null),
             nameAuthor: resultOk(encryptedCrypto.signatureEmail || null),
-            name: resultOk(folderName),
+            name: resultOk(name),
             treeEventScopeId: splitNodeUid(nodeUid).volumeId,
         };
-
-        await this.cryptoCache.setNodeKeys(nodeUid, keys);
-        return node;
     }
 
     async findAvailableName(parentFolderUid: string, name: string): Promise<string> {
@@ -388,3 +423,18 @@ export class NodesManagement {
         throw new ValidationError(c('Error').t`No available name found`);
     }
 }
+
+export class NodesManagement extends NodesManagementBase {
+    protected generateNodeFolder(
+        nodeUid: string,
+        parentNodeUid: string,
+        name: string,
+        encryptedCrypto: {
+            hash: string;
+            encryptedName: string;
+            signatureEmail: string | null;
+        },
+    ): DecryptedNode {
+        return this.generateNodeFolderBase(nodeUid, parentNodeUid, name, encryptedCrypto);
+    }
+}

package/src/internal/nodes/nodesRevisions.ts

@@ -1,6 +1,6 @@
 import { Logger } from '../../interface';
 import { makeNodeUidFromRevisionUid } from '../uids';
-import { NodeAPIService } from './apiService';
+import { NodeAPIServiceBase } from './apiService';
 import { NodesCryptoService } from './cryptoService';
 import { NodesAccess } from './nodesAccess';
 import { parseFileExtendedAttributes } from './extendedAttributes';
@@ -12,9 +12,9 @@ import { DecryptedRevision } from './interface';
 export class NodesRevisons {
     constructor(
         private logger: Logger,
-        private apiService: NodeAPIService,
+        private apiService: NodeAPIServiceBase,
         private cryptoService: NodesCryptoService,
-        private nodesAccess: NodesAccess,
+        private nodesAccess: Pick<NodesAccess, 'getNodeKeys'>,
     ) {
         this.logger = logger;
         this.apiService = apiService;

package/src/internal/photos/albums.ts

@@ -1,7 +1,7 @@
 import { BatchLoading } from '../batchLoading';
 import { DecryptedNode } from '../nodes';
 import { PhotosAPIService } from './apiService';
-import { NodesService } from './interface';
+import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 
 const BATCH_LOADING_SIZE = 10;
@@ -13,7 +13,7 @@ export class Albums {
     constructor(
         private apiService: PhotosAPIService,
         private photoShares: PhotoSharesManager,
-        private nodesService: NodesService,
+        private nodesService: PhotosNodesAccess,
     ) {
         this.apiService = apiService;
         this.photoShares = photoShares;