@protontech/drive-sdk 0.0.13 → 0.1.1

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

@@ -1,16 +1,20 @@
-import { ProtonDriveEntitiesCache, ProtonDriveCryptoCache, ProtonDriveAccount, MemberRole, NodeType } from "../../interface";
-import { DriveCrypto } from "../../crypto";
-import { MemoryCache } from "../../cache";
-import { getMockTelemetry } from "../../tests/telemetry";
-import { DriveAPIService } from "../apiService";
-import { DriveEventsService, DriveListener, DriveEvent, DriveEventType } from "../events";
-import { makeNodeUid } from "../uids";
-import { SharesService, DecryptedNode } from "./interface";
+import {
+    ProtonDriveEntitiesCache,
+    ProtonDriveCryptoCache,
+    ProtonDriveAccount,
+    MemberRole,
+    NodeType,
+} from '../../interface';
+import { DriveCrypto } from '../../crypto';
+import { MemoryCache } from '../../cache';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { DriveAPIService } from '../apiService';
+import { DriveEventType } from '../events';
+import { makeNodeUid } from '../uids';
+import { SharesService, DecryptedNode } from './interface';
 import { initNodesModule } from './index';
-
-function generateSerializedNode(uid: string, parentUid = 'volumeId~root', params: Partial<DecryptedNode> = {}): string {
-    return JSON.stringify(generateNode(uid, parentUid, params));
-}
+import { NodesCache } from './cache';
+import { getMockLogger } from '../../tests/logger';
 
 function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<DecryptedNode> = {}): DecryptedNode {
     return {
@@ -18,7 +22,7 @@ function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<
         parentUid,
         directMemberRole: MemberRole.Admin,
         type: NodeType.File,
-        mediaType: "text",
+        mediaType: 'text',
         isShared: false,
         creationTime: new Date(),
         trashTime: undefined,
@@ -33,31 +37,23 @@ describe('nodesModules integration tests', () => {
     let driveCryptoCache: ProtonDriveCryptoCache;
     let account: ProtonDriveAccount;
     let driveCrypto: DriveCrypto;
-    let eventCallbacks: DriveListener[];
-    let driveEvents: DriveEventsService;
     let sharesService: SharesService;
     let nodesModule: ReturnType<typeof initNodesModule>;
+    let nodesCache: NodesCache;
 
     beforeEach(() => {
         // @ts-expect-error No need to implement all methods for mocking
-        apiService = {}
+        apiService = {};
         driveEntitiesCache = new MemoryCache();
         driveCryptoCache = new MemoryCache();
         // @ts-expect-error No need to implement all methods for mocking
-        account = {}
-        // @ts-expect-error No need to implement all methods for mocking
-        driveCrypto = {}
-        eventCallbacks = [];
+        account = {};
         // @ts-expect-error No need to implement all methods for mocking
-        driveEvents = {
-            addListener: jest.fn().mockImplementation((callback) => {
-                eventCallbacks.push(callback);
-            }),
-        }
+        driveCrypto = {};
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
             getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
-        }
+        };
 
         nodesModule = initNodesModule(
             getMockTelemetry(),
@@ -66,23 +62,23 @@ describe('nodesModules integration tests', () => {
             driveCryptoCache,
             account,
             driveCrypto,
-            driveEvents,
             sharesService,
         );
+
+        nodesCache = new NodesCache(getMockLogger(), driveEntitiesCache);
     });
 
     test('should move node from one folder to another after move event', async () => {
         // Prepare two folders (original and target) and a node in the original folder.
         const originalFolderUid = makeNodeUid('volumeId', 'originalFolder');
-        await driveEntitiesCache.setEntity(`node-${originalFolderUid}`, generateSerializedNode(originalFolderUid));
-        await driveEntitiesCache.setEntity(`node-children-${originalFolderUid}`, 'loaded');
-
         const targetFolderUid = makeNodeUid('volumeId', 'targetFolder');
-        await driveEntitiesCache.setEntity(`node-${targetFolderUid}`, generateSerializedNode(targetFolderUid));
-        await driveEntitiesCache.setEntity(`node-children-${targetFolderUid}`, 'loaded');
-
         const nodeUid = makeNodeUid('volumeId', 'node1');
-        await driveEntitiesCache.setEntity(`node-${nodeUid}`, generateSerializedNode(nodeUid, originalFolderUid), [`nodeParentUid:${originalFolderUid}`]);
+
+        await nodesCache.setNode(generateNode(originalFolderUid));
+        await nodesCache.setFolderChildrenLoaded(originalFolderUid);
+        await nodesCache.setNode(generateNode(targetFolderUid));
+        await nodesCache.setFolderChildrenLoaded(targetFolderUid);
+        await nodesCache.setNode(generateNode(nodeUid, originalFolderUid));
 
         // Mock the API services to return the moved node.
         // This is called when listing the children of the target folder after
@@ -90,17 +86,19 @@ describe('nodesModules integration tests', () => {
         apiService.post = jest.fn().mockImplementation(async (url, body) => {
             expect(url).toBe(`drive/v2/volumes/volumeId/links`);
             return {
-                Links: [{
-                    Link: {
-                        LinkID: 'node1',
-                        ParentLinkID: 'targetFolder',
-                        NameHash: 'hash',
-                        Type: 2,
+                Links: [
+                    {
+                        Link: {
+                            LinkID: 'node1',
+                            ParentLinkID: 'targetFolder',
+                            NameHash: 'hash',
+                            Type: 2,
+                        },
+                        File: {
+                            ActiveRevision: {},
+                        },
                     },
-                    File: {
-                        ActiveRevision: {},
-                    },
-                }],
+                ],
             };
         });
         jest.spyOn(nodesModule.access, 'getParentKeys').mockResolvedValue({ key: { _idx: 32131 } } as any);
@@ -113,17 +111,15 @@ describe('nodesModules integration tests', () => {
         expect(targetBeforeMove).toMatchObject([]);
 
         // Send the move event that updates the cache.
-        const events: DriveEvent[] = [
-            {
-                type: DriveEventType.NodeUpdated,
-                nodeUid,
-                parentNodeUid: targetFolderUid,
-                isTrashed: false,
-                isShared: false,
-                isOwnVolume: true,
-            },
-        ]
-        await Promise.all(eventCallbacks.map((callback) => callback(events)));
+        await nodesModule.eventHandler.updateNodesCacheOnEvent({
+            type: DriveEventType.NodeUpdated,
+            nodeUid,
+            parentNodeUid: targetFolderUid,
+            isTrashed: false,
+            isShared: false,
+            treeEventScopeId: 'volumeId',
+            eventId: '1',
+        });
 
         // Verify the state after the move event, including when API service is called.
         const originalAfterMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(originalFolderUid));

package/src/internal/nodes/index.ts

@@ -1,26 +1,30 @@
-import { DriveAPIService } from "../apiService";
-import { DriveCrypto } from "../../crypto";
-import { DriveEventsService } from "../events";
-import { ProtonDriveEntitiesCache, ProtonDriveCryptoCache, ProtonDriveAccount, ProtonDriveTelemetry } from "../../interface";
-import { NodeAPIService } from "./apiService";
-import { NodesCache } from "./cache";
-import { NodesEvents } from "./events";
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
-import { SharesService } from "./interface";
-import { NodesAccess } from "./nodesAccess";
-import { NodesManagement } from "./nodesManagement";
-import { NodesRevisons } from "./nodesRevisions";
+import { DriveAPIService } from '../apiService';
+import { DriveCrypto } from '../../crypto';
+import {
+    ProtonDriveEntitiesCache,
+    ProtonDriveCryptoCache,
+    ProtonDriveAccount,
+    ProtonDriveTelemetry,
+} from '../../interface';
+import { NodeAPIService } from './apiService';
+import { NodesCache } from './cache';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
+import { SharesService } from './interface';
+import { NodesAccess } from './nodesAccess';
+import { NodesManagement } from './nodesManagement';
+import { NodesRevisons } from './nodesRevisions';
+import { NodesEventsHandler } from './events';
 
-export type { DecryptedNode, DecryptedRevision } from "./interface";
-export { generateFileExtendedAttributes } from "./extendedAttributes";
+export type { DecryptedNode, DecryptedRevision } from './interface';
+export { generateFileExtendedAttributes } from './extendedAttributes';
 
 /**
  * Provides facade for the whole nodes module.
- * 
+ *
  * The nodes module is responsible for handling node metadata, including
  * API communication, encryption, decryption, caching, and event handling.
- * 
+ *
  * This facade provides internal interface that other modules can use to
  * interact with the nodes.
  */
@@ -31,22 +35,28 @@ export function initNodesModule(
     driveCryptoCache: ProtonDriveCryptoCache,
     account: ProtonDriveAccount,
     driveCrypto: DriveCrypto,
-    driveEvents: DriveEventsService,
     sharesService: SharesService,
 ) {
     const api = new NodeAPIService(telemetry.getLogger('nodes-api'), apiService);
     const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
     const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, sharesService);
-    const nodesAccess = new NodesAccess(telemetry.getLogger('nodes'), api, cache, cryptoCache, cryptoService, sharesService);
-    const nodesEvents = new NodesEvents(telemetry.getLogger('nodes-events'), driveEvents, cache, nodesAccess);
-    const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess, nodesEvents);
+    const nodesAccess = new NodesAccess(
+        telemetry.getLogger('nodes'),
+        api,
+        cache,
+        cryptoCache,
+        cryptoService,
+        sharesService,
+    );
+    const nodesEventHandler = new NodesEventsHandler(telemetry.getLogger('nodes-events'), cache);
+    const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess);
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
 
     return {
         access: nodesAccess,
         management: nodesManagement,
         revisions: nodesRevisions,
-        events: nodesEvents,
+        eventHandler: nodesEventHandler,
     };
 }

package/src/internal/nodes/interface.ts

@@ -1,5 +1,16 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { NodeEntity, Result, InvalidNameError, Author, MemberRole, NodeType, ThumbnailType, MetricVolumeType, Revision, RevisionState } from "../../interface";
+import { PrivateKey, SessionKey } from '../../crypto';
+import {
+    NodeEntity,
+    Result,
+    InvalidNameError,
+    Author,
+    MemberRole,
+    NodeType,
+    ThumbnailType,
+    MetricVolumeType,
+    Revision,
+    RevisionState,
+} from '../../interface';
 
 /**
  * Internal common node interface for both encrypted or decrypted node.
@@ -20,13 +31,13 @@ interface BaseNode {
 
     // Share node metadata
     shareId?: string;
-    isShared: boolean,
-    directMemberRole: MemberRole,
+    isShared: boolean;
+    directMemberRole: MemberRole;
 }
 
 /**
  * Interface used only internaly in the nodes module.
- * 
+ *
  * Outside of the module, the decrypted node interface should be used.
  */
 export interface EncryptedNode extends BaseNode {
@@ -68,35 +79,37 @@ export interface EncryptedNodeAlbumCrypto extends EncryptedNodeCrypto {}
  * such as extended attributes.
  */
 export interface DecryptedUnparsedNode extends BaseNode {
-    keyAuthor: Author,
-    nameAuthor: Author,
-    name: Result<string, Error>,
-    activeRevision?: Result<DecryptedUnparsedRevision, Error>,
+    keyAuthor: Author;
+    nameAuthor: Author;
+    name: Result<string, Error>;
+    activeRevision?: Result<DecryptedUnparsedRevision, Error>;
     folder?: {
-        extendedAttributes?: string,
-    },
-    errors?: unknown[],
+        extendedAttributes?: string;
+    };
+    errors?: unknown[];
 }
 
 /**
  * Interface holding decrypted node metadata.
  */
-export interface DecryptedNode extends Omit<DecryptedUnparsedNode, 'name' | 'activeRevision' | 'folder'>, Omit<NodeEntity, 'name' | 'activeRevision'> {
+export interface DecryptedNode
+    extends Omit<DecryptedUnparsedNode, 'name' | 'activeRevision' | 'folder'>,
+        Omit<NodeEntity, 'name' | 'activeRevision'> {
     // Internal metadata
     isStale: boolean;
-    name: Result<string, Error | InvalidNameError>,
+    name: Result<string, Error | InvalidNameError>;
 
-    activeRevision?: Result<DecryptedRevision, Error>,
+    activeRevision?: Result<DecryptedRevision, Error>;
     folder?: {
-        claimedModificationTime?: Date,
-    },
+        claimedModificationTime?: Date;
+    };
 }
 
 /**
  * Interface holding decrypted node key, including session key, and hash key.
  *
  * These keys are cached as they are needed for various actions on the node.
- * 
+ *
  * Passphrase, for example, might be removed at some point. It is needed as
  * at this moment the move requires both node key passphrase and the session
  * key.
@@ -120,7 +133,7 @@ interface BaseRevision {
 export type Thumbnail = {
     uid: string;
     type: ThumbnailType;
-}
+};
 
 export interface EncryptedRevision extends BaseRevision {
     signatureEmail?: string;
@@ -128,8 +141,8 @@ export interface EncryptedRevision extends BaseRevision {
 }
 
 export interface DecryptedUnparsedRevision extends BaseRevision {
-    contentAuthor: Author,
-    extendedAttributes?: string,
+    contentAuthor: Author;
+    extendedAttributes?: string;
 }
 
 export interface DecryptedRevision extends Revision {
@@ -140,16 +153,16 @@ export interface DecryptedRevision extends Revision {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string, rootNodeId: string }>,
-    getSharePrivateKey(shareId: string): Promise<PrivateKey>,
+    getMyFilesIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
-        email: string,
-    }>,
+        email: string;
+    }>;
     getContextShareMemberEmailKey(shareId: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
-    }>,
-    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }>;
+    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
 }