n8n-nodes-onedrive-business-sp 1.1.1 → 1.2.0

package/dist/nodes/MicrosoftOneDriveBusiness/MicrosoftOneDriveBusinessTrigger.node.js

@@ -109,11 +109,51 @@ class MicrosoftOneDriveBusinessTrigger {
                     default: {},
                     options: [
                         {
-                            displayName: 'Poll Interval (minutes)',
-                            name: 'pollInterval',
+                            displayName: 'Watch Subfolders',
+                            name: 'recursive',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to watch subfolders recursively',
+                        },
+                        {
+                            displayName: 'Ignore Duplicates',
+                            name: 'ignoreDuplicates',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to ignore duplicate notifications for the same file',
+                        },
+                        {
+                            displayName: 'Wait for File Completion (seconds)',
+                            name: 'waitForCompletion',
                             type: 'number',
-                            default: 5,
-                            description: 'How often to poll for changes (in minutes)',
+                            default: 0,
+                            description: 'Wait time after detecting change to ensure file is fully uploaded. Useful for large files.',
+                        },
+                        {
+                            displayName: 'Include File Metadata',
+                            name: 'includeMetadata',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Whether to include extended metadata like version, lock status, etc.',
+                        },
+                        {
+                            displayName: 'Periodic Full Scan',
+                            name: 'fullScanEnabled',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to periodically perform a full scan as backup (in case delta misses changes)',
+                        },
+                        {
+                            displayName: 'Full Scan Interval (hours)',
+                            name: 'fullScanInterval',
+                            type: 'number',
+                            default: 24,
+                            displayOptions: {
+                                show: {
+                                    fullScanEnabled: [true],
+                                },
+                            },
+                            description: 'How often to perform a full scan (in hours)',
                         },
                     ],
                 },
@@ -232,6 +272,14 @@ class MicrosoftOneDriveBusinessTrigger {
                     else {
                         watchFolderId = watchFolder.value || 'root';
                     }
+                    // Validate webhook URL accessibility (basic check)
+                    if (!webhookUrl.startsWith('https://')) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Webhook URL must use HTTPS. Microsoft Graph requires secure endpoints.');
+                    }
+                    // Check if webhook URL contains localhost/127.0.0.1
+                    if (webhookUrl.includes('localhost') || webhookUrl.includes('127.0.0.1')) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Webhook URL cannot be localhost. Microsoft Graph cannot reach local addresses. Use a public URL or tunneling service like ngrok.');
+                    }
                     // Get drive ID if not provided
                     let actualDriveId = driveId;
                     if (!actualDriveId) {
@@ -242,6 +290,24 @@ class MicrosoftOneDriveBusinessTrigger {
                         });
                         actualDriveId = driveResponse.id;
                     }
+                    // Validate drive and folder accessibility
+                    try {
+                        await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}`,
+                            json: true,
+                        });
+                        if (watchFolderId !== 'root') {
+                            await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                                method: 'GET',
+                                url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${watchFolderId}`,
+                                json: true,
+                            });
+                        }
+                    }
+                    catch (validationError) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Cannot access drive/folder. It may have been deleted, moved, or you may not have permission. Error: ${validationError.message}`);
+                    }
                     // Microsoft Graph only supports subscriptions at drive root level
                     // We'll filter by folder in the webhook handler
                     const resource = `/drives/${actualDriveId}/root`;
@@ -265,7 +331,22 @@ class MicrosoftOneDriveBusinessTrigger {
                         webhookData.subscriptionId = responseData.id;
                         webhookData.driveId = actualDriveId;
                         webhookData.watchFolderId = watchFolderId;
-                        webhookData.deltaLink = null;
+                        webhookData.subscriptionExpiry = responseData.expirationDateTime;
+                        webhookData.processedItems = {};
+                        // Initialize delta link to avoid getting all existing items
+                        try {
+                            const deltaResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                                method: 'GET',
+                                url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/root/delta`,
+                                json: true,
+                            });
+                            // Store the delta link to track only future changes
+                            webhookData.deltaLink = deltaResponse['@odata.deltaLink'];
+                        }
+                        catch (deltaError) {
+                            // If delta initialization fails, set to null
+                            webhookData.deltaLink = null;
+                        }
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : 'Unknown error';
@@ -305,6 +386,39 @@ class MicrosoftOneDriveBusinessTrigger {
                 webhookResponse: query.validationToken,
             };
         }
+        // Check if subscription needs renewal (renew if less than 24h remaining)
+        const subscriptionExpiry = webhookData.subscriptionExpiry;
+        const isRenewing = webhookData.isRenewing;
+        if (subscriptionExpiry && !isRenewing) {
+            const expiryTime = new Date(subscriptionExpiry).getTime();
+            const now = Date.now();
+            const hoursRemaining = (expiryTime - now) / (1000 * 60 * 60);
+            if (hoursRemaining < 24 && hoursRemaining > 0) {
+                try {
+                    // Set renewal flag to prevent concurrent renewals
+                    webhookData.isRenewing = true;
+                    const newExpirationDateTime = new Date();
+                    newExpirationDateTime.setHours(newExpirationDateTime.getHours() + 72);
+                    const renewResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                        method: 'PATCH',
+                        url: `https://graph.microsoft.com/v1.0/subscriptions/${webhookData.subscriptionId}`,
+                        body: {
+                            expirationDateTime: newExpirationDateTime.toISOString(),
+                        },
+                        json: true,
+                    });
+                    webhookData.subscriptionExpiry = renewResponse.expirationDateTime;
+                }
+                catch (renewError) {
+                    // If renewal fails, log but continue processing
+                    console.log('Failed to renew subscription:', renewError);
+                }
+                finally {
+                    // Clear renewal flag
+                    webhookData.isRenewing = false;
+                }
+            }
+        }
         // Verify client state
         const notification = bodyData.value?.[0];
         if (notification?.clientState !== 'n8n-secret-token') {
@@ -314,6 +428,13 @@ class MicrosoftOneDriveBusinessTrigger {
         }
         const event = this.getNodeParameter('event');
         const watchFolder = this.getNodeParameter('watchFolderId', {});
+        const options = this.getNodeParameter('options', {});
+        const recursive = options.recursive || false;
+        const ignoreDuplicates = options.ignoreDuplicates !== false;
+        const waitForCompletion = options.waitForCompletion || 0;
+        const includeMetadata = options.includeMetadata !== false;
+        const fullScanEnabled = options.fullScanEnabled || false;
+        const fullScanInterval = options.fullScanInterval || 24;
         // Extract folder ID from resource locator
         let watchFolderId;
         if (typeof watchFolder === 'string') {
@@ -324,20 +445,69 @@ class MicrosoftOneDriveBusinessTrigger {
         }
         const driveId = webhookData.driveId;
         const storedWatchFolderId = webhookData.watchFolderId || 'root';
+        // Check if full scan is needed
+        if (fullScanEnabled) {
+            const lastFullScan = webhookData.lastFullScan || 0;
+            const now = Date.now();
+            const hoursSinceLastScan = (now - lastFullScan) / (1000 * 60 * 60);
+            if (hoursSinceLastScan >= fullScanInterval) {
+                // Reset delta link to force full scan
+                webhookData.deltaLink = null;
+                webhookData.lastFullScan = now;
+            }
+        }
         // Always use root delta query (Microsoft Graph requirement)
         let deltaUrl = webhookData.deltaLink;
         if (!deltaUrl) {
             deltaUrl = `https://graph.microsoft.com/v1.0/drives/${driveId}/root/delta`;
         }
         try {
-            const deltaResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
-                method: 'GET',
-                url: deltaUrl,
-                json: true,
-            });
+            // Wait for file completion if configured
+            if (waitForCompletion > 0) {
+                await new Promise(resolve => setTimeout(resolve, waitForCompletion * 1000));
+            }
+            // Fetch all pages of delta changes
+            let allChanges = [];
+            let currentDeltaUrl = deltaUrl;
+            let finalDeltaLink;
+            let retryCount = 0;
+            const maxRetries = 3;
+            while (currentDeltaUrl) {
+                try {
+                    const deltaResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                        method: 'GET',
+                        url: currentDeltaUrl,
+                        json: true,
+                    });
+                    const pageChanges = deltaResponse.value;
+                    allChanges = allChanges.concat(pageChanges);
+                    // Check for next page or delta link
+                    if (deltaResponse['@odata.nextLink']) {
+                        currentDeltaUrl = deltaResponse['@odata.nextLink'];
+                    }
+                    else {
+                        currentDeltaUrl = undefined;
+                        finalDeltaLink = deltaResponse['@odata.deltaLink'];
+                    }
+                    retryCount = 0; // Reset retry count on success
+                }
+                catch (pageError) {
+                    // Retry logic for transient failures
+                    const statusCode = pageError?.statusCode || pageError?.response?.status;
+                    if ((statusCode === 429 || statusCode >= 500) && retryCount < maxRetries) {
+                        retryCount++;
+                        const delay = Math.min(1000 * Math.pow(2, retryCount), 10000); // Exponential backoff
+                        await new Promise(resolve => setTimeout(resolve, delay));
+                        continue; // Retry same URL
+                    }
+                    throw pageError; // Re-throw if not retryable or max retries reached
+                }
+            }
             // Store the new delta link
-            webhookData.deltaLink = deltaResponse['@odata.deltaLink'];
-            const changes = deltaResponse.value;
+            if (finalDeltaLink) {
+                webhookData.deltaLink = finalDeltaLink;
+            }
+            const changes = allChanges;
             // Get folder path if watching specific folder
             let watchFolderPath = null;
             if (storedWatchFolderId !== 'root') {
@@ -355,45 +525,184 @@ class MicrosoftOneDriveBusinessTrigger {
                     // If can't get folder path, don't filter
                 }
             }
+            // Deduplication: track processed items
+            const processedItems = webhookData.processedItems || {};
+            const now = Date.now();
+            // Clean up old processed items (older than 1 hour)
+            for (const key in processedItems) {
+                if (now - processedItems[key] > 3600000) {
+                    delete processedItems[key];
+                }
+            }
             const filteredChanges = changes.filter((change) => {
+                // Validate required fields
+                if (!change.id || !change.name) {
+                    return false; // Skip incomplete items
+                }
                 const isFile = change.file !== undefined;
                 const isFolder = change.folder !== undefined;
                 const isDeleted = change.deleted !== undefined;
                 if (isDeleted)
                     return false;
+                // Skip the root folder itself
+                if (change.root !== undefined)
+                    return false;
+                // Skip if missing critical metadata
+                if (!change.createdDateTime || !change.lastModifiedDateTime) {
+                    return false;
+                }
+                // Deduplication check
+                if (ignoreDuplicates) {
+                    const itemKey = `${change.id}_${change.lastModifiedDateTime}`;
+                    if (processedItems[itemKey]) {
+                        return false; // Already processed this exact change
+                    }
+                    processedItems[itemKey] = now;
+                }
                 // Filter by folder path if watching specific folder
-                if (watchFolderPath && change.parentReference) {
+                if (storedWatchFolderId !== 'root' && change.parentReference) {
                     const parentRef = change.parentReference;
-                    const itemPath = parentRef.path || '';
-                    if (!itemPath.includes(watchFolderPath)) {
-                        return false;
+                    const parentId = parentRef.id;
+                    if (recursive) {
+                        // For recursive, check if item is in watched folder or any subfolder
+                        const itemPath = parentRef.path || '';
+                        if (watchFolderPath) {
+                            if (!itemPath.includes(watchFolderPath)) {
+                                return false;
+                            }
+                        }
+                        else {
+                            // Fallback: check parent ID chain (would need additional API calls)
+                            // For now, just check direct parent
+                            if (parentId !== storedWatchFolderId) {
+                                // Could be in subfolder, but we can't verify without more API calls
+                                // Let it through for now
+                            }
+                        }
+                    }
+                    else {
+                        // Non-recursive: must be direct child
+                        if (parentId !== storedWatchFolderId) {
+                            return false;
+                        }
                     }
                 }
                 if (event === 'fileCreated' && isFile) {
-                    return change.createdDateTime === change.lastModifiedDateTime;
+                    // Compare timestamps instead of strings for better accuracy
+                    const created = new Date(change.createdDateTime).getTime();
+                    const modified = new Date(change.lastModifiedDateTime).getTime();
+                    // Allow small time difference (within 5 seconds) for creation detection
+                    return Math.abs(created - modified) < 5000;
                 }
                 else if (event === 'fileUpdated' && isFile) {
-                    return change.createdDateTime !== change.lastModifiedDateTime;
+                    const created = new Date(change.createdDateTime).getTime();
+                    const modified = new Date(change.lastModifiedDateTime).getTime();
+                    return modified > created + 5000;
                 }
                 else if (event === 'folderCreated' && isFolder) {
-                    return change.createdDateTime === change.lastModifiedDateTime;
+                    const created = new Date(change.createdDateTime).getTime();
+                    const modified = new Date(change.lastModifiedDateTime).getTime();
+                    return Math.abs(created - modified) < 5000;
                 }
                 else if (event === 'folderUpdated' && isFolder) {
-                    return change.createdDateTime !== change.lastModifiedDateTime;
+                    const created = new Date(change.createdDateTime).getTime();
+                    const modified = new Date(change.lastModifiedDateTime).getTime();
+                    return modified > created + 5000;
                 }
                 return false;
             });
+            // Save processed items
+            webhookData.processedItems = processedItems;
             if (filteredChanges.length === 0) {
                 return {
                     webhookResponse: 'No matching changes',
                     workflowData: [],
                 };
             }
+            // Enrich with extended metadata if requested
+            if (includeMetadata && filteredChanges.length > 0) {
+                for (const change of filteredChanges) {
+                    try {
+                        const itemDetails = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${driveId}/items/${change.id}`,
+                            qs: {
+                                $select: 'id,name,size,webUrl,file,folder,publication,createdBy,lastModifiedBy,fileSystemInfo,versions'
+                            },
+                            json: true,
+                        });
+                        // Add version information
+                        if (itemDetails.file) {
+                            change.versionNumber = itemDetails.file.hashes ?
+                                itemDetails['@microsoft.graph.version'] : undefined;
+                        }
+                        // Add lock/checkout status (SharePoint feature)
+                        if (itemDetails.publication) {
+                            const pub = itemDetails.publication;
+                            change.checkoutUser = pub.checkedOutBy;
+                            change.isCheckedOut = !!pub.checkedOutBy;
+                        }
+                        // Merge additional details
+                        Object.assign(change, {
+                            webUrl: itemDetails.webUrl,
+                            createdBy: itemDetails.createdBy,
+                            lastModifiedBy: itemDetails.lastModifiedBy,
+                            fileSystemInfo: itemDetails.fileSystemInfo,
+                        });
+                    }
+                    catch (enrichError) {
+                        // If enrichment fails, continue with basic data
+                        console.log('Failed to enrich metadata:', enrichError);
+                    }
+                }
+            }
             return {
                 workflowData: [filteredChanges.map((change) => ({ json: change }))],
             };
         }
         catch (error) {
+            // Handle specific error cases
+            const statusCode = error?.statusCode || error?.response?.status;
+            const errorCode = error?.error?.code || error?.response?.data?.error?.code;
+            // Delta link expired (410 Gone) or invalid (404)
+            if (statusCode === 410 || statusCode === 404 || errorCode === 'resyncRequired') {
+                // Reset delta link and try again with fresh sync
+                webhookData.deltaLink = null;
+                return {
+                    webhookResponse: 'Delta link expired, will resync on next change',
+                    workflowData: [],
+                };
+            }
+            // Folder not found or access denied
+            if (statusCode === 404 && storedWatchFolderId !== 'root') {
+                const errorMessage = 'Watched folder no longer exists or is inaccessible. Please reconfigure the trigger.';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
+            }
+            // Forbidden - permissions changed
+            if (statusCode === 403) {
+                const errorMessage = 'Access denied. Permissions may have changed or credentials need to be refreshed.';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
+            }
+            // Unauthorized - token expired/revoked
+            if (statusCode === 401) {
+                const errorMessage = 'Authentication failed. Please re-authenticate your OneDrive connection.';
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
+            }
+            // Service unavailable or gateway timeout
+            if (statusCode === 503 || statusCode === 504) {
+                return {
+                    webhookResponse: 'Microsoft Graph service temporarily unavailable, will retry on next notification',
+                    workflowData: [],
+                };
+            }
+            // Rate limiting (429)
+            if (statusCode === 429) {
+                const retryAfter = error?.response?.headers?.['retry-after'] || '60';
+                return {
+                    webhookResponse: `Rate limited, retry after ${retryAfter} seconds`,
+                    workflowData: [],
+                };
+            }
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to fetch delta changes: ${errorMessage}`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-onedrive-business-sp",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "n8n node for Microsoft OneDrive for Business (SharePoint)",
   "keywords": [
     "n8n-community-node-package",