@protontech/drive-sdk 0.0.10

package/src/internal/sharing/sharingAccess.test.ts

@@ -0,0 +1,102 @@
+import { SharingAPIService } from "./apiService";
+import { SharingCache } from "./cache";
+import { SharingCryptoService } from "./cryptoService";
+import { SharesService, NodesService } from "./interface";
+import { SharingAccess } from "./sharingAccess";
+
+describe("SharingAccess", () => {
+    let apiService: SharingAPIService;
+    let cache: SharingCache;
+    let cryptoService: SharingCryptoService;
+    let sharesService: SharesService;
+    let nodesService: NodesService;
+
+    let sharingAccess: SharingAccess;
+
+    const nodeUids = Array.from({ length: 15 }, (_, i) => `nodeUid${i}`);
+    const nodes = nodeUids.map((nodeUid) => ({ nodeUid }));
+    const nodeUidsIterator = async function* () {
+        for (const nodeUid of nodeUids) {
+            yield nodeUid;
+        }
+    }
+
+    beforeEach(() => {
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {
+            iterateSharedNodeUids: jest.fn().mockImplementation(() => nodeUidsIterator()),
+            iterateSharedWithMeNodeUids: jest.fn().mockImplementation(() => nodeUidsIterator()),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        cache = {
+            setSharedByMeNodeUids: jest.fn(),
+            setSharedWithMeNodeUids: jest.fn(),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoService = {
+            decryptInvitation: jest.fn(),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        sharesService = {
+            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: "volumeId" }),
+        }
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesService = {
+            iterateNodes: jest.fn().mockImplementation(async function* (nodeUids) {
+                for (const node of nodes) {
+                    if (nodeUids.includes(node.nodeUid)) {
+                        yield node;
+                    }
+                }
+            }),
+        }
+
+        sharingAccess = new SharingAccess(apiService, cache, cryptoService, sharesService, nodesService);
+    });
+
+    describe("iterateSharedNodes", () => {
+        it("should iterate from cache", async () => {
+            cache.getSharedByMeNodeUids = jest.fn().mockResolvedValue(nodeUids);
+
+            const result = await Array.fromAsync(sharingAccess.iterateSharedNodes());
+
+            expect(result).toEqual(nodes);
+            expect(apiService.iterateSharedNodeUids).not.toHaveBeenCalled();
+            expect(cache.setSharedByMeNodeUids).not.toHaveBeenCalled();
+        });
+
+        it("should iterate from API", async () => {
+            cache.getSharedByMeNodeUids = jest.fn().mockRejectedValue(new Error('Not cached'));
+
+            const result = await Array.fromAsync(sharingAccess.iterateSharedNodes());
+
+            expect(result).toEqual(nodes);
+            expect(apiService.iterateSharedNodeUids).toHaveBeenCalledWith("volumeId", undefined);
+            expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // 15 / 10 per batch
+            expect(cache.setSharedByMeNodeUids).toHaveBeenCalledWith(nodeUids);
+        });
+    });
+
+    describe("iterateSharedNodesWithMe", () => {
+        it("should iterate from cache", async () => {
+            cache.getSharedWithMeNodeUids = jest.fn().mockResolvedValue(nodeUids);
+
+            const result = await Array.fromAsync(sharingAccess.iterateSharedNodesWithMe());
+
+            expect(result).toEqual(nodes);
+            expect(apiService.iterateSharedWithMeNodeUids).not.toHaveBeenCalled();
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+        });
+
+        it("should iterate from API", async () => {
+            cache.getSharedWithMeNodeUids = jest.fn().mockRejectedValue(new Error('Not cached'));
+
+            const result = await Array.fromAsync(sharingAccess.iterateSharedNodesWithMe());
+
+            expect(result).toEqual(nodes);
+            expect(apiService.iterateSharedWithMeNodeUids).toHaveBeenCalledWith(undefined);
+            expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // 15 / 10 per batch
+            expect(cache.setSharedWithMeNodeUids).toHaveBeenCalledWith(nodeUids);
+        });
+    });
+});

package/src/internal/sharing/sharingAccess.ts

@@ -0,0 +1,133 @@
+import { c } from 'ttag';
+
+import { ProtonInvitationWithNode } from "../../interface";
+import { ValidationError } from "../../errors";
+import { DecryptedNode } from "../nodes";
+import { BatchLoading } from "../batchLoading";
+import { SharingAPIService } from "./apiService";
+import { SharingCache } from "./cache";
+import { SharingCryptoService } from "./cryptoService";
+import { SharesService, NodesService } from "./interface";
+
+/**
+ * Provides high-level actions for access shared nodes.
+ *
+ * The manager is responsible for listing shared by me, shared with me,
+ * invitations, bookmarks, etc., including API communication, encryption,
+ * decryption, and caching.
+ */
+export class SharingAccess {
+    constructor(
+        private apiService: SharingAPIService,
+        private cache: SharingCache,
+        private cryptoService: SharingCryptoService,
+        private sharesService: SharesService,
+        private nodesService: NodesService,
+    ) {
+        this.apiService = apiService;
+        this.cache = cache;
+        this.cryptoService = cryptoService;
+        this.sharesService = sharesService;
+        this.nodesService = nodesService;
+    }
+
+    async* iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        try {
+            const nodeUids = await this.cache.getSharedByMeNodeUids();
+            yield* this.iterateSharedNodesFromCache(nodeUids, signal);
+        } catch {
+            const { volumeId } = await this.sharesService.getMyFilesIDs();
+            const nodeUidsIterator = this.apiService.iterateSharedNodeUids(volumeId, signal);
+            yield* this.iterateSharedNodesFromAPI(nodeUidsIterator, (nodeUids) => this.cache.setSharedByMeNodeUids(nodeUids), signal);
+        }
+    }
+
+    async* iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        try {
+            const nodeUids = await this.cache.getSharedWithMeNodeUids();
+            yield* this.iterateSharedNodesFromCache(nodeUids, signal);
+        } catch {
+            const nodeUidsIterator = this.apiService.iterateSharedWithMeNodeUids(signal);
+            yield* this.iterateSharedNodesFromAPI(nodeUidsIterator, (nodeUids) => this.cache.setSharedWithMeNodeUids(nodeUids), signal);
+        }
+    }
+
+    private async* iterateSharedNodesFromCache(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal) });
+        for (const nodeUid of nodeUids) {
+            yield* batchLoading.load(nodeUid);
+        }
+        yield* batchLoading.loadRest();
+    }
+
+    private async* iterateSharedNodesFromAPI(
+        nodeUidsIterator: AsyncGenerator<string>,
+        setCache: (nodeUids: string[]) => Promise<void>,
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
+        const loadedNodeUids = [];
+        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal) });
+        for await (const nodeUid of nodeUidsIterator) {
+            loadedNodeUids.push(nodeUid);
+            yield* batchLoading.load(nodeUid);
+        }
+        yield* batchLoading.loadRest();
+        // Set cache only at the end. Once there is anything in the cache,
+        // it will be used instead of requesting the data from the API.
+        await setCache(loadedNodeUids);
+    }
+
+    private async* iterateNodesAndIgnoreMissingOnes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+        const nodeGenerator = this.nodesService.iterateNodes(nodeUids, signal);
+        for await (const node of nodeGenerator) {
+            if ('missingUid' in node) {
+                continue;
+            }
+            yield node;
+        }
+    }
+
+    async removeSharedNodeWithMe(nodeUid: string): Promise<void> {
+        const node = await this.nodesService.getNode(nodeUid);
+        if (!node.shareId) {
+            return;
+        }
+
+        const share = await this.sharesService.loadEncryptedShare(node.shareId);
+        const memberUid = share.membership?.memberUid;
+        if (!memberUid) {
+            throw new ValidationError(c('Error').t`You can leave only item that is shared with you`);
+        }
+
+        await this.apiService.removeMember(memberUid);
+    }
+
+    async* iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
+        for await (const invitationUid of this.apiService.iterateInvitationUids(signal)) {
+            const encryptedInvitation = await this.apiService.getInvitation(invitationUid);
+            const invitation = await this.cryptoService.decryptInvitationWithNode(encryptedInvitation);
+            yield invitation;
+        }
+    }
+
+    async acceptInvitation(invitationUid: string): Promise<void> {
+        const encryptedInvitation = await this.apiService.getInvitation(invitationUid);
+        const { base64SessionKeySignature } = await this.cryptoService.acceptInvitation(encryptedInvitation);
+        await this.apiService.acceptInvitation(invitationUid, base64SessionKeySignature);
+    }
+
+    async rejectInvitation(invitationUid: string): Promise<void> {
+        await this.apiService.rejectInvitation(invitationUid);
+    }
+
+    // FIXME: return decrypted bookmarks
+    async* iterateSharedBookmarks(signal?: AbortSignal): AsyncGenerator<string> {
+        for await (const bookmark of this.apiService.iterateBookmarks(signal)) {
+            yield bookmark.tokenId;
+        }
+    }
+
+    async deleteBookmark(tokenId: string): Promise<void> {
+        await this.apiService.deleteBookmark(tokenId);
+    }
+}