@protontech/drive-sdk 0.0.12 → 0.1.0

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

@@ -1,13 +1,16 @@
 import { getMockLogger } from "../../tests/logger";
 import { DriveEvent, DriveEventType } from "../events";
-import { NodesService, SharingType } from "./interface";
 import { SharingCache } from "./cache";
-import { handleSharedByMeNodes, handleSharedWithMeNodes } from "./events";
 import { SharingAccess } from "./sharingAccess";
+import { SharingEventHandler } from "./events";
+import { SharesManager } from "../shares/manager";
+
+// FIXME: test tree_refresh and tree_remove
 
 describe("handleSharedByMeNodes", () => {
     let cache: SharingCache;
-    let nodesService: NodesService;
+    let sharingEventHandler: SharingEventHandler;
+    let sharesManager: SharesManager;
 
     beforeEach(() => {
         jest.clearAllMocks();
@@ -17,197 +20,105 @@ describe("handleSharedByMeNodes", () => {
             addSharedByMeNodeUid: jest.fn(),
             removeSharedByMeNodeUid: jest.fn(),
             setSharedWithMeNodeUids: jest.fn(),
+            getSharedByMeNodeUids: jest.fn().mockResolvedValue(["cachedNodeUid"]),
         };
-        // @ts-expect-error No need to implement all methods for mocking
-        nodesService = {
-            getNode: jest.fn().mockResolvedValue({ uid: 'nodeUid', name: { ok: true, value: 'name' } }),
-        };
+        sharesManager = {
+            isOwnVolume: jest.fn(async (volumeId: string) => volumeId === 'MyVolume1'),
+        } as any;
+        sharingEventHandler = new SharingEventHandler(getMockLogger(), cache, sharesManager);
     });
 
-    const testCases: { 
-        title: string,
-        existingNodeUids: string[],
-        event: DriveEvent,
-        added: boolean,
-        removed: boolean,
-    }[] = [
-        {
-            title: "should add if new own shared node is created",
-            existingNodeUids: [],
-            event: {
+    describe("node events trigger cache update", () => {
+
+        it("should add if new own shared node is created", async () => {
+            const event: DriveEvent = {
+                eventId: "1",
                 type: DriveEventType.NodeCreated,
-                nodeUid: "nodeUid",
+                nodeUid: "newNodeUid",
                 parentNodeUid: "parentUid",
                 isTrashed: false,
                 isShared: true,
-                isOwnVolume: true,
-            },
-            added: true,
-            removed: false,
-        },
-        {
-            title: "should not add if new shared node is not own",
-            existingNodeUids: [],
-            event: {
+                treeEventScopeId: "MyVolume1",
+            };
+            await sharingEventHandler.handleDriveEvent(event);
+            expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith("newNodeUid");
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+
+        });
+
+        // FIXME enable when volume ownership is handled
+        test.skip("should not add if new shared node is not own", async () => {
+            const event: DriveEvent = {
+                eventId: "1",
                 type: DriveEventType.NodeCreated,
-                nodeUid: "nodeUid",
+                nodeUid: "newNodeUid",
                 parentNodeUid: "parentUid",
                 isTrashed: false,
                 isShared: true,
-                isOwnVolume: false,
-            },
-            added: false,
-            removed: false,
-        },
-        {
-            title: "should not add if new own node is not shared",
-            existingNodeUids: [],
-            event: {
+                treeEventScopeId: "NotOwnVolume",
+            };
+            await sharingEventHandler.handleDriveEvent(event);
+            expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+
+        });
+
+        it("should not add if new own node is not shared", async () => {
+            const event: DriveEvent = {
                 type: DriveEventType.NodeCreated,
-                nodeUid: "nodeUid",
+                nodeUid: "newNodeUid",
                 parentNodeUid: "parentUid",
                 isTrashed: false,
                 isShared: false,
-                isOwnVolume: true,
-            },
-            added: false,
-            removed: false,
-        },
-        {
-            title: "should add if own node is updated and shared",
-            existingNodeUids: [],
-            event: {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isTrashed: false,
-                isShared: true,
-                isOwnVolume: true,
-            },
-            added: true,
-            removed: false,
-        },
-        {
-            title: "should add/update if shared node is updated",
-            existingNodeUids: ["nodeUid"],
-            event: {
+                eventId: "1",
+                treeEventScopeId: "MyVolume1",
+            };
+            await sharingEventHandler.handleDriveEvent(event);
+            expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+        });
+
+        it("should add if own node is updated and shared", async () => {
+            const event: DriveEvent = {
                 type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
+                nodeUid: "cachedNodeUid",
                 parentNodeUid: "parentUid",
                 isTrashed: false,
                 isShared: true,
-                isOwnVolume: true,
-            },
-            added: true,
-            removed: false,
-        },
-        {
-            title: "should remove if shared node is un-shared",
-            existingNodeUids: ["nodeUid"],
-            event: {
-                type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isTrashed: false,
-                isShared: false,
-                isOwnVolume: true,
-            },
-            added: false,
-            removed: true,
-        },
-        {
-            title: "should not remove if non-shared node is updated",
-            existingNodeUids: [],
-            event: {
+                eventId: "1",
+                treeEventScopeId: "MyVolume1",
+            };
+            await sharingEventHandler.handleDriveEvent(event);
+            expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith("cachedNodeUid");
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
+        });
+
+        it("should remove if shared node is un-shared", async () => {
+            const event: DriveEvent = {
                 type: DriveEventType.NodeUpdated,
-                nodeUid: "nodeUid",
+                nodeUid: "cachedNodeUid",
                 parentNodeUid: "parentUid",
                 isTrashed: false,
                 isShared: false,
-                isOwnVolume: true,
-            },
-            added: false,
-            removed: false,
-        },
-        {
-            title: "should remove if shared node is deleted",
-            existingNodeUids: ["nodeUid"],
-            event: {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isOwnVolume: true,
-            },
-            added: false,
-            removed: true,
-        },
-        {
-            title: "should not remove if non-shared node is deleted",
-            existingNodeUids: [],
-            event: {
-                type: DriveEventType.NodeDeleted,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
-                isOwnVolume: true,
-            },
-            added: false,
-            removed: false,
-        },
-    ];
-
-    describe("with listeners", () => {
-        testCases.map(({ title, existingNodeUids, event, added, removed }) => {
-            it(title, async () => {
-                cache.getSharedByMeNodeUids = jest.fn().mockResolvedValue(existingNodeUids);
-                const listener = jest.fn();
-                const listeners = [{ type: SharingType.SharedByMe, callback: listener }];
-
-                await handleSharedByMeNodes(getMockLogger(), event, cache, listeners, nodesService);
-    
-                if (added) {
-                    expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith("nodeUid");
-                    expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'update', uid: 'nodeUid' }));
-                } else {
-                    expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
-                }
-                if (removed) {
-                    expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith("nodeUid");
-                    expect(listener).toHaveBeenCalledWith({ type: 'remove', uid: 'nodeUid' });
-                } else {
-                    expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
-                }
-                if (!added && !removed) {
-                    expect(listener).not.toHaveBeenCalled();
-                }
- 
-                expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-            });
+                eventId: "1",
+                treeEventScopeId: "MyVolume1",
+            };
+            await sharingEventHandler.handleDriveEvent(event);
+            expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith("cachedNodeUid");
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
         });
-    });
-
-    describe("without listeners", () => {
-        testCases.map(({ title, existingNodeUids, event, added, removed }) => {
-            it(title, async () => {
-                cache.getSharedByMeNodeUids = jest.fn().mockResolvedValue(existingNodeUids);
-                const listener = jest.fn();
-                const listeners = [{ type: SharingType.sharedWithMe, callback: listener }];
-
-                await handleSharedByMeNodes(getMockLogger(), event, cache, listeners, nodesService);
-    
-                if (added) {
-                    expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith("nodeUid");
-                } else {
-                    expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
-                }
-                if (removed) {
-                    expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith("nodeUid");
-                } else {
-                    expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
-                }
 
-                expect(listener).not.toHaveBeenCalled();
-                expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
-            });
+        it("should remove if shared node is deleted", async () => {
+            const event: DriveEvent = {
+                type: DriveEventType.NodeDeleted,
+                nodeUid: "cachedNodeUid",
+                parentNodeUid: "parentUid",
+                eventId: "1",
+                treeEventScopeId: "MyVolume1",
+            };
+            await sharingEventHandler.handleDriveEvent(event);
+            expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith("cachedNodeUid");
+            expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
         });
     });
 });
@@ -215,6 +126,7 @@ describe("handleSharedByMeNodes", () => {
 describe("handleSharedWithMeNodes", () => {
     let cache: SharingCache;
     let sharingAccess: SharingAccess;
+    let sharesManager: SharesManager;
 
     beforeEach(() => {
         jest.clearAllMocks();
@@ -228,41 +140,23 @@ describe("handleSharedWithMeNodes", () => {
         sharingAccess = {
             iterateSharedNodesWithMe: jest.fn(),
         };
+        sharesManager = {
+            isOwnVolume: jest.fn(async (volumeId: string) => volumeId === 'MyVolume1'),
+        } as any;
     });
 
     it("should only update cache", async () => {
         const event: DriveEvent = {
-            type: DriveEventType.ShareWithMeUpdated,
+            type: DriveEventType.SharedWithMeUpdated,
+            eventId: 'event1',
+            treeEventScopeId: 'core',
         };
 
-        await handleSharedWithMeNodes(event, cache, [], sharingAccess);
+        const sharingEventHandler = new SharingEventHandler(getMockLogger(), cache, sharesManager);
+        await sharingEventHandler.handleDriveEvent(event);
 
         expect(cache.setSharedWithMeNodeUids).toHaveBeenCalledWith(undefined);
         expect(cache.getSharedWithMeNodeUids).not.toHaveBeenCalled();
         expect(sharingAccess.iterateSharedNodesWithMe).not.toHaveBeenCalled();
     });
-
-    it("should update cache and notify listener", async () => {
-        cache.getSharedWithMeNodeUids = jest.fn().mockResolvedValue(["nodeUid1", "nodeUid4"]);
-        sharingAccess.iterateSharedNodesWithMe = jest.fn().mockImplementation(async function* () {
-            yield { uid: "nodeUid1", name: { ok: true, value: "name1" } };
-            yield { uid: "nodeUid2", name: { ok: true, value: "name2" } };
-            yield { uid: "nodeUid3", name: { ok: true, value: "name3" } };
-        });
-        const listener = jest.fn();
-        const event: DriveEvent = {
-            type: DriveEventType.ShareWithMeUpdated,
-        };
-
-        await handleSharedWithMeNodes(event, cache, [{ type: SharingType.sharedWithMe, callback: listener }], sharingAccess);
-
-        expect(cache.setSharedWithMeNodeUids).toHaveBeenCalledWith(undefined);
-        expect(cache.getSharedWithMeNodeUids).toHaveBeenCalled();
-        expect(sharingAccess.iterateSharedNodesWithMe).toHaveBeenCalled();
-        expect(listener).toHaveBeenCalledTimes(4);
-        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'update', uid: 'nodeUid1' }));
-        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'update', uid: 'nodeUid2' }));
-        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ type: 'update', uid: 'nodeUid3' }));
-        expect(listener).toHaveBeenCalledWith({ type: 'remove', uid: 'nodeUid4' });
-    });
 });

package/src/internal/sharing/events.ts

@@ -1,166 +1,52 @@
-import { NodeEventCallback, Logger } from "../../interface";
-import { convertInternalNode } from "../../transformers";
-import { DriveEventsService, DriveEvent, DriveEventType } from "../events";
+import { Logger } from "../../interface";
+import { DriveEvent, DriveEventType } from "../events";
 import { SharingCache } from "./cache";
-import { SharingType, NodesService } from "./interface";
-import { SharingAccess } from "./sharingAccess";
-
-type Listeners = {
-    type: SharingType,
-    callback: NodeEventCallback,
-}[];
-
-/**
- * Provides both event handling and subscription mechanism for user.
- * 
- * The service is responsible for handling events regarding sharing listing
- * from the DriveEventsService, and for providing a subscription mechanism
- * for the user to listen to updates of specific group of nodes, such as
- * any update to list of shared with me nodes.
- */
-export class SharingEvents {
-    private listeners: Listeners = [];
-
-    constructor(logger: Logger, events: DriveEventsService, cache: SharingCache, nodesService: NodesService, sharingAccess: SharingAccess) {
-        events.addListener(async (events, fullRefreshVolumeId) => {
-            // Technically we need to refresh only the shared by me nodes for
-            // own volume, and shared with me nodes only when the event comes
-            // as core refresh event is converted to it.
-            // We can optimise later, for now we refresh everything to make
-            // it simpler. The cache is smart enough to not do unnecessary
-            // requests to the API and refresh on web is rare without
-            // persistant cache for now.
-            if (fullRefreshVolumeId) {
-                await cache.setSharedByMeNodeUids(undefined);
-                await cache.setSharedWithMeNodeUids(undefined);
-                return
+import { SharesService } from "./interface";
+
+export class SharingEventHandler {
+    constructor(private logger: Logger, private cache: SharingCache, private shares: SharesService) {
+    };
+
+    /**
+     * Update cache and notify listeners accordingly for any updates
+     * to nodes that are shared by me.
+     *
+     * Any node create or update that is being shared, is automatically
+     * added to the cache and the listeners are notified about the
+     * update of the node.
+     *
+     * Any node delete or update that is not being shared, and the cache
+     * includes the node, is removed from the cache and the listeners are
+     * notified about the removal of the node.
+     *
+     * @throws Only if the client's callback throws.
+     */
+    async handleDriveEvent(event: DriveEvent) {
+        try {
+            if (event.type === DriveEventType.SharedWithMeUpdated) {
+                await this.cache.setSharedWithMeNodeUids(undefined);
+                return;
             }
-
-            for (const event of events) {
-                await handleSharedByMeNodes(logger, event, cache, this.listeners, nodesService);
-                await handleSharedWithMeNodes(event, cache, this.listeners, sharingAccess);
+            if (!(await this.shares.isOwnVolume(event.treeEventScopeId))) {
+                return;
             }
-        });
-    }
-
-    subscribeToSharedNodesByMe(callback: NodeEventCallback) {
-        this.listeners.push({ type: SharingType.SharedByMe, callback });
-        return () => {
-            this.listeners = this.listeners.filter(listener => listener.callback !== callback);
-        }
-    }
-
-    subscribeToSharedNodesWithMe(callback: NodeEventCallback) {
-        this.listeners.push({ type: SharingType.sharedWithMe, callback });
-        return () => {
-            this.listeners = this.listeners.filter(listener => listener.callback !== callback);
-        }
-    }
-}
-
-/**
- * Update cache and notify listeners accordingly for any updates
- * to nodes that are shared by me.
- *
- * Any node create or update that is being shared, is automatically
- * added to the cache and the listeners are notified about the
- * update of the node.
- *
- * Any node delete or update that is not being shared, and the cache
- * includes the node, is removed from the cache and the listeners are
- * notified about the removal of the node.
- *
- * @throws Only if the client's callback throws.
- */
-export async function handleSharedByMeNodes(logger: Logger, event: DriveEvent, cache: SharingCache, listeners: Listeners, nodesService: NodesService) {
-    if (event.type === DriveEventType.ShareWithMeUpdated || !event.isOwnVolume) {
-        return;
-    }
-
-    const subscribedListeners = listeners.filter(({ type }) => type === SharingType.SharedByMe);
-
-    if ([DriveEventType.NodeCreated, DriveEventType.NodeUpdated, DriveEventType.NodeUpdatedMetadata].includes(event.type) && event.isShared) {
-        try {
-            await cache.addSharedByMeNodeUid(event.nodeUid);
-        } catch (error: unknown) {
-            logger.error(`Skipping shared by me node cache update`, error);
-        }
-        if (subscribedListeners.length) {
-            let node;
-            try {
-                node = await nodesService.getNode(event.nodeUid);
-            } catch (error: unknown) {
-                logger.error(`Skipping shared by me node update event to listener`, error);
+            if (event.type === DriveEventType.NodeCreated || event.type == DriveEventType.NodeUpdated) {
+                if (event.isShared && !event.isTrashed) {
+                    await this.cache.addSharedByMeNodeUid(event.nodeUid);
+                } else {
+                    await this.cache.removeSharedByMeNodeUid(event.nodeUid);
+                }
                 return;
             }
-            subscribedListeners.forEach(({ callback }) => callback({ type: 'update', uid: node.uid, node: convertInternalNode(node) }));
-        }
-    }
-
-    if (
-        ((event.type === DriveEventType.NodeUpdated || event.type === DriveEventType.NodeUpdatedMetadata) && !event.isShared)
-        || event.type === DriveEventType.NodeDeleted
-    ) {
-        let nodeWasShared = false;
-        try {
-            const cachedNodeUids = await cache.getSharedByMeNodeUids();
-            nodeWasShared = cachedNodeUids.includes(event.nodeUid);
-        } catch {
-            // Cache can be empty.
-        }
-
-        if (nodeWasShared) {
-            try {
-                await cache.removeSharedByMeNodeUid(event.nodeUid);
-            } catch (error: unknown) {
-                logger.error(`Skipping shared by me node cache remove`, error);
+            if (event.type === DriveEventType.NodeDeleted) {
+                await this.cache.removeSharedByMeNodeUid(event.nodeUid);
+                return;
             }
-            subscribedListeners.forEach(({ callback }) => callback({ type: 'remove', uid: event.nodeUid }));
-        }
-    }
-}
-
-/**
- * Update cache and notify listeners accordingly for any updates
- * to nodes that are shared with me.
- *
- * There is only one event type that is relevant for shared with me
- * nodes, which is the ShareWithMeUpdated event. The event is triggered
- * when the list of shared with me nodes is updated.
- * 
- * The cache is cleared and re-populated fully when the client
- * requests the list of shared with me, or is actively listening.
- * 
- * If the client listenes to shared with me updates, the client receives
- * update to the full list of shared with me nodes, including remove
- * updates for nodes that are no longer shared with me, but was before.
- *
- * @throws Only if the client's callback throws.
- */
-export async function handleSharedWithMeNodes(event: DriveEvent, cache: SharingCache, listeners: Listeners, sharingAccess: SharingAccess) {
-    if (event.type !== DriveEventType.ShareWithMeUpdated) {
-        return;
-    }
-
-    let cachedNodeUids: string[] = [];
-    const subscribedListeners = listeners.filter(({ type }) => type === SharingType.sharedWithMe);
-    if (subscribedListeners.length) {
-        cachedNodeUids = await cache.getSharedWithMeNodeUids();
-    }
-
-    // Clearing the cache must be first, sharingAccess is no-op if cache is set.
-    await cache.setSharedWithMeNodeUids(undefined);
-
-    if (subscribedListeners.length) {
-        const nodeUids = [];
-        for await (const node of sharingAccess.iterateSharedNodesWithMe()) {
-            nodeUids.push(node.uid);
-            subscribedListeners.forEach(({ callback }) => callback({ type: 'update', uid: node.uid, node: convertInternalNode(node) }));
-        }
-        for (const nodeUid of cachedNodeUids) {
-            if (!nodeUids.includes(nodeUid)) {
-                subscribedListeners.forEach(({ callback }) => callback({ type: 'remove', uid: nodeUid }));
+            if (event.type === DriveEventType.TreeRefresh || event.type === DriveEventType.TreeRemove) {
+                await this.cache.setSharedWithMeNodeUids(undefined);
             }
+        } catch (error: unknown) {
+            this.logger.error(`Skipping shared by me node cache update`, error);
         }
     }
 }

package/src/internal/sharing/index.ts

@@ -1,18 +1,17 @@
 import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from "../../interface";
 import { DriveCrypto } from '../../crypto';
 import { DriveAPIService } from "../apiService";
-import { DriveEventsService } from "../events";
 import { SharingAPIService } from "./apiService";
 import { SharingCache } from "./cache";
 import { SharingCryptoService } from "./cryptoService";
-import { SharingEvents } from "./events";
 import { SharingAccess } from "./sharingAccess";
 import { SharingManagement } from "./sharingManagement";
-import { SharesService, NodesService, NodesEvents } from "./interface";
+import { SharesService, NodesService } from "./interface";
+import { SharingEventHandler } from "./events";
 
 /**
  * Provides facade for the whole sharing module.
- * 
+ *
  * The sharing module is responsible for handling invitations, bookmarks,
  * standard shares, listing shared nodes, etc. It includes API communication,
  * encryption, decryption, caching, and event handling.
@@ -23,21 +22,19 @@ export function initSharingModule(
     driveEntitiesCache: ProtonDriveEntitiesCache,
     account: ProtonDriveAccount,
     crypto: DriveCrypto,
-    driveEvents: DriveEventsService,
     sharesService: SharesService,
     nodesService: NodesService,
-    nodesEvents: NodesEvents,
 ) {
     const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService);
     const cache = new SharingCache(driveEntitiesCache);
     const cryptoService = new SharingCryptoService(telemetry, crypto, account, sharesService);
     const sharingAccess = new SharingAccess(api, cache, cryptoService, sharesService, nodesService);
-    const sharingEvents = new SharingEvents(telemetry.getLogger('sharing-events'), driveEvents, cache, nodesService, sharingAccess);
-    const sharingManagement = new SharingManagement(telemetry.getLogger('sharing'), api, cryptoService, account, sharesService, nodesService, nodesEvents);
+    const sharingManagement = new SharingManagement(telemetry.getLogger('sharing'), api, cryptoService, account, sharesService, nodesService);
+    const sharingEventHandler = new SharingEventHandler(telemetry.getLogger('sharing-event-handler'), cache, sharesService);
 
     return {
         access: sharingAccess,
-        events: sharingEvents,
+        eventHandler: sharingEventHandler,
         management: sharingManagement,
     };
 }

package/src/internal/sharing/interface.ts

@@ -21,7 +21,7 @@ export interface EncryptedInvitationRequest {
 
 /**
  * Internal interface of existing invitation on the API.
- * 
+ *
  * This interface is used only for managing the invitations. For listing
  * invitations with node metadata, see `EncryptedInvitationWithNode`.
  */
@@ -32,7 +32,7 @@ export interface EncryptedInvitation extends EncryptedInvitationRequest {
 
 /**
  * Internal interface of existing invitation with the share and node metadata.
- * 
+ *
  * Invitation with node is used for listing shared nodes with me, so it includes
  * what is being shared as well.
  */
@@ -116,6 +116,7 @@ export interface EncryptedPublicLink {
     flags: number,
     creatorEmail: string,
     publicUrl: string,
+    numberOfInitializedDownloads: number;
     armoredUrlPassword: string,
     urlPasswordSalt: string,
     base64SharePassphraseKeyPacket: string,
@@ -152,6 +153,7 @@ export interface SharesService {
         addressId: string,
         addressKey: PrivateKey,
     }>,
+    isOwnVolume(volumeId: string): Promise<boolean>;
 }
 
 /**
@@ -171,8 +173,10 @@ export interface NodesService {
         addressKey: PrivateKey,
     }>,
     iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
+    notifyNodeChanged(nodeUid: string): Promise<void>;
 }
 
+// TODO I think this can be removed
 /**
  * Interface describing the dependencies to the nodes module.
  */