@protontech/drive-sdk 0.6.2 → 0.7.1

package/src/internal/nodes/apiService.ts

@@ -1,8 +1,7 @@
 import { c } from 'ttag';
 
 import { NodeWithSameNameExistsValidationError, ProtonDriveError, ValidationError } from '../../errors';
-import { Logger, NodeResult } from '../../interface';
-import { MemberRole, RevisionState } from '../../interface/nodes';
+import { Logger, NodeResult, MemberRole, RevisionState, AnonymousUser } from '../../interface';
 import {
     DriveAPIService,
     drivePaths,
@@ -102,7 +101,6 @@ type PostRestoreRevisionResponse =
 type DeleteRevisionResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['delete']['responses']['200']['content']['application/json'];
 
-
 type PostCheckAvailableHashesRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/checkAvailableHashes']['post']['requestBody'],
     { content: object }
@@ -116,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) {
@@ -142,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[]>();
@@ -186,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;
                     }
@@ -221,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,
@@ -292,7 +295,7 @@ export class NodeAPIService {
         },
         newNode: {
             encryptedName: string;
-            nameSignatureEmail: string;
+            nameSignatureEmail: string | AnonymousUser;
             hash?: string;
         },
         signal?: AbortSignal,
@@ -332,9 +335,9 @@ export class NodeAPIService {
             parentUid: string;
             armoredNodePassphrase: string;
             armoredNodePassphraseSignature?: string;
-            signatureEmail?: string;
+            signatureEmail?: string | AnonymousUser;
             encryptedName: string;
-            nameSignatureEmail?: string;
+            nameSignatureEmail?: string | AnonymousUser;
             hash: string;
             contentHash?: string;
         },
@@ -343,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(
@@ -369,9 +377,9 @@ export class NodeAPIService {
             parentUid: string;
             armoredNodePassphrase: string;
             armoredNodePassphraseSignature?: string;
-            signatureEmail?: string;
+            signatureEmail?: string | AnonymousUser;
             encryptedName: string;
-            nameSignatureEmail?: string;
+            nameSignatureEmail?: string | AnonymousUser;
             hash: string;
         },
         signal?: AbortSignal,
@@ -379,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);
     }
@@ -430,7 +444,7 @@ export class NodeAPIService {
         }
     }
 
-    async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *deleteTrashedNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for (const { volumeId, batchNodeIds, batchNodeUids } of groupNodeUidsByVolumeAndIteratePerBatch(nodeUids)) {
             const response = await this.apiService.post<PostDeleteNodesRequest, PostDeleteNodesResponse>(
                 `drive/v2/volumes/${volumeId}/trash/delete_multiple`,
@@ -445,6 +459,21 @@ export class NodeAPIService {
         }
     }
 
+    async *deleteExistingNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+        for (const { volumeId, batchNodeIds, batchNodeUids } of groupNodeUidsByVolumeAndIteratePerBatch(nodeUids)) {
+            const response = await this.apiService.post<PostDeleteNodesRequest, PostDeleteNodesResponse>(
+                `drive/v2/volumes/${volumeId}/delete_multiple`,
+                {
+                    LinkIDs: batchNodeIds,
+                },
+                signal,
+            );
+
+            // TODO: remove `as` when backend fixes OpenAPI schema.
+            yield* handleResponseErrors(batchNodeUids, volumeId, response.Responses as LinkResponse[]);
+        }
+    }
+
     async createFolder(
         parentUid: string,
         newNode: {
@@ -452,7 +481,7 @@ export class NodeAPIService {
             armoredHashKey: string;
             armoredNodePassphrase: string;
             armoredNodePassphraseSignature: string;
-            signatureEmail: string;
+            signatureEmail: string | AnonymousUser;
             encryptedName: string;
             hash: string;
             armoredExtendedAttributes?: string;
@@ -478,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;
         }
 
@@ -570,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: {
@@ -602,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 {
@@ -693,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,
@@ -705,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[] }> {
@@ -732,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/cryptoReporter.ts

@@ -34,7 +34,7 @@ export class NodesCryptoReporter {
         signatureType: string,
         verified: VERIFICATION_STATUS,
         verificationErrors?: Error[],
-        claimedAuthor?: string,
+        claimedAuthor?: string | AnonymousUser,
         notAvailableVerificationKeys = false,
     ): Promise<Author> {
         const author = handleClaimedAuthor(
@@ -54,7 +54,7 @@ export class NodesCryptoReporter {
         node: { uid: string; creationTime: Date },
         field: MetricVerificationErrorField,
         verificationErrors?: Error[],
-        claimedAuthor?: string,
+        claimedAuthor?: string | AnonymousUser,
     ) {
         if (this.reportedVerificationErrors.has(node.uid)) {
             return;
@@ -128,7 +128,7 @@ function handleClaimedAuthor(
     signatureType: string,
     verified: VERIFICATION_STATUS,
     verificationErrors?: Error[],
-    claimedAuthor?: string,
+    claimedAuthor?: string | AnonymousUser,
     notAvailableVerificationKeys = false,
 ): Author {
     if (!claimedAuthor && notAvailableVerificationKeys) {