@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/nodes/events.ts

@@ -1,271 +1,65 @@
-import { Logger, NodeEventCallback } from "../../interface";
-import { convertInternalNode } from "../../transformers";
-import { DriveEventsService, DriveEvent, DriveEventType } from "../events";
-import { DecryptedNode } from "./interface";
-import { NodesCache } from "./cache";
-import { NodesAccess } from "./nodesAccess";
-
-type Listeners = {
-    /**
-     * Condition for the listener to be notified about the event.
-     * 
-     * The condition is a function that receives the event information
-     * and returns true if the listener should be notified about the
-     * event.
-     */
-    condition: (nodeEventInfo: NodeEventInfo) => boolean,
-    callback: NodeEventCallback,
-}[];
-
-/**
- * Minimal information about the event that is used for listener
- * condition. The information is used to determine if the listener
- * should be notified about the event.
- * 
- * This must come from the API response to volume events.
- */
-type NodeEventInfo = {
-    parentNodeUid?: string,
-    isTrashed?: boolean,
-}
+import { Logger } from '../../interface';
+import { DriveEvent, DriveEventType } from '../events';
+import { NodesCache } from './cache';
 
 /**
- * Provides both event handling and subscription mechanism for user.
- * 
+ * Provides internal event handling.
+ *
  * The service is responsible for handling events regarding node metadata
- * 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 for trashed nodes.
+ * from the DriveEventsService.
  */
-export class NodesEvents {
-    private listeners: Listeners = [];
+export class NodesEventsHandler {
+    constructor(
+        private logger: Logger,
+        private cache: NodesCache,
+    ) {}
 
-    constructor(private logger: Logger, events: DriveEventsService, private cache: NodesCache, private nodesAccess: NodesAccess) {
-        this.logger = logger;
-        this.cache = cache;
-        this.nodesAccess = nodesAccess;
-
-        events.addListener(async (events, fullRefreshVolumeId) => {
-            if (fullRefreshVolumeId) {
-                await cache.setNodesStaleFromVolume(fullRefreshVolumeId);
+    async updateNodesCacheOnEvent(event: DriveEvent): Promise<void> {
+        try {
+            if (event.type === DriveEventType.TreeRefresh) {
+                await this.cache.setNodesStaleFromVolume(event.treeEventScopeId);
                 return;
             }
-
-            for (const event of events) {
-                try {
-                    await updateCacheByEvent(logger, event, cache);
-                } catch (error: unknown) {
-                    logger.error(`Failed to update cache`, error);
-                }
-                try {
-                    await notifyListenersByEvent(logger, event, this.listeners, cache, nodesAccess);
-                } catch (error: unknown) {
-                    logger.error(`Failed to notifiy listeners`, error);
-                }
-                // Delete must come last as it will remove the node from the cache
-                // and we need to first know local status of the node to properly
-                // notify the listeners.
-                await deleteFromCacheByEvent(logger, event, cache);
+            if (event.type === DriveEventType.TreeRemove) {
+                await this.cache.removeVolume(event.treeEventScopeId);
+                return;
             }
-        });
-    }
-
-    subscribeToTrashedNodes(callback: NodeEventCallback) {
-        this.listeners.push({ condition: ({ isTrashed }) => isTrashed || false, callback });
-        return () => {
-            this.listeners = this.listeners.filter(listener => listener.callback !== callback);
-        }
-    }
-
-    subscribeToChildren(parentNodeUid: string, callback: NodeEventCallback) {
-        this.listeners.push({ condition: ({ parentNodeUid: parent }) => parent === parentNodeUid, callback });
-        return () => {
-            this.listeners = this.listeners.filter(listener => listener.callback !== callback);
-        }
-    }
-
-    async nodeCreated(node: DecryptedNode): Promise<void> {
-        await this.cache.setNode(node);
-        void this.notifyListenersByNode(node, DriveEventType.NodeCreated);
-    }
-
-    async nodeUpdated(partialNode: { uid: string } & Partial<DecryptedNode>): Promise<void> {
-        const originalNode = await this.cache.getNode(partialNode.uid);
-        const updatedNode = {
-            ...originalNode,
-            ...partialNode,
-        }
-
-        await this.cache.setNode(updatedNode);
-        void this.notifyListenersByNode(updatedNode, DriveEventType.NodeUpdated);
-    }
-
-    async nodesDeleted(nodeUids: string[]): Promise<void> {
-        try {
-            for await (const originalNode of this.cache.iterateNodes(nodeUids)) {
-                if (originalNode.ok) {
-                    void this.notifyListenersByNode(originalNode.node, DriveEventType.NodeDeleted);
+            if (event.type === DriveEventType.NodeDeleted) {
+                await this.cache.removeNodes([event.nodeUid]);
+                return;
+            }
+            if (event.type === DriveEventType.NodeCreated) {
+                // FIXME Add it to the parent listing even if it's not cached
+                // so it doesn't need to refetch all children
+
+                // We do not have partial nodes in the cache, so we don't
+                // add it. If new node is not added, we need to reset the
+                // children loaded flag to force refetch when requested.
+                if (event.parentNodeUid) {
+                    await this.cache.resetFolderChildrenLoaded(event.parentNodeUid);
                 }
+                return;
             }
-        } catch {}
-
-        await this.cache.removeNodes(nodeUids);
-    }
-
-    private async notifyListenersByNode(node: DecryptedNode, eventType: DriveEventType.NodeCreated | DriveEventType.NodeUpdated | DriveEventType.NodeDeleted) {
-        const event: DriveEvent = {
-            type: eventType,
-            nodeUid: node.uid,
-            parentNodeUid: node.parentUid,
-            isOwnVolume: true,
-            isTrashed: !!node.trashTime,
-            isShared: node.isShared,
-        };
-        await notifyListenersByEvent(this.logger, event, this.listeners, this.cache, this.nodesAccess);
-
-    }
-}
-
-/**
- * For given event, update the cache accordingly.
- * 
- * The function is responsible for updating the cache based on the
- * event received from the DriveEventsService. The cache metadata
- * are not updated, only the nodes are marked as stale to be
- * fetched and decrypted again when requested by the client.
- * 
- * If the node is not found in the cache, the event is silently
- * skipped as the node will be fetched and decrypted when requested
- * by the client.
- * 
- * If the node cannot be updated in the cache, the node is removed
- * from the cache to not block the client. If the node is not possible
- * to remove, the function throws an error.
- * 
- * @throws Only if the node is not possible to remove from the cache.
- */
-export async function updateCacheByEvent(logger: Logger, event: DriveEvent, cache: NodesCache) {
-    // NodeCreated event is ignored as we do not want to fetch and
-    // decrypt the node immediately. The node will be fetched and
-    // decrypted when requested by the client.
-    if (event.type === DriveEventType.NodeCreated) {
-        // We do not have partial nodes in the cache, so we don't
-        // add it. If new node is not added, we need to reset the
-        // children loaded flag to force refetch when requested.
-        if (event.parentNodeUid) {
-            await cache.resetFolderChildrenLoaded(event.parentNodeUid);
-        }
-    }
-    if (event.type === DriveEventType.NodeUpdated || event.type === DriveEventType.NodeUpdatedMetadata) {
-        let node;
-        // getNode can fail if the node is not found or if it is
-        // corrupted. In later case, it will be automatically
-        // removed from cache. In both cases, lets skip the event
-        // silently as once requested by client, the node will
-        // be cached again.
-        try {
-            node = await cache.getNode(event.nodeUid);
-        } catch (error: unknown) {
-            logger.debug(`Skipping node update event (node not in the cache): ${error}`);
-        }
-        if (node) {
-            node.isStale = true;
-            // We need to update the parentUid as the node might have
-            // been moved to another parent. This is important for
-            // children iteration.
-            node.parentUid = event.parentNodeUid;
-            try {
-                await cache.setNode(node);
-            } catch (setNodeError: unknown) {
-                logger.error(`Skipping node update event (failed to update)`, setNodeError);
-                // If updating node in the cache is failing, lets remove it
-                // to not block the whole client. If the node is not possible
-                // to remove, lets throw at this point as cache is in very
-                // bad state by this point and the rest of the code would start
-                // to break randomly.
-                try {
-                    await cache.removeNodes([event.nodeUid]);
-                } catch (removeNodeError: unknown) {
-                    logger.error(`Skipping node update event (failed to remove after failed update)`, removeNodeError);
-                    // removeNodeError is automatic correction algorithm.
-                    // If that fails, lets throw the original error as that
-                    // is the real problem.
-                    throw setNodeError;
+            if (event.type === DriveEventType.NodeUpdated) {
+                const node = await this.cache.getNode(event.nodeUid);
+                node.isStale = true;
+                node.parentUid = event.parentNodeUid;
+                node.isShared = event.isShared;
+                if (event.isTrashed) {
+                    node.trashTime ??= new Date();
+                } else {
+                    node.trashTime = undefined;
                 }
+                await this.cache.setNode(node);
             }
-        }
-    }
-}
-
-/**
- * For given event, delete the node from the cache if it is
- * deleted.
- */
-export async function deleteFromCacheByEvent(logger: Logger, event: DriveEvent, cache: NodesCache) {
-    if (event.type === DriveEventType.NodeDeleted) {
-        // removeNodes can fail removing children.
-        // We do not want to stop processing other events in such
-        // a case. Lets log the error and continue.
-        try {
-            await cache.removeNodes([event.nodeUid]);
         } catch (error: unknown) {
-            logger.error(`Skipping node delete event:`, error);
-        }
-    }
-}
-
-/**
- * For given event, notify the listeners accordingly.
- * 
- * The function is responsible for notifying the listeners about the
- * event received from the DriveEventsService. The listeners are
- * connected with events based on the condition, such as parent node
- * uid for listening to children updates.
- * 
- * The function is responsible for fetching and decrypting the latest
- * version of the node metadata. If the node is not found, the event
- * is silently skipped as the node will be fetched and decrypted when
- * requested by the client.
- * 
- * @throws Only if the client's callback throws.
- */
-export async function notifyListenersByEvent(logger: Logger, event: DriveEvent, listeners: Listeners, cache: NodesCache, nodesAccess: NodesAccess) {
-    if (event.type === DriveEventType.ShareWithMeUpdated) {
-        return;
-    }
-
-    const subscribedListeners = listeners.filter(({ condition }) => condition(event));
-    const eventMatchingCondition = subscribedListeners.length > 0;
-
-    if ([DriveEventType.NodeCreated, DriveEventType.NodeUpdated, DriveEventType.NodeUpdatedMetadata].includes(event.type) && eventMatchingCondition) {
-        if (subscribedListeners.length) {
-            let node;
-            try {
-                node = await nodesAccess.getNode(event.nodeUid);
-            } catch (error: unknown) {
-                logger.error(`Skipping node update event to listener`, error);
-                return;
+            if (error instanceof Error) {
+                // FIXME throw CacheMissException error and catch it
+                if (error.message === 'Entity not found') {
+                    return;
+                }
             }
-            subscribedListeners.forEach(({ callback }) => callback({ type: 'update', uid: node.uid, node: convertInternalNode(node) }));
-        }
-    }
-
-    if (
-        ((event.type === DriveEventType.NodeUpdated || event.type === DriveEventType.NodeUpdatedMetadata) && !eventMatchingCondition)
-        || event.type === DriveEventType.NodeDeleted
-    ) {
-        let node: DecryptedNode;
-        try {
-            node = await cache.getNode(event.nodeUid);
-        } catch {}
-
-        const subscribedListeners = listeners.filter(({ condition }) => condition({
-            parentNodeUid: node?.parentUid,
-            isTrashed: !!node?.trashTime || false,
-        }));
-
-        if (subscribedListeners.length) {
-            subscribedListeners.forEach(({ callback }) => callback({ type: 'remove', uid: event.nodeUid }));
+            this.logger.error(`Failed to update node cache for event: ${event.eventId}`, error);
         }
     }
 }

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

@@ -1,5 +1,12 @@
-import { getMockLogger } from "../../tests/logger";
-import { FolderExtendedAttributes, FileExtendedAttributesParsed, generateFolderExtendedAttributes, generateFileExtendedAttributes, parseFolderExtendedAttributes, parseFileExtendedAttributes } from './extendedAttributes';
+import { getMockLogger } from '../../tests/logger';
+import {
+    FolderExtendedAttributes,
+    FileExtendedAttributesParsed,
+    generateFolderExtendedAttributes,
+    generateFileExtendedAttributes,
+    parseFolderExtendedAttributes,
+    parseFileExtendedAttributes,
+} from './extendedAttributes';
 
 describe('extended attrbiutes', () => {
     describe('should generate folder attributes', () => {
@@ -11,7 +18,7 @@ describe('extended attrbiutes', () => {
             it(`should generate ${input}`, () => {
                 const output = generateFolderExtendedAttributes(input);
                 expect(output).toBe(expectedAttributes);
-            })
+            });
         });
     });
 
@@ -26,46 +33,43 @@ describe('extended attrbiutes', () => {
                     claimedModificationTime: new Date(1234567890000),
                 },
             ],
-            [
-                '{"Common": {"ModificationTime": "aa"}}',
-                {},
-            ],
+            ['{"Common": {"ModificationTime": "aa"}}', {}],
             [
                 '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": 123}}',
                 {
                     claimedModificationTime: new Date(1234567890000),
                 },
             ],
-            [
-                '{"Common": {"Whatever": 123}}',
-                {},
-            ],
+            ['{"Common": {"Whatever": 123}}', {}],
         ];
         testCases.forEach(([input, expectedAttributes]) => {
             it(`should parse ${input}`, () => {
                 const output = parseFolderExtendedAttributes(getMockLogger(), input);
                 expect(output).toMatchObject(expectedAttributes);
-            })
+            });
         });
     });
 
     describe('should generate file attributes', () => {
         const testCases: [object, string | undefined][] = [
             [{}, undefined],
-            [{modificationTime: new Date(1234567890000)}, '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z"}}'],
-            [{size: undefined}, undefined],
-            [{size: 0}, '{"Common":{"Size":0}}'],
-            [{size: 1234}, '{"Common":{"Size":1234}}'],
-            [{blockSizes: []}, undefined],
-            [{blockSizes: [4,4,4,2]}, '{"Common":{"BlockSizes":[4,4,4,2]}}'],
-            [{digests: {}}, undefined],
-            [{digests: {sha1: 'abcdef'}}, '{"Common":{"Digests":{"SHA1":"abcdef"}}}'],
+            [
+                { modificationTime: new Date(1234567890000) },
+                '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z"}}',
+            ],
+            [{ size: undefined }, undefined],
+            [{ size: 0 }, '{"Common":{"Size":0}}'],
+            [{ size: 1234 }, '{"Common":{"Size":1234}}'],
+            [{ blockSizes: [] }, undefined],
+            [{ blockSizes: [4, 4, 4, 2] }, '{"Common":{"BlockSizes":[4,4,4,2]}}'],
+            [{ digests: {} }, undefined],
+            [{ digests: { sha1: 'abcdef' } }, '{"Common":{"Digests":{"SHA1":"abcdef"}}}'],
             [
                 {
                     modificationTime: new Date(1234567890000),
                     size: 1234,
                     blockSizes: [4, 4, 4, 2],
-                    digests: {sha1: 'abcdef'},
+                    digests: { sha1: 'abcdef' },
                 },
                 '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z","Size":1234,"BlockSizes":[4,4,4,2],"Digests":{"SHA1":"abcdef"}}}',
             ],
@@ -74,7 +78,7 @@ describe('extended attrbiutes', () => {
             it(`should generate ${input}`, () => {
                 const output = generateFileExtendedAttributes(input);
                 expect(output).toBe(expectedAttributes);
-            })
+            });
         });
     });
 
@@ -151,7 +155,7 @@ describe('extended attrbiutes', () => {
                 {
                     claimedModificationTime: undefined,
                     claimedSize: undefined,
-                    claimedDigests: {sha1: "abcdef"},
+                    claimedDigests: { sha1: 'abcdef' },
                     claimedAdditionalMetadata: undefined,
                 },
             ],
@@ -171,7 +175,7 @@ describe('extended attrbiutes', () => {
             it(`should parse ${input}`, () => {
                 const output = parseFileExtendedAttributes(getMockLogger(), input);
                 expect(output).toMatchObject(expectedAttributes);
-            })
+            });
         });
     });
 });

package/src/internal/nodes/extendedAttributes.ts

@@ -1,4 +1,4 @@
-import { Logger } from "../../interface";
+import { Logger } from '../../interface';
 
 interface FolderExtendedAttributesSchema {
     Common?: {
@@ -38,16 +38,16 @@ interface FileExtendedAttributesSchema {
 }
 
 export interface FolderExtendedAttributes {
-    claimedModificationTime?: Date,
+    claimedModificationTime?: Date;
 }
 
 export interface FileExtendedAttributesParsed {
-    claimedSize?: number,
-    claimedModificationTime?: Date,
+    claimedSize?: number;
+    claimedModificationTime?: Date;
     claimedDigests?: {
-        sha1?: string,
-    },
-    claimedAdditionalMetadata?: object,
+        sha1?: string;
+    };
+    claimedAdditionalMetadata?: object;
 }
 
 export function generateFolderExtendedAttributes(claimedModificationTime?: Date): string | undefined {
@@ -83,12 +83,12 @@ export function parseFolderExtendedAttributes(logger: Logger, extendedAttributes
 }
 
 export function generateFileExtendedAttributes(options: {
-    modificationTime?: Date,
-    size?: number,
-    blockSizes?: number[],
+    modificationTime?: Date;
+    size?: number;
+    blockSizes?: number[];
     digests?: {
-        sha1?: string,
-    },
+        sha1?: string;
+    };
 }): string | undefined {
     const commonAttributes: FileExtendedAttributesSchema['Common'] = {};
     if (options.modificationTime) {
@@ -115,7 +115,7 @@ export function generateFileExtendedAttributes(options: {
 
 export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?: string): FileExtendedAttributesParsed {
     if (!extendedAttributes) {
-        return {}
+        return {};
     }
 
     try {
@@ -128,7 +128,9 @@ export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?:
             claimedSize: parseSize(logger, parsed),
             claimedModificationTime: parseModificationTime(logger, parsed),
             claimedDigests: parseDigests(logger, parsed),
-            claimedAdditionalMetadata: Object.keys(claimedAdditionalMetadata).length ? claimedAdditionalMetadata : undefined,
+            claimedAdditionalMetadata: Object.keys(claimedAdditionalMetadata).length
+                ? claimedAdditionalMetadata
+                : undefined,
         };
     } catch (error: unknown) {
         logger.error(`Failed to parse extended attributes`, error);
@@ -148,7 +150,10 @@ function parseSize(logger: Logger, xattr?: FileExtendedAttributesSchema): number
     return size;
 }
 
-function parseModificationTime(logger: Logger, xattr?: FolderExtendedAttributesSchema | FolderExtendedAttributesSchema): Date | undefined {
+function parseModificationTime(
+    logger: Logger,
+    xattr?: FolderExtendedAttributesSchema | FolderExtendedAttributesSchema,
+): Date | undefined {
     const modificationTime = xattr?.Common?.ModificationTime;
     if (modificationTime === undefined) {
         return undefined;