@protontech/drive-sdk 0.0.13 → 0.1.1

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 { getMockLogger } from '../../tests/logger';
+import { DriveEvent, DriveEventType } from '../events';
+import { SharingCache } from './cache';
+import { SharingAccess } from './sharingAccess';
+import { SharingEventHandler } from './events';
+import { SharesManager } from '../shares/manager';
 
-describe("handleSharedByMeNodes", () => {
+// 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,204 +20,109 @@ 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",
-                parentNodeUid: "parentUid",
+                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();
+        });
+
+        test('should not add if new shared node is not own', async () => {
+            const event: DriveEvent = {
+                eventId: '1',
                 type: DriveEventType.NodeCreated,
-                nodeUid: "nodeUid",
-                parentNodeUid: "parentUid",
+                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",
-                parentNodeUid: "parentUid",
+                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",
-                parentNodeUid: "parentUid",
+                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",
-                parentNodeUid: "parentUid",
+                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();
         });
     });
 });
 
-describe("handleSharedWithMeNodes", () => {
+describe('handleSharedWithMeNodes', () => {
     let cache: SharingCache;
     let sharingAccess: SharingAccess;
+    let sharesManager: SharesManager;
 
     beforeEach(() => {
         jest.clearAllMocks();
@@ -228,41 +136,23 @@ describe("handleSharedWithMeNodes", () => {
         sharingAccess = {
             iterateSharedNodesWithMe: jest.fn(),
         };
+        sharesManager = {
+            isOwnVolume: jest.fn(async (volumeId: string) => volumeId === 'MyVolume1'),
+        } as any;
     });
 
-    it("should only update cache", async () => {
+    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,55 @@
-import { NodeEventCallback, Logger } from "../../interface";
-import { convertInternalNode } from "../../transformers";
-import { DriveEventsService, 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 { Logger } from '../../interface';
+import { DriveEvent, DriveEventType } from '../events';
+import { SharingCache } from './cache';
+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 { 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 { DriveAPIService } from '../apiService';
+import { SharingAPIService } from './apiService';
+import { SharingCache } from './cache';
+import { SharingCryptoService } from './cryptoService';
+import { SharingAccess } from './sharingAccess';
+import { SharingManagement } from './sharingManagement';
+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,30 @@ 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,
     };
 }