n8n-nodes-onedrive-business 1.0.0

package/dist/nodes/OneDriveBusinessTrigger.node.d.ts

@@ -0,0 +1,63 @@
+import { IHookFunctions, IWebhookFunctions, IPollFunctions, INodeType, INodeTypeDescription, INodeExecutionData, IWebhookResponseData } from 'n8n-workflow';
+/**
+ * OneDrive Business Trigger Node
+ *
+ * ARCHITECTURE (CRITICAL):
+ *
+ * 1. Webhook Endpoint
+ *    - Receives notifications from Microsoft Graph
+ *    - Validates clientState and validationToken
+ *    - Returns 200 OK immediately
+ *    - NEVER emits workflow data directly
+ *
+ * 2. Microsoft Graph Subscription
+ *    - Auto-created on activation
+ *    - Auto-renewed before expiration
+ *    - Auto-deleted on deactivation
+ *    - Resource: /users/{userId}/drive/root or /sites/{siteId}/drive
+ *    - Change types: created,updated
+ *
+ * 3. Delta Query Processing
+ *    - Source of truth for all events
+ *    - Triggered by webhook notifications (via polling)
+ *    - Fetches actual file metadata
+ *    - Handles pagination
+ *    - Persists deltaLink between runs
+ *
+ * 4. Deduplication Engine
+ *    - File stability checking (hash, size, timestamps)
+ *    - Version tracking (${itemId}_${eTag})
+ *    - 15-second stability window
+ *    - Event classification (created vs updated)
+ *
+ * This architecture ensures EXACTLY ONE workflow execution per file version,
+ * despite SharePoint generating multiple backend updates per upload.
+ */
+export declare class OneDriveBusinessTrigger implements INodeType {
+    description: INodeTypeDescription;
+    private static instances;
+    /**
+     * Webhook Setup (on activation)
+     */
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    /**
+     * Webhook Handler (receives notifications)
+     *
+     * CRITICAL: This does NOT emit workflow data.
+     * It only validates the request and returns 200 OK.
+     */
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+    /**
+     * Polling (Source of Truth)
+     *
+     * This is where the actual workflow triggering happens.
+     * Called periodically to check for changes via Delta Query.
+     */
+    poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+}

package/dist/nodes/OneDriveBusinessTrigger.node.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneDriveBusinessTrigger = void 0;
+const GraphClient_1 = require("../utils/GraphClient");
+const StateStore_1 = require("../utils/StateStore");
+const DeltaProcessor_1 = require("../utils/DeltaProcessor");
+const WebhookHandler_1 = require("../utils/WebhookHandler");
+const helpers_1 = require("../utils/helpers");
+/**
+ * OneDrive Business Trigger Node
+ *
+ * ARCHITECTURE (CRITICAL):
+ *
+ * 1. Webhook Endpoint
+ *    - Receives notifications from Microsoft Graph
+ *    - Validates clientState and validationToken
+ *    - Returns 200 OK immediately
+ *    - NEVER emits workflow data directly
+ *
+ * 2. Microsoft Graph Subscription
+ *    - Auto-created on activation
+ *    - Auto-renewed before expiration
+ *    - Auto-deleted on deactivation
+ *    - Resource: /users/{userId}/drive/root or /sites/{siteId}/drive
+ *    - Change types: created,updated
+ *
+ * 3. Delta Query Processing
+ *    - Source of truth for all events
+ *    - Triggered by webhook notifications (via polling)
+ *    - Fetches actual file metadata
+ *    - Handles pagination
+ *    - Persists deltaLink between runs
+ *
+ * 4. Deduplication Engine
+ *    - File stability checking (hash, size, timestamps)
+ *    - Version tracking (${itemId}_${eTag})
+ *    - 15-second stability window
+ *    - Event classification (created vs updated)
+ *
+ * This architecture ensures EXACTLY ONE workflow execution per file version,
+ * despite SharePoint generating multiple backend updates per upload.
+ */
+class OneDriveBusinessTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'OneDrive Business Trigger',
+            name: 'oneDriveBusinessTrigger',
+            icon: 'file:onedrive.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Triggers when files or folders change in OneDrive Business',
+            defaults: {
+                name: 'OneDrive Business Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'oneDriveBusinessOAuth2Api',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            polling: true,
+            properties: [
+                // Drive Location
+                {
+                    displayName: 'Drive Type',
+                    name: 'driveType',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'User Drive',
+                            value: 'user',
+                            description: 'Monitor a user\'s OneDrive',
+                        },
+                        {
+                            name: 'Site Drive',
+                            value: 'site',
+                            description: 'Monitor a SharePoint site\'s document library',
+                        },
+                    ],
+                    default: 'user',
+                    description: 'Type of drive to monitor',
+                },
+                {
+                    displayName: 'User ID',
+                    name: 'userId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            driveType: ['user'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    placeholder: 'user@contoso.com or user-id',
+                    description: 'User principal name or ID',
+                },
+                {
+                    displayName: 'Site ID',
+                    name: 'siteId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            driveType: ['site'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    placeholder: 'contoso.sharepoint.com,site-id,web-id',
+                    description: 'SharePoint site ID',
+                },
+                // Event Selection
+                {
+                    displayName: 'Trigger On',
+                    name: 'events',
+                    type: 'multiOptions',
+                    options: [
+                        {
+                            name: 'File Created',
+                            value: 'file.created',
+                            description: 'Trigger when a new file is created',
+                        },
+                        {
+                            name: 'File Updated',
+                            value: 'file.updated',
+                            description: 'Trigger when a file is modified',
+                        },
+                        {
+                            name: 'Folder Created',
+                            value: 'folder.created',
+                            description: 'Trigger when a new folder is created',
+                        },
+                        {
+                            name: 'Folder Updated',
+                            value: 'folder.updated',
+                            description: 'Trigger when a folder is modified',
+                        },
+                    ],
+                    default: ['file.created', 'file.updated'],
+                    required: true,
+                    description: 'Events that trigger the workflow',
+                },
+                // Polling interval (fallback if webhooks fail)
+                {
+                    displayName: 'Polling Interval',
+                    name: 'pollInterval',
+                    type: 'number',
+                    default: 60,
+                    description: 'How often to check for changes (in seconds) if webhook notifications are not received',
+                },
+            ],
+        };
+        /**
+         * Webhook Setup (on activation)
+         */
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.subscriptionId) {
+                        // Check if subscription still exists
+                        const graphClient = new GraphClient_1.GraphClient(this);
+                        try {
+                            await graphClient.get(`/subscriptions/${webhookData.subscriptionId}`);
+                            return true;
+                        }
+                        catch (error) {
+                            // Subscription doesn't exist
+                            delete webhookData.subscriptionId;
+                            return false;
+                        }
+                    }
+                    return false;
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const nodeId = this.getNode().id;
+                    // Initialize components
+                    const graphClient = new GraphClient_1.GraphClient(this);
+                    // Get drive location from parameters
+                    const driveType = this.getNodeParameter('driveType');
+                    const driveLocation = {
+                        type: driveType,
+                        userId: driveType === 'user' ? this.getNodeParameter('userId') : undefined,
+                        siteId: driveType === 'site' ? this.getNodeParameter('siteId') : undefined,
+                    };
+                    const subscriptionResource = (0, helpers_1.resolveSubscriptionResource)(driveLocation);
+                    const drivePath = (0, helpers_1.resolveDrivePath)(driveLocation);
+                    // Initialize state store
+                    const credentials = await this.getCredentials('oneDriveBusinessOAuth2Api');
+                    const tenantId = credentials.tenantId;
+                    // Get drive ID
+                    const drive = await graphClient.get(drivePath);
+                    const driveId = drive.id;
+                    const stateStore = new StateStore_1.StateStore(nodeId);
+                    await stateStore.initialize(tenantId, driveId, driveLocation.userId, driveLocation.siteId);
+                    // Create webhook handler
+                    const webhookHandler = new WebhookHandler_1.WebhookHandler(graphClient, stateStore, subscriptionResource);
+                    // Create subscription
+                    const subscription = await webhookHandler.createOrRenewSubscription(webhookUrl);
+                    // Store subscription ID in workflow static data
+                    const webhookData = this.getWorkflowStaticData('node');
+                    webhookData.subscriptionId = subscription.id;
+                    // Store instances for webhook handling
+                    OneDriveBusinessTrigger.instances.set(nodeId, {
+                        stateStore,
+                        webhookHandler,
+                    });
+                    console.log(`OneDrive Business Trigger activated for node ${nodeId}`);
+                    return true;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const nodeId = this.getNode().id;
+                    const instance = OneDriveBusinessTrigger.instances.get(nodeId);
+                    if (instance) {
+                        // Delete subscription
+                        try {
+                            await instance.webhookHandler.deleteSubscription();
+                        }
+                        catch (error) {
+                            console.error('Error deleting subscription:', error);
+                        }
+                        // Flush state
+                        await instance.stateStore.flush();
+                        // Remove instance
+                        OneDriveBusinessTrigger.instances.delete(nodeId);
+                    }
+                    delete webhookData.subscriptionId;
+                    console.log(`OneDrive Business Trigger deactivated for node ${nodeId}`);
+                    return true;
+                },
+            },
+        };
+    }
+    /**
+     * Webhook Handler (receives notifications)
+     *
+     * CRITICAL: This does NOT emit workflow data.
+     * It only validates the request and returns 200 OK.
+     */
+    async webhook() {
+        const req = this.getRequestObject();
+        const res = this.getResponseObject();
+        const nodeId = this.getNode().id;
+        const instance = OneDriveBusinessTrigger.instances.get(nodeId);
+        if (instance) {
+            await instance.webhookHandler.handleWebhookRequest(req, res);
+        }
+        else {
+            // No instance found, respond with 404
+            res.writeHead(404);
+            res.end();
+        }
+        // Return no data (webhook notifications don't trigger workflows)
+        return {
+            noWebhookResponse: true,
+        };
+    }
+    /**
+     * Polling (Source of Truth)
+     *
+     * This is where the actual workflow triggering happens.
+     * Called periodically to check for changes via Delta Query.
+     */
+    async poll() {
+        const nodeId = this.getNode().id;
+        const events = this.getNodeParameter('events');
+        const eventFilter = new Set(events);
+        // Initialize components
+        const graphClient = new GraphClient_1.GraphClient(this);
+        // Get drive location from parameters
+        const driveType = this.getNodeParameter('driveType');
+        const driveLocation = {
+            type: driveType,
+            userId: driveType === 'user' ? this.getNodeParameter('userId') : undefined,
+            siteId: driveType === 'site' ? this.getNodeParameter('siteId') : undefined,
+        };
+        const drivePath = (0, helpers_1.resolveDrivePath)(driveLocation);
+        // Initialize state store
+        const credentials = await this.getCredentials('oneDriveBusinessOAuth2Api');
+        const tenantId = credentials.tenantId;
+        // Get drive ID
+        const drive = await graphClient.get(drivePath);
+        const driveId = drive.id;
+        // Get or create state store
+        let instance = OneDriveBusinessTrigger.instances.get(nodeId);
+        if (!instance) {
+            const stateStore = new StateStore_1.StateStore(nodeId);
+            await stateStore.initialize(tenantId, driveId, driveLocation.userId, driveLocation.siteId);
+            const subscriptionResource = (0, helpers_1.resolveSubscriptionResource)(driveLocation);
+            const webhookHandler = new WebhookHandler_1.WebhookHandler(graphClient, stateStore, subscriptionResource);
+            instance = { stateStore, webhookHandler };
+            OneDriveBusinessTrigger.instances.set(nodeId, instance);
+        }
+        // Create delta processor
+        const deltaProcessor = new DeltaProcessor_1.DeltaProcessor(graphClient, instance.stateStore, drivePath);
+        // Process delta query
+        const triggerEvents = await deltaProcessor.processDeltaQuery(eventFilter);
+        // Clean up old versions periodically
+        const state = instance.stateStore.getState();
+        const processedCount = Object.keys(state.processedVersions).length;
+        if (processedCount > 1000) {
+            await instance.stateStore.cleanupOldVersions(10);
+        }
+        // Convert to workflow data
+        const workflowData = [];
+        if (triggerEvents.length > 0) {
+            workflowData.push(triggerEvents.map(event => ({
+                json: {
+                    event: event.eventType,
+                    timestamp: event.timestamp,
+                    item: event.item,
+                },
+            })));
+        }
+        return workflowData;
+    }
+}
+exports.OneDriveBusinessTrigger = OneDriveBusinessTrigger;
+// Store instances for cleanup
+OneDriveBusinessTrigger.instances = new Map();

package/dist/onedrive.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64"><path d="M41.8 17H41c-7.3 0-13.4 5.3-14.7 12.3-.6-.1-1.2-.2-1.8-.2-6.5 0-11.9 4.6-13.2 10.8C5 40.8 0 46.1 0 52.5c0 6.4 5.2 11.5 11.5 11.5h31.9c11.4 0 20.6-9.2 20.6-20.6 0-10.4-7.7-19-17.7-20.3-1.1-9.9-9.5-17.6-19.5-17.6z" fill="#0078D4"/></svg>

package/dist/types.d.ts

@@ -0,0 +1,218 @@
+/**
+ * TypeScript Type Definitions for OneDrive Business Node
+ *
+ * These types are based on Microsoft Graph API v1.0 responses
+ * and are used throughout the OneDrive Business custom node.
+ */
+/**
+ * Microsoft Graph DriveItem representation
+ * Reference: https://learn.microsoft.com/en-us/graph/api/resources/driveitem
+ */
+export interface DriveItem {
+    id: string;
+    name: string;
+    size: number;
+    webUrl: string;
+    createdDateTime: string;
+    lastModifiedDateTime: string;
+    eTag: string;
+    cTag: string;
+    parentReference?: {
+        driveId: string;
+        driveType: string;
+        id: string;
+        path: string;
+    };
+    file?: {
+        mimeType: string;
+        hashes?: {
+            quickXorHash?: string;
+            sha1Hash?: string;
+            sha256Hash?: string;
+        };
+    };
+    folder?: {
+        childCount: number;
+    };
+    fileSystemInfo?: {
+        createdDateTime: string;
+        lastModifiedDateTime: string;
+    };
+    deleted?: {
+        state: string;
+    };
+    shared?: {
+        scope: string;
+        owner?: {
+            user?: {
+                displayName: string;
+                id: string;
+            };
+        };
+    };
+    '@microsoft.graph.downloadUrl'?: string;
+}
+/**
+ * Delta Query Response from Microsoft Graph
+ * Used for tracking changes in OneDrive
+ */
+export interface DeltaResponse {
+    value: DriveItem[];
+    '@odata.nextLink'?: string;
+    '@odata.deltaLink'?: string;
+}
+/**
+ * Microsoft Graph Webhook Notification
+ * Received when a change occurs in the subscribed resource
+ */
+export interface WebhookNotification {
+    subscriptionId: string;
+    clientState?: string;
+    expirationDateTime: string;
+    resource: string;
+    changeType: string;
+    resourceData?: {
+        id: string;
+        '@odata.type': string;
+        '@odata.id': string;
+    };
+}
+/**
+ * Webhook validation request from Microsoft Graph
+ * Sent when creating a new subscription
+ */
+export interface WebhookValidationRequest {
+    validationToken: string;
+}
+/**
+ * Microsoft Graph Subscription (Webhook)
+ * Reference: https://learn.microsoft.com/en-us/graph/api/resources/subscription
+ */
+export interface GraphSubscription {
+    id: string;
+    resource: string;
+    changeType: string;
+    notificationUrl: string;
+    expirationDateTime: string;
+    clientState?: string;
+    creatorId?: string;
+}
+/**
+ * Persistent state for OneDrive Business Trigger Node
+ * Stored between workflow executions to maintain deduplication
+ */
+export interface NodeState {
+    tenantId: string;
+    driveId: string;
+    userId?: string;
+    siteId?: string;
+    deltaLink: string | null;
+    lastDeltaQuery: number;
+    processedVersions: Record<string, boolean>;
+    lastKnownItems: Record<string, {
+        eTag: string;
+        lastModifiedDateTime: string;
+    }>;
+    subscriptionId?: string;
+    subscriptionExpiration?: number;
+}
+/**
+ * File stability tracking
+ * Used to determine if a file is still being uploaded/modified
+ */
+export interface FileStabilityInfo {
+    itemId: string;
+    eTag: string;
+    size: number;
+    lastModifiedDateTime: string;
+    hasHash: boolean;
+    isStable: boolean;
+    firstSeen: number;
+    lastChecked: number;
+}
+/**
+ * Event emitted by the trigger node
+ */
+export interface TriggerEvent {
+    eventType: 'file.created' | 'file.updated' | 'folder.created' | 'folder.updated';
+    item: DriveItem;
+    timestamp: string;
+}
+/**
+ * OAuth2 Credentials structure
+ */
+export interface OneDriveBusinessCredentials {
+    clientId: string;
+    clientSecret: string;
+    tenantId: string;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    tokenType: string;
+}
+/**
+ * Drive resolution options
+ */
+export interface DriveLocation {
+    type: 'user' | 'site';
+    userId?: string;
+    siteId?: string;
+}
+/**
+ * Graph API Error Response
+ */
+export interface GraphError {
+    error: {
+        code: string;
+        message: string;
+        innerError?: {
+            code: string;
+            message: string;
+            date: string;
+            'request-id': string;
+            'client-request-id': string;
+        };
+    };
+}
+/**
+ * Share link creation request
+ */
+export interface ShareLinkRequest {
+    type: 'view' | 'edit' | 'embed';
+    scope?: 'anonymous' | 'organization';
+    password?: string;
+    expirationDateTime?: string;
+}
+/**
+ * Share link response
+ */
+export interface ShareLinkResponse {
+    id: string;
+    roles: string[];
+    link: {
+        type: string;
+        scope: string;
+        webUrl: string;
+        webHtml?: string;
+        application?: {
+            id: string;
+            displayName: string;
+        };
+    };
+}
+/**
+ * Pagination helper for Graph API
+ */
+export interface PaginatedResponse<T> {
+    value: T[];
+    '@odata.nextLink'?: string;
+}
+/**
+ * Retry configuration for API calls
+ */
+export interface RetryConfig {
+    maxRetries: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * TypeScript Type Definitions for OneDrive Business Node
+ *
+ * These types are based on Microsoft Graph API v1.0 responses
+ * and are used throughout the OneDrive Business custom node.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });