@protontech/drive-sdk 0.7.0 → 0.7.2

package/src/internal/errors.ts

@@ -3,6 +3,10 @@ import { c } from 'ttag';
 import { VERIFICATION_STATUS } from '../crypto';
 import { AbortError, ConnectionError, RateLimitedError, ValidationError } from '../errors';
 
+export function createErrorFromUnknown(error: unknown): Error {
+    return error instanceof Error ? error : new Error(getErrorMessage(error), { cause: error });
+}
+
 export function getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : c('Error').t`Unknown error`;
 }

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

@@ -65,6 +65,7 @@ function generateAPINode() {
             ParentLinkID: 'parentLinkId',
             NameHash: 'nameHash',
             CreateTime: 123456789,
+            ModifyTime: 1234567890,
             TrashTime: 0,
 
             Name: 'encName',
@@ -140,6 +141,7 @@ function generateNode() {
         uid: 'volumeId~linkId',
         parentUid: 'volumeId~parentLinkId',
         creationTime: new Date(123456789000),
+        modificationTime: new Date(1234567890000),
         trashTime: undefined,
 
         shareId: undefined,

package/src/internal/nodes/apiService.ts

@@ -114,18 +114,21 @@ type PostCheckAvailableHashesResponse =
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
-export class NodeAPIService {
+export abstract class NodeAPIServiceBase<
+    T extends EncryptedNode = EncryptedNode,
+    TMetadataResponseLink extends { Link: { LinkID: string } } = { Link: { LinkID: string } },
+> {
     constructor(
-        private logger: Logger,
-        private apiService: DriveAPIService,
-        private clientUid: string | undefined,
+        protected logger: Logger,
+        protected apiService: DriveAPIService,
+        protected clientUid: string | undefined,
     ) {
         this.logger = logger;
         this.apiService = apiService;
         this.clientUid = clientUid;
     }
 
-    async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
+    async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<T> {
         const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, undefined, signal);
         const result = await nodesGenerator.next();
         if (!result.value) {
@@ -140,7 +143,7 @@ export class NodeAPIService {
         ownVolumeId: string | undefined,
         filterOptions?: FilterOptions,
         signal?: AbortSignal,
-    ): AsyncGenerator<EncryptedNode> {
+    ): AsyncGenerator<T> {
         const allNodeIds = nodeUids.map(splitNodeUid);
 
         const nodeIdsByVolumeId = new Map<string, string[]>();
@@ -184,27 +187,21 @@ export class NodeAPIService {
         }
     }
 
-    private async *iterateNodesPerVolume(
+    protected async *iterateNodesPerVolume(
         volumeId: string,
         nodeIds: string[],
         isOwnVolumeId: boolean,
         filterOptions?: FilterOptions,
         signal?: AbortSignal,
-    ): AsyncGenerator<EncryptedNode, unknown[]> {
+    ): AsyncGenerator<T, 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,
-            );
+            const responseLinks = await this.fetchNodeMetadata(volumeId, nodeIdsBatch, signal);
 
-            for (const link of response.Links) {
+            for (const link of responseLinks) {
                 try {
-                    const encryptedNode = linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    const encryptedNode = this.linkToEncryptedNode(volumeId, link, isOwnVolumeId);
                     if (filterOptions?.type && encryptedNode.type !== filterOptions.type) {
                         continue;
                     }
@@ -219,6 +216,14 @@ export class NodeAPIService {
         return errors;
     }
 
+    protected abstract fetchNodeMetadata(
+        volumeId: string,
+        linkIds: string[],
+        signal?: AbortSignal,
+    ): Promise<TMetadataResponseLink[]>;
+
+    protected abstract linkToEncryptedNode(volumeId: string, link: TMetadataResponseLink, isOwnVolumeId: boolean): T;
+
     // Improvement requested: load next page sooner before all IDs are yielded.
     async *iterateChildrenNodeUids(
         parentNodeUid: string,
@@ -341,24 +346,29 @@ export class NodeAPIService {
         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,
-        );
+        try {
+            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,
+            );
+        } catch (error: unknown) {
+            handleNodeWithSameNameExistsValidationError(volumeId, error);
+            throw error;
+        }
     }
 
     async copyNode(
@@ -377,23 +387,29 @@ export class NodeAPIService {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
         const { volumeId: parentVolumeId, nodeId: parentNodeId } = splitNodeUid(newNode.parentUid);
 
-        const response = await this.apiService.post<PostCopyNodeRequest, PostCopyNodeResponse>(
-            `drive/volumes/${volumeId}/links/${nodeId}/copy`,
-            {
-                TargetVolumeID: parentVolumeId,
-                TargetParentLinkID: parentNodeId,
-                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,
-            },
-            signal,
-        );
+        let response: PostCopyNodeResponse;
+        try {
+            response = await this.apiService.post<PostCopyNodeRequest, PostCopyNodeResponse>(
+                `drive/volumes/${volumeId}/links/${nodeId}/copy`,
+                {
+                    TargetVolumeID: parentVolumeId,
+                    TargetParentLinkID: parentNodeId,
+                    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,
+                },
+                signal,
+            );
+        } catch (error: unknown) {
+            handleNodeWithSameNameExistsValidationError(volumeId, error);
+            throw error;
+        }
 
         return makeNodeUid(volumeId, response.LinkID);
     }
@@ -491,21 +507,7 @@ export class NodeAPIService {
                 },
             );
         } catch (error: unknown) {
-            if (error instanceof ValidationError) {
-                if (error.code === ErrorCode.ALREADY_EXISTS) {
-                    const typedDetails = error.details as
-                        | {
-                              ConflictLinkID: string;
-                          }
-                        | undefined;
-
-                    const existingNodeUid = typedDetails?.ConflictLinkID
-                        ? makeNodeUid(volumeId, typedDetails.ConflictLinkID)
-                        : undefined;
-
-                    throw new NodeWithSameNameExistsValidationError(error.message, error.code, existingNodeUid);
-                }
-            }
+            handleNodeWithSameNameExistsValidationError(volumeId, error);
             throw error;
         }
 
@@ -583,6 +585,35 @@ export class NodeAPIService {
     }
 }
 
+export class NodeAPIService extends NodeAPIServiceBase {
+    constructor(logger: Logger, apiService: DriveAPIService, clientUid: string | undefined) {
+        super(logger, apiService, clientUid);
+    }
+
+    protected async fetchNodeMetadata(
+        volumeId: string,
+        linkIds: string[],
+        signal?: AbortSignal,
+    ): Promise<PostLoadLinksMetadataResponse['Links']> {
+        const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(
+            `drive/v2/volumes/${volumeId}/links`,
+            {
+                LinkIDs: linkIds,
+            },
+            signal,
+        );
+        return response.Links;
+    }
+
+    protected linkToEncryptedNode(
+        volumeId: string,
+        link: PostLoadLinksMetadataResponse['Links'][0],
+        isOwnVolumeId: boolean,
+    ): EncryptedNode {
+        return linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+    }
+}
+
 type LinkResponse = {
     LinkID: string;
     Response: {
@@ -615,56 +646,36 @@ function* handleResponseErrors(
     }
 }
 
-function linkToEncryptedNode(
+function handleNodeWithSameNameExistsValidationError(volumeId: string, error: unknown): void {
+    if (error instanceof ValidationError) {
+        if (error.code === ErrorCode.ALREADY_EXISTS) {
+            const typedDetails = error.details as
+                | {
+                      ConflictLinkID: string;
+                  }
+                | undefined;
+
+            const existingNodeUid = typedDetails?.ConflictLinkID
+                ? makeNodeUid(volumeId, typedDetails.ConflictLinkID)
+                : undefined;
+
+            throw new NodeWithSameNameExistsValidationError(error.message, error.code, existingNodeUid);
+        }
+    }
+}
+
+export function linkToEncryptedNode(
     logger: Logger,
     volumeId: string,
-    link: PostLoadLinksMetadataResponse['Links'][0],
+    link: Pick<PostLoadLinksMetadataResponse['Links'][0], 'Link' | 'Membership' | 'Sharing' | 'Folder' | 'File'>,
     isAdmin: boolean,
 ): EncryptedNode {
-    const membershipRole = permissionsToMemberRole(logger, link.Membership?.Permissions);
-
-    const baseNodeMetadata = {
-        // Internal metadata
-        hash: link.Link.NameHash || undefined,
-        encryptedName: link.Link.Name,
-
-        // Basic node metadata
-        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,
-
-        // Sharing node metadata
-        shareId: link.Sharing?.ShareID || undefined,
-        isShared: !!link.Sharing,
-        isSharedPublicly: !!link.Sharing?.ShareURLID,
-        directRole: isAdmin ? MemberRole.Admin : membershipRole,
-        membership: link.Membership
-            ? {
-                  role: membershipRole,
-                  inviteTime: new Date(link.Membership.InviteTime * 1000),
-              }
-            : undefined,
-    };
-
-    const baseCryptoNodeMetadata = {
-        signatureEmail: link.Link.SignatureEmail || undefined,
-        nameSignatureEmail: link.Link.NameSignatureEmail || undefined,
-        armoredKey: link.Link.NodeKey,
-        armoredNodePassphrase: link.Link.NodePassphrase,
-        armoredNodePassphraseSignature: link.Link.NodePassphraseSignature,
-        membership: link.Membership
-            ? {
-                  inviterEmail: link.Membership.InviterEmail,
-                  base64MemberSharePassphraseKeyPacket: link.Membership.MemberSharePassphraseKeyPacket,
-                  armoredInviterSharePassphraseKeyPacketSignature:
-                      link.Membership.InviterSharePassphraseKeyPacketSignature,
-                  armoredInviteeSharePassphraseSessionKeySignature:
-                      link.Membership.InviteeSharePassphraseSessionKeySignature,
-              }
-            : undefined,
-    };
+    const { baseNodeMetadata, baseCryptoNodeMetadata } = linkToEncryptedNodeBaseMetadata(
+        logger,
+        volumeId,
+        link,
+        isAdmin,
+    );
 
     if (link.Link.Type === 1 && link.Folder) {
         return {
@@ -706,6 +717,11 @@ function linkToEncryptedNode(
         };
     }
 
+    // TODO: Remove this once client do not use main SDK for photos.
+    // At the beginning, the client used main SDK for some photo actions.
+    // This was a temporary solution before the Photos SDK was implemented.
+    // Now the client must use Photos SDK for all photo-related actions.
+    // Knowledge of albums in main SDK is deprecated and will be removed.
     if (link.Link.Type === 3) {
         return {
             ...baseNodeMetadata,
@@ -718,6 +734,64 @@ function linkToEncryptedNode(
     throw new Error(`Unknown node type: ${link.Link.Type}`);
 }
 
+export function linkToEncryptedNodeBaseMetadata(
+    logger: Logger,
+    volumeId: string,
+    link: Pick<PostLoadLinksMetadataResponse['Links'][0], 'Link' | 'Membership' | 'Sharing'>,
+    isAdmin: boolean,
+) {
+    const membershipRole = permissionsToMemberRole(logger, link.Membership?.Permissions);
+
+    const baseNodeMetadata = {
+        // Internal metadata
+        hash: link.Link.NameHash || undefined,
+        encryptedName: link.Link.Name,
+
+        // Basic node metadata
+        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),
+        modificationTime: new Date(link.Link.ModifyTime * 1000),
+        trashTime: link.Link.TrashTime ? new Date(link.Link.TrashTime * 1000) : undefined,
+
+        // Sharing node metadata
+        shareId: link.Sharing?.ShareID || undefined,
+        isShared: !!link.Sharing,
+        isSharedPublicly: !!link.Sharing?.ShareURLID,
+        directRole: isAdmin ? MemberRole.Admin : membershipRole,
+        membership: link.Membership
+            ? {
+                  role: membershipRole,
+                  inviteTime: new Date(link.Membership.InviteTime * 1000),
+              }
+            : undefined,
+    };
+
+    const baseCryptoNodeMetadata = {
+        signatureEmail: link.Link.SignatureEmail || undefined,
+        nameSignatureEmail: link.Link.NameSignatureEmail || undefined,
+        armoredKey: link.Link.NodeKey,
+        armoredNodePassphrase: link.Link.NodePassphrase,
+        armoredNodePassphraseSignature: link.Link.NodePassphraseSignature,
+        membership: link.Membership
+            ? {
+                  inviterEmail: link.Membership.InviterEmail,
+                  base64MemberSharePassphraseKeyPacket: link.Membership.MemberSharePassphraseKeyPacket,
+                  armoredInviterSharePassphraseKeyPacketSignature:
+                      link.Membership.InviterSharePassphraseKeyPacketSignature,
+                  armoredInviteeSharePassphraseSessionKeySignature:
+                      link.Membership.InviteeSharePassphraseSessionKeySignature,
+              }
+            : undefined,
+    };
+
+    return {
+        baseNodeMetadata,
+        baseCryptoNodeMetadata,
+    };
+}
+
 export function* groupNodeUidsByVolumeAndIteratePerBatch(
     nodeUids: string[],
 ): Generator<{ volumeId: string; batchNodeIds: string[]; batchNodeUids: string[] }> {
@@ -745,7 +819,6 @@ export function* groupNodeUidsByVolumeAndIteratePerBatch(
     }
 }
 
-
 function transformRevisionResponse(
     volumeId: string,
     nodeId: string,

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

@@ -23,6 +23,7 @@ function generateNode(
         isShared: false,
         isSharedPublicly: false,
         creationTime: new Date(),
+        modificationTime: new Date(),
         trashTime: undefined,
         volumeId: 'volumeId',
         isStale: false,

package/src/internal/nodes/cache.ts

@@ -9,7 +9,9 @@ export enum CACHE_TAG_KEYS {
     Roots = 'nodeRoot',
 }
 
-type DecryptedNodeResult = { uid: string; ok: true; node: DecryptedNode } | { uid: string; ok: false; error: string };
+type DecryptedNodeResult<T extends DecryptedNode> =
+    | { uid: string; ok: true; node: T }
+    | { uid: string; ok: false; error: string };
 
 /**
  * Provides caching for nodes metadata.
@@ -19,7 +21,7 @@ type DecryptedNodeResult = { uid: string; ok: true; node: DecryptedNode } | { ui
  *
  * The cache of node metadata should not contain any crypto material.
  */
-export class NodesCache {
+export abstract class NodesCacheBase<T extends DecryptedNode = DecryptedNode> {
     constructor(
         private logger: Logger,
         private driveCache: ProtonDriveEntitiesCache,
@@ -28,9 +30,9 @@ export class NodesCache {
         this.driveCache = driveCache;
     }
 
-    async setNode(node: DecryptedNode): Promise<void> {
+    async setNode(node: T): Promise<void> {
         const key = getCacheUid(node.uid);
-        const nodeData = serialiseNode(node);
+        const nodeData = this.serialiseNode(node);
         const { volumeId } = splitNodeUid(node.uid);
 
         const tags = [`volume:${volumeId}`];
@@ -46,11 +48,11 @@ export class NodesCache {
         await this.driveCache.setEntity(key, nodeData, tags);
     }
 
-    async getNode(nodeUid: string): Promise<DecryptedNode> {
+    async getNode(nodeUid: string): Promise<T> {
         const key = getCacheUid(nodeUid);
         const nodeData = await this.driveCache.getEntity(key);
         try {
-            return deserialiseNode(nodeData);
+            return this.deserialiseNode(nodeData);
         } catch (error: unknown) {
             await this.removeCorruptedNode({ nodeUid }, error);
             throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`, {
@@ -59,6 +61,10 @@ export class NodesCache {
         }
     }
 
+    protected abstract serialiseNode(node: T): string;
+
+    protected abstract deserialiseNode(nodeData: string): T;
+
     /**
      * Set all nodes on given node as stale. This is useful when we
      * get refresh event from the server and we thus don't know
@@ -146,7 +152,7 @@ export class NodesCache {
         return cacheUids;
     }
 
-    async *iterateNodes(nodeUids: string[]): AsyncGenerator<DecryptedNodeResult> {
+    async *iterateNodes(nodeUids: string[]): AsyncGenerator<DecryptedNodeResult<T>> {
         const cacheUids = nodeUids.map(getCacheUid);
         for await (const result of this.driveCache.iterateEntities(cacheUids)) {
             const node = await this.convertCacheResult(result);
@@ -156,7 +162,7 @@ export class NodesCache {
         }
     }
 
-    async *iterateChildren(parentNodeUid: string): AsyncGenerator<DecryptedNodeResult> {
+    async *iterateChildren(parentNodeUid: string): AsyncGenerator<DecryptedNodeResult<T>> {
         for await (const result of this.driveCache.iterateEntitiesByTag(
             `${CACHE_TAG_KEYS.ParentUid}:${parentNodeUid}`,
         )) {
@@ -171,7 +177,7 @@ export class NodesCache {
         yield* this.driveCache.iterateEntitiesByTag(`${CACHE_TAG_KEYS.Roots}:${volumeId}`);
     }
 
-    async *iterateTrashedNodes(): AsyncGenerator<DecryptedNodeResult> {
+    async *iterateTrashedNodes(): AsyncGenerator<DecryptedNodeResult<T>> {
         for await (const result of this.driveCache.iterateEntitiesByTag(CACHE_TAG_KEYS.Trashed)) {
             const node = await this.convertCacheResult(result);
             if (node) {
@@ -184,7 +190,7 @@ export class NodesCache {
      * Converts result from the cache with cache UID and data to result of node
      * with node UID and DecryptedNode.
      */
-    private async convertCacheResult(result: EntityResult<string>): Promise<DecryptedNodeResult | null> {
+    private async convertCacheResult(result: EntityResult<string>): Promise<DecryptedNodeResult<T> | null> {
         let nodeUid;
         try {
             nodeUid = getNodeUid(result.key);
@@ -195,7 +201,7 @@ export class NodesCache {
         if (result.ok) {
             let node;
             try {
-                node = deserialiseNode(result.value);
+                node = this.deserialiseNode(result.value);
             } catch (error: unknown) {
                 await this.removeCorruptedNode({ nodeUid }, error);
                 return null;
@@ -232,6 +238,16 @@ export class NodesCache {
     }
 }
 
+export class NodesCache extends NodesCacheBase<DecryptedNode> {
+    protected serialiseNode(node: DecryptedNode): string {
+        return serialiseNode(node);
+    }
+
+    protected deserialiseNode(nodeData: string): DecryptedNode {
+        return deserialiseNode(nodeData);
+    }
+}
+
 function getCacheUid(nodeUid: string) {
     return `node-${nodeUid}`;
 }
@@ -243,11 +259,12 @@ function getNodeUid(cacheUid: string) {
     return cacheUid.substring(5);
 }
 
-function serialiseNode(node: DecryptedNode) {
+export function serialiseNode(node: DecryptedNode) {
     return JSON.stringify(node);
 }
 
-function deserialiseNode(nodeData: string): DecryptedNode {
+// TODO: use better deserialisation with validation
+export function deserialiseNode(nodeData: string): DecryptedNode {
     const node = JSON.parse(nodeData);
     if (
         !node ||
@@ -263,6 +280,7 @@ function deserialiseNode(nodeData: string): DecryptedNode {
         typeof node.isShared !== 'boolean' ||
         !node.creationTime ||
         typeof node.creationTime !== 'string' ||
+        typeof node.modificationTime !== 'string' ||
         (typeof node.trashTime !== 'string' && node.trashTime !== undefined) ||
         (typeof node.folder !== 'object' && node.folder !== undefined) ||
         (typeof node.folder?.claimedModificationTime !== 'string' && node.folder?.claimedModificationTime !== undefined)
@@ -272,6 +290,7 @@ function deserialiseNode(nodeData: string): DecryptedNode {
     return {
         ...node,
         creationTime: new Date(node.creationTime),
+        modificationTime: new Date(node.modificationTime),
         trashTime: node.trashTime ? new Date(node.trashTime) : undefined,
         activeRevision: node.activeRevision ? deserialiseRevision(node.activeRevision) : undefined,
         membership: node.membership

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

@@ -1327,7 +1327,12 @@ describe('nodesCryptoService', () => {
                 key: 'addressKey' as any,
             };
 
-            const result = await cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, signingKeys);
+            const result = await cryptoService.encryptNodeWithNewParent(
+                node.name,
+                keys as any,
+                parentKeys,
+                signingKeys,
+            );
 
             expect(result).toEqual({
                 encryptedName: 'encryptedNodeName',
@@ -1360,7 +1365,12 @@ describe('nodesCryptoService', () => {
                 parentNodeKey: 'parentNodeKey' as any,
             };
 
-            const result = await cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, signingKeys);
+            const result = await cryptoService.encryptNodeWithNewParent(
+                node.name,
+                keys as any,
+                parentKeys,
+                signingKeys,
+            );
 
             expect(result).toEqual({
                 encryptedName: 'encryptedNodeName',
@@ -1407,7 +1417,7 @@ describe('nodesCryptoService', () => {
             };
 
             await expect(
-                cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, signingKeys),
+                cryptoService.encryptNodeWithNewParent(node.name, keys as any, parentKeys, signingKeys),
             ).rejects.toThrow('Moving item to a non-folder is not allowed');
         });
 

package/src/internal/nodes/cryptoService.ts

@@ -637,7 +637,7 @@ export class NodesCryptoService {
     }
 
     async encryptNodeWithNewParent(
-        node: Pick<DecryptedNode, 'name'>,
+        nodeName: DecryptedNode['name'],
         keys: { passphrase: string; passphraseSessionKey: SessionKey; nameSessionKey: SessionKey },
         parentKeys: { key: PrivateKey; hashKey: Uint8Array },
         signingKeys: NodeSigningKeys,
@@ -652,7 +652,7 @@ export class NodesCryptoService {
         if (!parentKeys.hashKey) {
             throw new ValidationError('Moving item to a non-folder is not allowed');
         }
-        if (!node.name.ok) {
+        if (!nodeName.ok) {
             throw new ValidationError('Cannot move item without a valid name, please rename the item first');
         }
 
@@ -664,12 +664,12 @@ export class NodesCryptoService {
         }
 
         const { armoredNodeName } = await this.driveCrypto.encryptNodeName(
-            node.name.value,
+            nodeName.value,
             keys.nameSessionKey,
             parentKeys.key,
             nameAndPassprhaseSigningKey,
         );
-        const hash = await this.driveCrypto.generateLookupHash(node.name.value, parentKeys.hashKey);
+        const hash = await this.driveCrypto.generateLookupHash(nodeName.value, parentKeys.hashKey);
         const { armoredPassphrase, armoredPassphraseSignature } = await this.driveCrypto.encryptPassphrase(
             keys.passphrase,
             keys.passphraseSessionKey,

package/src/internal/nodes/events.ts

@@ -1,6 +1,6 @@
 import { Logger } from '../../interface';
 import { DriveEvent, DriveEventType } from '../events';
-import { NodesCache } from './cache';
+import { NodesCacheBase } from './cache';
 
 /**
  * Provides internal event handling.
@@ -11,7 +11,7 @@ import { NodesCache } from './cache';
 export class NodesEventsHandler {
     constructor(
         private logger: Logger,
-        private cache: NodesCache,
+        private cache: NodesCacheBase,
     ) {}
 
     async updateNodesCacheOnEvent(event: DriveEvent): Promise<void> {