@protontech/drive-sdk 0.0.12 → 0.1.0

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

@@ -44,6 +44,18 @@ function generateAPIFolderNode(linkOverrides = {}, overrides = {}) {
     };
 }
 
+function generateAPIAlbumNode(linkOverrides = {}, overrides = {}) {
+    const node = generateAPINode();
+    return {
+        Link: {
+            ...node.Link,
+            Type: 3,
+            ...linkOverrides,
+        },
+        ...overrides,
+    };
+}
+
 function generateAPINode() {
     return {
         Link: {
@@ -107,6 +119,15 @@ function generateFolderNode(overrides = {}) {
     }
 }
 
+function generateAlbumNode(overrides = {}) {
+    const node = generateNode();
+    return {
+        ...node,
+        type: NodeType.Album,
+        ...overrides
+    }
+}
+
 function generateNode() {
     return {
         hash: "nameHash",
@@ -119,7 +140,7 @@ function generateNode() {
 
         shareId: undefined,
         isShared: false,
-        directMemberRole: MemberRole.Inherited,
+        directMemberRole: MemberRole.Admin,
 
         encryptedCrypto: {
             armoredKey: "nodeKey",
@@ -149,13 +170,13 @@ describe("nodeAPIService", () => {
     });
 
     describe('iterateNodes', () => {
-        async function testIterateNodes(mockedLink: any, expectedNode: any) {
+        async function testIterateNodes(mockedLink: any, expectedNode: any, ownVolumeId = 'volumeId') {
             // @ts-expect-error Mocking for testing purposes
             apiMock.post = jest.fn(async () => Promise.resolve({
                 Links: [mockedLink],
             }));
 
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId']));
+            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], ownVolumeId));
             expect(nodes).toStrictEqual([expectedNode]);
         }
     
@@ -180,6 +201,13 @@ describe("nodeAPIService", () => {
             );
         });
 
+        it('should get album node', async () => {
+            await testIterateNodes(
+                generateAPIAlbumNode(),
+                generateAlbumNode(),
+            );
+        });
+
         it('should get shared node', async () => {
             await testIterateNodes(
                 generateAPIFolderNode({}, {
@@ -213,6 +241,7 @@ describe("nodeAPIService", () => {
                     shareId: 'shareId',
                     directMemberRole: MemberRole.Viewer,
                 }),
+                'myVolumeId',
             );
         });
 
@@ -240,7 +269,7 @@ describe("nodeAPIService", () => {
                 ],
             }));
 
-            const generator = api.iterateNodes(['volumeId~nodeId']);
+            const generator = api.iterateNodes(['volumeId~nodeId'], 'volumeId');
 
             const node1 = await generator.next();
             expect(node1.value).toStrictEqual(generateFolderNode());
@@ -272,10 +301,10 @@ describe("nodeAPIService", () => {
                 ],
             }));
 
-            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2']));
+            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId1~nodeId1', 'volumeId2~nodeId2'], 'volumeId1'));
             expect(nodes).toStrictEqual([
-                generateFolderNode({ uid: 'volumeId1~nodeId1', parentUid: 'volumeId1~parentNodeId1' }),
-                generateFolderNode({ uid: 'volumeId2~nodeId2', parentUid: 'volumeId2~parentNodeId2' }),
+                generateFolderNode({ uid: 'volumeId1~nodeId1', parentUid: 'volumeId1~parentNodeId1', directMemberRole: MemberRole.Admin }),
+                generateFolderNode({ uid: 'volumeId2~nodeId2', parentUid: 'volumeId2~parentNodeId2', directMemberRole: MemberRole.Inherited }),
             ]);
         });
     });

package/src/internal/nodes/apiService.ts

@@ -2,7 +2,7 @@ import { c } from "ttag";
 
 import { ProtonDriveError, ValidationError } from "../../errors";
 import { Logger, NodeResult } from "../../interface";
-import { RevisionState } from "../../interface/nodes";
+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";
@@ -56,15 +56,15 @@ export class NodeAPIService {
         this.apiService = apiService;
     }
 
-    async getNode(nodeUid: string, signal?: AbortSignal): Promise<EncryptedNode> {
-        const nodesGenerator = this.iterateNodes([nodeUid], signal);
+    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");
         return result.value;
     }
 
     // Improvement requested: split into multiple calls for many nodes.
-    async* iterateNodes(nodeUids: 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[]>();
@@ -81,13 +81,15 @@ export class NodeAPIService {
         const errors = [];
 
         for (const [volumeId, nodeIds] of nodeIdsByVolumeId.entries()) {
+            const isAdmin = volumeId === ownVolumeId;
+
             const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(`drive/v2/volumes/${volumeId}/links`, {
                 LinkIDs: nodeIds,
             }, signal);
 
             for (const link of response.Links) {
                 try {
-                    yield linkToEncryptedNode(this.logger, volumeId, link);
+                    yield linkToEncryptedNode(this.logger, volumeId, link, isAdmin);
                 } catch (error: unknown) {
                     this.logger.error(`Failed to transform node ${link.Link.LinkID}`, error);
                     errors.push(error);
@@ -363,7 +365,7 @@ function* handleResponseErrors(nodeUids: string[], volumeId: string, responses:
     }
 }
 
-function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLinksMetadataResponse['Links'][0]): EncryptedNode {
+function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLinksMetadataResponse['Links'][0], isAdmin: boolean): EncryptedNode {
     const baseNodeMetadata = {
         // Internal metadata
         hash: link.Link.NameHash || undefined,
@@ -379,7 +381,7 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
         // Sharing node metadata
         shareId: link.Sharing?.ShareID || undefined,
         isShared: !!link.Sharing,
-        directMemberRole: permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
+        directMemberRole: isAdmin ? MemberRole.Admin : permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
     }
     const baseCryptoNodeMetadata = {
         signatureEmail: link.Link.SignatureEmail || undefined,
@@ -426,6 +428,15 @@ function linkToEncryptedNode(logger: Logger, volumeId: string, link: PostLoadLin
         }
     }
 
+    if (link.Link.Type === 3) {
+        return {
+            ...baseNodeMetadata,
+            encryptedCrypto: {
+                ...baseCryptoNodeMetadata,
+            },
+        }
+    }
+
     throw new Error(`Unknown node type: ${link.Link.Type}`);
 }
 
@@ -437,6 +448,7 @@ function transformRevisionResponse(
     return {
         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),
         storageSize: revision.Size,
         signatureEmail: revision.SignatureEmail || undefined,

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

@@ -108,6 +108,7 @@ describe('nodesCache', () => {
             creationTime: new Date('2021-01-01'),
             storageSize: 100,
             contentAuthor: resultOk('test@test.com'),
+            claimedModificationTime: new Date('2021-02-01')
         });
         const node = generateNode('node1', '', { activeRevision });
 

package/src/internal/nodes/cache.ts

@@ -6,6 +6,7 @@ import { DecryptedNode, DecryptedRevision } from "./interface";
 export enum CACHE_TAG_KEYS {
     ParentUid = 'nodeParentUid',
     Trashed = 'nodeTrashed',
+    Roots = 'nodeRoot',
 }
 
 type DecryptedNodeResult = (
@@ -15,10 +16,10 @@ type DecryptedNodeResult = (
 
 /**
  * Provides caching for nodes metadata.
- * 
+ *
  * The cache is responsible for serialising and deserialising node metadata,
  * recording parent-child relationships, and recursively removing nodes.
- * 
+ *
  * The cache of node metadata should not contain any crypto material.
  */
 export class NodesCache {
@@ -35,6 +36,8 @@ export class NodesCache {
         const tags = [`volume:${volumeId}`];
         if (node.parentUid) {
             tags.push(`${CACHE_TAG_KEYS.ParentUid}:${node.parentUid}`)
+        } else {
+            tags.push(`${CACHE_TAG_KEYS.Roots}:${volumeId}`)
         }
         if (node.trashTime) {
             tags.push(`${CACHE_TAG_KEYS.Trashed}`)
@@ -74,6 +77,17 @@ export class NodesCache {
         }
     }
 
+    /**
+     * Remove all entries associated with a volume.
+     *
+     * This is needed when a user looses access to a volume.
+     */
+    async removeVolume(volumeId: string): Promise<void> {
+        for await (const result of this.iterateRootNodeUids(volumeId)) {
+            await this.removeNodes([result.key]);
+        }
+    }
+
     /**
      * Remove corrupted node never throws, but it logs so we can know
      * about issues and fix them. It is crucial to remove corrupted
@@ -142,6 +156,10 @@ export class NodesCache {
         }
     }
 
+    async *iterateRootNodeUids(volumeId: string): AsyncGenerator<EntityResult<string>> {
+        yield* this.driveCache.iterateEntitiesByTag(`${CACHE_TAG_KEYS.Roots}:${volumeId}`);
+    }
+
     async *iterateTrashedNodes(): AsyncGenerator<DecryptedNodeResult> {
         for await (const result of this.driveCache.iterateEntitiesByTag(CACHE_TAG_KEYS.Trashed)) {
             const node = await this.convertCacheResult(result);
@@ -261,6 +279,7 @@ function deserialiseRevision(revision: any): Result<DecryptedRevision, Error> {
         return resultOk({
             ...revision.value,
             creationTime: new Date(revision.value.creationTime),
+            claimedModificationTime: new Date(revision.value.claimedModificationTime)
         });
     }
 

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

@@ -578,6 +578,44 @@ describe("nodesCryptoService", () => {
         });
     });
 
+    describe("album node", () => {
+        const encryptedNode = {
+            uid: "volumeId~nodeId",
+            parentUid: "volumeId~parentId",
+            encryptedCrypto: {
+                signatureEmail: "signatureEmail",
+                nameSignatureEmail: "nameSignatureEmail",
+                armoredKey: "armoredKey",
+                armoredNodePassphrase: "armoredNodePassphrase",
+                armoredNodePassphraseSignature: "armoredNodePassphraseSignature",
+            },
+        } as EncryptedNode;
+
+        it("should decrypt successfuly", async () => {
+            const result = await cryptoService.decryptNode(encryptedNode, parentKey);
+
+            expect(result).toMatchObject({
+                node: {
+                    name: { ok: true, value: "name" },
+                    keyAuthor: { ok: true, value: "signatureEmail" },
+                    nameAuthor: { ok: true, value: "nameSignatureEmail" },
+                    folder: undefined,
+                    activeRevision: undefined,
+                    errors: undefined,
+                },
+                keys: {
+                    passphrase: "pass",
+                    key: "decryptedKey",
+                    passphraseSessionKey: "passphraseSessionKey",
+                    hashKey: new Uint8Array(),
+                }
+            });
+
+            expect(account.getPublicKeys).toHaveBeenCalledTimes(2);
+            expect(telemetry.logEvent).not.toHaveBeenCalled();
+        });
+    });
+
     describe("anonymous node", () => {
         const encryptedNode = {
             uid: "volumeId~nodeId",

package/src/internal/nodes/cryptoService.ts

@@ -422,7 +422,7 @@ export class NodesCryptoService {
     };
 
     async moveNode(
-        node: DecryptedNode,
+        node: Pick<DecryptedNode, 'name'>,
         keys: { passphrase: string, passphraseSessionKey: SessionKey, nameSessionKey: SessionKey },
         parentKeys: { key: PrivateKey, hashKey: Uint8Array },
         address: { email: string, addressKey: PrivateKey },