n8n-nodes-onedrive-business 1.1.2 → 1.1.5

package/dist/nodes/OneDriveBusinessTrigger.node.js

@@ -358,9 +358,9 @@ class OneDriveBusinessTrigger {
             OneDriveBusinessTrigger.instances.set(nodeId, instance);
         }
         // Create delta processor
-        const deltaProcessor = new DeltaProcessor_1.DeltaProcessor(graphClient, instance.stateStore, drivePath);
+        const deltaProcessor = new DeltaProcessor_1.DeltaProcessor(graphClient, instance.stateStore, drivePath, watchPath);
         // Process delta query
-        const triggerEvents = await deltaProcessor.processDeltaQuery(eventFilter, watchPath);
+        const triggerEvents = await deltaProcessor.processDeltaQuery(eventFilter);
         // Clean up old versions periodically
         const state = instance.stateStore.getState();
         const processedCount = Object.keys(state.processedVersions).length;
@@ -378,7 +378,7 @@ class OneDriveBusinessTrigger {
                 },
             })));
         }
-        return workflowData;
+        return workflowData.length > 0 ? workflowData : null;
     }
 }
 exports.OneDriveBusinessTrigger = OneDriveBusinessTrigger;

package/dist/utils/DeltaProcessor.d.ts

@@ -36,21 +36,16 @@ export declare class DeltaProcessor {
     private graphClient;
     private stateStore;
     private drivePath;
+    private watchPath?;
     private stabilityTracker;
     private readonly STABILITY_WINDOW_MS;
-    constructor(graphClient: GraphClient, stateStore: StateStore, drivePath: string);
+    constructor(graphClient: GraphClient, stateStore: StateStore, drivePath: string, watchPath?: string);
     /**
      * Process delta query and return triggerable events
      *
      * This is the main entry point called by the trigger node
      */
-    /**
-     * Process delta query and return triggerable events
-     *
-     * This is the main entry point called by the trigger node
-     */
-    processDeltaQuery(eventFilter: Set<string>, // e.g., ['file.created', 'file.updated']
-    watchPath?: string): Promise<TriggerEvent[]>;
+    processDeltaQuery(eventFilter: Set<string>): Promise<TriggerEvent[]>;
     /**
      * Fetch all pages from delta query
      * Handles @odata.nextLink pagination and stores @odata.deltaLink
@@ -61,10 +56,6 @@ export declare class DeltaProcessor {
      * Returns a TriggerEvent if the item should trigger a workflow
      */
     private processItem;
-    /**
-     * Check if item is within the watched path
-     */
-    private isItemInScope;
     /**
      * Classify event as created vs updated
      *

package/dist/utils/DeltaProcessor.js

@@ -34,7 +34,7 @@ const helpers_1 = require("./helpers");
  * Without this processor, ONE file upload would trigger FOUR workflow executions.
  */
 class DeltaProcessor {
-    constructor(graphClient, stateStore, drivePath) {
+    constructor(graphClient, stateStore, drivePath, watchPath) {
         // Stability tracking for files currently being uploaded
         this.stabilityTracker = new Map();
         // Stability window: wait 15 seconds after last modification
@@ -42,19 +42,15 @@ class DeltaProcessor {
         this.graphClient = graphClient;
         this.stateStore = stateStore;
         this.drivePath = drivePath;
+        this.watchPath = watchPath;
     }
     /**
      * Process delta query and return triggerable events
      *
      * This is the main entry point called by the trigger node
      */
-    /**
-     * Process delta query and return triggerable events
-     *
-     * This is the main entry point called by the trigger node
-     */
-    async processDeltaQuery(eventFilter, // e.g., ['file.created', 'file.updated']
-    watchPath) {
+    async processDeltaQuery(eventFilter // e.g., ['file.created', 'file.updated']
+    ) {
         const events = [];
         try {
             // Get current state
@@ -69,13 +65,28 @@ class DeltaProcessor {
             }
             else {
                 // Initial delta query
-                deltaEndpoint = `${this.drivePath}/root/delta`;
+                if (this.watchPath && this.watchPath !== '' && this.watchPath !== '/') {
+                    // Scope to specific folder
+                    let path = this.watchPath;
+                    if (!path.startsWith('/')) {
+                        path = '/' + path;
+                    }
+                    // Syntax: /drive/root:/path/to/folder:/delta
+                    // Note the colons wrapping the path
+                    deltaEndpoint = `${this.drivePath}/root:${encodeURIComponent(path)}:/delta`;
+                    console.log(`[DeltaProcessor] Initializing Scoped Delta Query: ${deltaEndpoint}`);
+                }
+                else {
+                    // Browse entire drive
+                    deltaEndpoint = `${this.drivePath}/root/delta`;
+                    console.log(`[DeltaProcessor] Initializing Root Delta Query`);
+                }
             }
             // Fetch delta changes (handle pagination)
             const items = await this.fetchAllDeltaPages(deltaEndpoint);
             // Process each item
             for (const item of items) {
-                const event = await this.processItem(item, eventFilter, watchPath);
+                const event = await this.processItem(item, eventFilter);
                 if (event) {
                     events.push(event);
                 }
@@ -95,6 +106,8 @@ class DeltaProcessor {
         const allItems = [];
         let currentEndpoint = initialEndpoint;
         while (currentEndpoint) {
+            // Log for debugging
+            console.log(`[DeltaProcessor] Fetching: ${currentEndpoint}`);
             const response = await this.graphClient.get(currentEndpoint);
             allItems.push(...response.value);
             // Check for next page
@@ -119,19 +132,18 @@ class DeltaProcessor {
      * Process a single delta item
      * Returns a TriggerEvent if the item should trigger a workflow
      */
-    async processItem(item, eventFilter, watchPath) {
+    async processItem(item, eventFilter) {
         // Skip deleted items (unless specifically requested)
         if (item.deleted) {
             return null;
         }
-        // Skip root folder
+        // Skip root folder (the folder itself, not its children)
         if (!item.parentReference) {
             return null;
         }
-        // Check scope (folder filtering)
-        if (watchPath && !this.isItemInScope(item, watchPath)) {
-            return null;
-        }
+        // Note: We don't need manual scope checking (isItemInScope) anymore
+        // because the Delta Query itself is scoped to the target folder.
+        // Any item returned here IS in the scope.
         // Determine event type
         const eventType = this.classifyEvent(item);
         // Check if this event type is enabled
@@ -163,42 +175,6 @@ class DeltaProcessor {
             timestamp: new Date().toISOString(),
         };
     }
-    /**
-     * Check if item is within the watched path
-     */
-    isItemInScope(item, watchPath) {
-        if (!item.parentReference || !item.parentReference.path) {
-            return false;
-        }
-        // Extract relative path from parentReference.path
-        // Format: /drives/{drive-id}/root:/path/to/folder
-        const parts = item.parentReference.path.split('root:');
-        if (parts.length < 2) {
-            // Item is in root
-            // If watchPath is /, then it's a match. Otherwise no.
-            return watchPath === '/' || watchPath === '';
-        }
-        let relativePath = parts[1]; // /path/to/folder
-        // Ensure paths start with / for consistent comparison
-        if (!relativePath.startsWith('/')) {
-            relativePath = '/' + relativePath;
-        }
-        // Ensure watchPath starts with /
-        let normalizedWatchPath = watchPath;
-        if (!normalizedWatchPath.startsWith('/')) {
-            normalizedWatchPath = '/' + normalizedWatchPath;
-        }
-        // Check if relative path matches or is a subfolder
-        // 1. Exact match: relativePath === normalizedWatchPath
-        // 2. Subfolder: relativePath startsWith normalizedWatchPath + '/'
-        if (relativePath === normalizedWatchPath) {
-            return true;
-        }
-        if (relativePath.startsWith(normalizedWatchPath + '/')) {
-            return true;
-        }
-        return false;
-    }
     /**
      * Classify event as created vs updated
      *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "n8n-nodes-onedrive-business",
-    "version": "1.1.2",
+    "version": "1.1.5",
     "description": "n8n custom node for OneDrive Business with robust deduplication and webhook triggers",
     "keywords": [
         "n8n",