n8n-nodes-onedrive-business-sp 1.0.0

package/README.md

@@ -0,0 +1,272 @@
+# Microsoft OneDrive (Business) Node for n8n
+
+This is a complete implementation of a Microsoft OneDrive for Business node for n8n, built on SharePoint Document Library with Microsoft Graph API.
+
+## 🚀 Features
+
+### Resources & Operations
+
+#### File Operations
+- ✅ **Delete** - Remove files from OneDrive
+- ✅ **Download** - Download file content as binary data
+- ✅ **Get** - Retrieve file metadata
+- ✅ **Rename** - Change file names
+- ✅ **Search** - Find files by query
+- ✅ **Share** - Create sharing links with configurable permissions
+- ✅ **Upload** - Upload files from binary data
+
+#### Folder Operations
+- ✅ **Create** - Create new folders
+- ✅ **Delete** - Remove folders
+- ✅ **Get Items** - List contents of a folder
+- ✅ **Rename** - Change folder names
+- ✅ **Search** - Find folders by query
+- ✅ **Share** - Create sharing links with configurable permissions
+
+### Triggers (Webhook-based)
+- ⚡ **On File Created** - Triggers when a new file is created
+- ⚡ **On File Updated** - Triggers when a file is modified
+- ⚡ **On Folder Created** - Triggers when a new folder is created
+- ⚡ **On Folder Updated** - Triggers when a folder is modified
+
+## 📋 Prerequisites
+
+### Microsoft Azure App Registration
+
+1. Go to [Azure Portal](https://portal.azure.com/)
+2. Navigate to **Azure Active Directory** > **App registrations** > **New registration**
+3. Configure:
+   - Name: `n8n OneDrive Business Integration`
+   - Supported account types: **Accounts in any organizational directory**
+   - Redirect URI: `https://your-n8n-instance.com/rest/oauth2-credential/callback`
+
+4. After creation, note down:
+   - **Application (client) ID**
+   - **Directory (tenant) ID**
+
+5. Go to **Certificates & secrets** > **New client secret**
+   - Note down the **Client secret value** (shown only once!)
+
+6. Go to **API permissions** > **Add a permission** > **Microsoft Graph** > **Delegated permissions**
+   - Add these permissions:
+     - `Files.ReadWrite.All`
+     - `Sites.Read.All`
+     - `Sites.ReadWrite.All`
+     - `offline_access`
+   - Click **Grant admin consent**
+
+## 🔧 Installation
+
+### For n8n Community Nodes
+
+1. **Copy Files to n8n Custom Nodes Directory:**
+
+```bash
+# Navigate to your n8n installation
+cd ~/.n8n/custom
+
+# Create directory structure
+mkdir -p nodes/MicrosoftOneDriveBusiness
+mkdir -p credentials
+
+# Copy credential file
+cp credentials/MicrosoftOneDriveBusinessOAuth2Api.credentials.ts ~/.n8n/custom/credentials/
+
+# Copy node files
+cp nodes/MicrosoftOneDriveBusiness/* ~/.n8n/custom/nodes/MicrosoftOneDriveBusiness/
+```
+
+2. **Install as Community Node (Alternative):**
+
+If published as an npm package:
+
+```bash
+# In n8n UI: Settings > Community Nodes > Install
+# Package name: n8n-nodes-microsoft-onedrive-business
+```
+
+### For Development
+
+```bash
+# Clone repository
+git clone <repository-url>
+cd n8n-onedrive-business
+
+# Install dependencies
+npm install
+
+# Link to n8n
+npm link
+
+# In your n8n directory
+npm link n8n-nodes-microsoft-onedrive-business
+```
+
+## ⚙️ Configuration
+
+### 1. Add Credentials in n8n
+
+1. Go to **Credentials** > **New** > **Microsoft OneDrive (Business) OAuth2 API**
+2. Enter:
+   - **Client ID**: Your Azure App's Application (client) ID
+   - **Client Secret**: Your Azure App's client secret
+3. Click **Connect my account** and authorize
+
+### 2. Get Site ID and Drive ID
+
+To use the node, you need your SharePoint site ID:
+
+**Get Site ID:**
+```bash
+GET https://graph.microsoft.com/v1.0/sites/{hostname}:/{site-path}
+```
+
+Example:
+```bash
+GET https://graph.microsoft.com/v1.0/sites/contoso.sharepoint.com:/sites/TeamSite
+```
+
+**Get Drive ID** (optional - will auto-fetch if not provided):
+```bash
+GET https://graph.microsoft.com/v1.0/sites/{site-id}/drive
+```
+
+## 📖 Usage Examples
+
+### Example 1: Upload a File
+
+```typescript
+{
+  "nodes": [
+    {
+      "parameters": {
+        "resource": "file",
+        "operation": "upload",
+        "siteId": "contoso.sharepoint.com,abc123,def456",
+        "parentFolderId": "root",
+        "fileName": "report.pdf",
+        "binaryPropertyName": "data"
+      },
+      "name": "Upload to OneDrive",
+      "type": "n8n-nodes-microsoftOneDriveBusiness.microsoftOneDriveBusiness",
+      "credentials": {
+        "microsoftOneDriveBusinessOAuth2Api": "OneDrive Business Credentials"
+      }
+    }
+  ]
+}
+```
+
+### Example 2: Search and Download Files
+
+```typescript
+{
+  "nodes": [
+    {
+      "parameters": {
+        "resource": "file",
+        "operation": "search",
+        "siteId": "contoso.sharepoint.com,abc123,def456",
+        "query": "quarterly report"
+      },
+      "name": "Search Files"
+    },
+    {
+      "parameters": {
+        "resource": "file",
+        "operation": "download",
+        "fileId": "={{ $json.id }}",
+        "binaryProperty": "data"
+      },
+      "name": "Download File"
+    }
+  ]
+}
+```
+
+### Example 3: Trigger on New Files
+
+```typescript
+{
+  "nodes": [
+    {
+      "parameters": {
+        "siteId": "contoso.sharepoint.com,abc123,def456",
+        "event": "fileCreated",
+        "watchFolderId": "root"
+      },
+      "name": "OneDrive Trigger",
+      "type": "n8n-nodes-microsoftOneDriveBusiness.microsoftOneDriveBusinessTrigger"
+    }
+  ]
+}
+```
+
+## 🔑 Key Differences from OneDrive Personal
+
+| Feature | OneDrive Personal | OneDrive Business |
+|---------|-------------------|-------------------|
+| Backend | Consumer OneDrive | SharePoint |
+| Drive Type | `personal` | `business` |
+| API Base | `/me/drive` | `/sites/{id}/drive` |
+| Authentication | Personal Microsoft Account | Azure AD (Work/School) |
+| Organization Features | ❌ | ✅ (Sharing policies, DLP, etc.) |
+
+## 🛠️ API Endpoints Used
+
+- `GET /sites/{site-id}/drive` - Get drive information
+- `PUT /drives/{drive-id}/items/{parent-id}:/{filename}:/content` - Upload file
+- `GET /drives/{drive-id}/items/{item-id}/content` - Download file
+- `GET /drives/{drive-id}/items/{item-id}` - Get metadata
+- `DELETE /drives/{drive-id}/items/{item-id}` - Delete item
+- `PATCH /drives/{drive-id}/items/{item-id}` - Update item
+- `GET /drives/{drive-id}/root/search(q='{query}')` - Search
+- `POST /drives/{drive-id}/items/{item-id}/createLink` - Create sharing link
+- `POST /subscriptions` - Create webhook subscription (triggers)
+- `GET /drives/{drive-id}/root/delta` - Get delta changes (triggers)
+
+## 🐛 Troubleshooting
+
+### "Drive not found" error
+- Verify your Site ID is correct
+- Ensure user has access to the SharePoint site
+- Check that the drive exists for the site
+
+### "Insufficient privileges" error
+- Verify all required Graph API permissions are granted
+- Ensure admin consent is given for tenant-wide permissions
+- Check that the user has appropriate SharePoint permissions
+
+### Webhook/Trigger not working
+- Ensure your n8n instance is publicly accessible
+- Verify the webhook URL is correct
+- Check that subscriptions are being created (they expire after 72 hours)
+- Microsoft Graph webhook delivery can have delays
+
+### File upload fails
+- Check file size (large files >4MB need resumable upload session)
+- Verify binary data property name is correct
+- Ensure mime type is set correctly
+
+## 📚 Resources
+
+- [Microsoft Graph API Documentation](https://docs.microsoft.com/en-us/graph/api/resources/onedrive)
+- [SharePoint API Documentation](https://docs.microsoft.com/en-us/graph/api/resources/sharepoint)
+- [n8n Node Development](https://docs.n8n.io/integrations/creating-nodes/)
+- [Azure App Registration](https://docs.microsoft.com/en-us/azure/active-directory/develop/quickstart-register-app)
+
+## 📄 License
+
+MIT License - Feel free to use and modify as needed.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please:
+1. Fork the repository
+2. Create a feature branch
+3. Submit a pull request
+
+## ✨ Credits
+
+Built for n8n following official node development guidelines.
+Implements OneDrive for Business (SharePoint) only - does not support OneDrive Personal.

package/dist/credentials/MicrosoftOneDriveBusinessOAuth2Api.credentials.d.ts

@@ -0,0 +1,10 @@
+import { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class MicrosoftOneDriveBusinessOAuth2Api implements ICredentialType {
+    name: string;
+    extends: string[];
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/MicrosoftOneDriveBusinessOAuth2Api.credentials.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrosoftOneDriveBusinessOAuth2Api = void 0;
+class MicrosoftOneDriveBusinessOAuth2Api {
+    constructor() {
+        this.name = 'microsoftOneDriveBusinessOAuth2Api';
+        this.extends = ['oAuth2Api'];
+        this.displayName = 'Microsoft OneDrive (Business) OAuth2 API';
+        this.documentationUrl = 'microsoft';
+        this.properties = [
+            {
+                displayName: 'Grant Type',
+                name: 'grantType',
+                type: 'hidden',
+                default: 'authorizationCode',
+            },
+            {
+                displayName: 'Authorization URL',
+                name: 'authUrl',
+                type: 'hidden',
+                default: 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize',
+            },
+            {
+                displayName: 'Access Token URL',
+                name: 'accessTokenUrl',
+                type: 'hidden',
+                default: 'https://login.microsoftonline.com/common/oauth2/v2.0/token',
+            },
+            {
+                displayName: 'Scope',
+                name: 'scope',
+                type: 'hidden',
+                default: 'Files.ReadWrite.All Sites.Read.All Sites.ReadWrite.All offline_access',
+            },
+            {
+                displayName: 'Auth URI Query Parameters',
+                name: 'authQueryParameters',
+                type: 'hidden',
+                default: 'response_mode=query',
+            },
+            {
+                displayName: 'Authentication',
+                name: 'authentication',
+                type: 'hidden',
+                default: 'body',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '={{"Bearer " + $credentials.oauthTokenData.access_token}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://graph.microsoft.com/v1.0',
+                url: '/me',
+            },
+        };
+    }
+}
+exports.MicrosoftOneDriveBusinessOAuth2Api = MicrosoftOneDriveBusinessOAuth2Api;

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

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class MicrosoftOneDriveBusiness implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

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

@@ -0,0 +1,583 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrosoftOneDriveBusiness = void 0;
+class MicrosoftOneDriveBusiness {
+    constructor() {
+        this.description = {
+            displayName: 'Microsoft OneDrive (Business)',
+            name: 'microsoftOneDriveBusiness',
+            icon: 'file:onedrive.svg',
+            group: ['input', 'output'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Work with OneDrive for Business (SharePoint)',
+            defaults: {
+                name: 'Microsoft OneDrive (Business)',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'microsoftOneDriveBusinessOAuth2Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'File',
+                            value: 'file',
+                        },
+                        {
+                            name: 'Folder',
+                            value: 'folder',
+                        },
+                    ],
+                    default: 'file',
+                },
+                // File Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a file',
+                            action: 'Delete a file',
+                        },
+                        {
+                            name: 'Download',
+                            value: 'download',
+                            description: 'Download a file',
+                            action: 'Download a file',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get file metadata',
+                            action: 'Get a file',
+                        },
+                        {
+                            name: 'Rename',
+                            value: 'rename',
+                            description: 'Rename a file',
+                            action: 'Rename a file',
+                        },
+                        {
+                            name: 'Search',
+                            value: 'search',
+                            description: 'Search for files',
+                            action: 'Search files',
+                        },
+                        {
+                            name: 'Share',
+                            value: 'share',
+                            description: 'Share a file',
+                            action: 'Share a file',
+                        },
+                        {
+                            name: 'Upload',
+                            value: 'upload',
+                            description: 'Upload a file',
+                            action: 'Upload a file',
+                        },
+                    ],
+                    default: 'upload',
+                },
+                // Folder Operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a folder',
+                            action: 'Create a folder',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Delete a folder',
+                            action: 'Delete a folder',
+                        },
+                        {
+                            name: 'Get Items',
+                            value: 'getItems',
+                            description: 'Get items in a folder',
+                            action: 'Get items in a folder',
+                        },
+                        {
+                            name: 'Rename',
+                            value: 'rename',
+                            description: 'Rename a folder',
+                            action: 'Rename a folder',
+                        },
+                        {
+                            name: 'Search',
+                            value: 'search',
+                            description: 'Search for folders',
+                            action: 'Search folders',
+                        },
+                        {
+                            name: 'Share',
+                            value: 'share',
+                            description: 'Share a folder',
+                            action: 'Share a folder',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Common Fields
+                {
+                    displayName: 'Site ID',
+                    name: 'siteId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'The SharePoint site ID',
+                },
+                {
+                    displayName: 'Drive ID',
+                    name: 'driveId',
+                    type: 'string',
+                    default: '',
+                    description: 'The drive ID. If not specified, the default drive for the site will be used.',
+                },
+                // File: Delete
+                {
+                    displayName: 'File ID',
+                    name: 'fileId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['delete', 'get', 'download', 'rename', 'share'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The ID of the file',
+                },
+                // File: Upload
+                {
+                    displayName: 'Parent Folder ID',
+                    name: 'parentFolderId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                        },
+                    },
+                    default: 'root',
+                    description: 'The ID of the parent folder. Use "root" for the root folder.',
+                },
+                {
+                    displayName: 'File Name',
+                    name: 'fileName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The name of the file to upload',
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['upload'],
+                        },
+                    },
+                    default: 'data',
+                    required: true,
+                    description: 'Name of the binary property containing the file data',
+                },
+                // File: Rename
+                {
+                    displayName: 'New Name',
+                    name: 'newName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['rename'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The new name for the file or folder',
+                },
+                // File: Search
+                {
+                    displayName: 'Query',
+                    name: 'query',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['search'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The search query',
+                },
+                // File: Share
+                {
+                    displayName: 'Link Type',
+                    name: 'linkType',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['share'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'View',
+                            value: 'view',
+                            description: 'View only',
+                        },
+                        {
+                            name: 'Edit',
+                            value: 'edit',
+                            description: 'Edit access',
+                        },
+                        {
+                            name: 'Embed',
+                            value: 'embed',
+                            description: 'Embed link',
+                        },
+                    ],
+                    default: 'view',
+                    description: 'The type of sharing link to create',
+                },
+                {
+                    displayName: 'Link Scope',
+                    name: 'linkScope',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            resource: ['file', 'folder'],
+                            operation: ['share'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Anonymous',
+                            value: 'anonymous',
+                            description: 'Anyone with the link',
+                        },
+                        {
+                            name: 'Organization',
+                            value: 'organization',
+                            description: 'People in your organization',
+                        },
+                    ],
+                    default: 'organization',
+                    description: 'The scope of the sharing link',
+                },
+                // Folder: Create
+                {
+                    displayName: 'Folder Name',
+                    name: 'folderName',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                            operation: ['create'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The name of the folder to create',
+                },
+                {
+                    displayName: 'Parent Folder ID',
+                    name: 'parentFolderId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                            operation: ['create', 'getItems'],
+                        },
+                    },
+                    default: 'root',
+                    description: 'The ID of the parent folder. Use "root" for the root folder.',
+                },
+                // Folder: Delete, Rename, Share
+                {
+                    displayName: 'Folder ID',
+                    name: 'folderId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['folder'],
+                            operation: ['delete', 'rename', 'share'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'The ID of the folder',
+                },
+                // Download Options
+                {
+                    displayName: 'Put Output in Field',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            resource: ['file'],
+                            operation: ['download'],
+                        },
+                    },
+                    default: 'data',
+                    required: true,
+                    description: 'The name of the output binary field to put the file in',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        let responseData = {};
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const siteId = this.getNodeParameter('siteId', i);
+                const driveId = this.getNodeParameter('driveId', i, '');
+                // Get drive ID if not provided
+                let actualDriveId = driveId;
+                if (!actualDriveId) {
+                    const driveResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                        method: 'GET',
+                        url: `https://graph.microsoft.com/v1.0/sites/${siteId}/drive`,
+                        json: true,
+                    });
+                    actualDriveId = driveResponse.id;
+                }
+                if (resource === 'file') {
+                    // FILE OPERATIONS
+                    if (operation === 'delete') {
+                        const fileId = this.getNodeParameter('fileId', i);
+                        await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'DELETE',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${fileId}`,
+                            json: true,
+                        });
+                        responseData = { success: true, fileId };
+                    }
+                    else if (operation === 'download') {
+                        const fileId = this.getNodeParameter('fileId', i);
+                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
+                        // Get file metadata first
+                        const fileMetadata = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${fileId}`,
+                            json: true,
+                        });
+                        // Download file content
+                        const fileContent = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${fileId}/content`,
+                            json: false,
+                            encoding: null,
+                        });
+                        const fileName = fileMetadata.name || 'file';
+                        const mimeType = fileMetadata.file?.mimeType || undefined;
+                        const binaryData = await this.helpers.prepareBinaryData(fileContent, fileName, mimeType);
+                        returnData.push({
+                            json: fileMetadata,
+                            binary: {
+                                [binaryProperty]: binaryData,
+                            },
+                        });
+                        continue;
+                    }
+                    else if (operation === 'get') {
+                        const fileId = this.getNodeParameter('fileId', i);
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${fileId}`,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'rename') {
+                        const fileId = this.getNodeParameter('fileId', i);
+                        const newName = this.getNodeParameter('newName', i);
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'PATCH',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${fileId}`,
+                            body: {
+                                name: newName,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'search') {
+                        const query = this.getNodeParameter('query', i);
+                        const result = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/root/search(q='${encodeURIComponent(query)}')`,
+                            json: true,
+                        });
+                        const items = result.value || [];
+                        responseData = items.filter((item) => item.file !== undefined);
+                    }
+                    else if (operation === 'share') {
+                        const fileId = this.getNodeParameter('fileId', i);
+                        const linkType = this.getNodeParameter('linkType', i);
+                        const linkScope = this.getNodeParameter('linkScope', i);
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'POST',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${fileId}/createLink`,
+                            body: {
+                                type: linkType,
+                                scope: linkScope,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'upload') {
+                        const parentFolderId = this.getNodeParameter('parentFolderId', i);
+                        const fileName = this.getNodeParameter('fileName', i);
+                        const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
+                        const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
+                        const fileBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+                        const parentPath = parentFolderId === 'root' ? 'root' : `items/${parentFolderId}`;
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'PUT',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/${parentPath}:/${fileName}:/content`,
+                            body: fileBuffer,
+                            headers: {
+                                'Content-Type': binaryData.mimeType || 'application/octet-stream',
+                            },
+                            json: true,
+                        });
+                    }
+                }
+                else if (resource === 'folder') {
+                    // FOLDER OPERATIONS
+                    if (operation === 'create') {
+                        const folderName = this.getNodeParameter('folderName', i);
+                        const parentFolderId = this.getNodeParameter('parentFolderId', i);
+                        const parentPath = parentFolderId === 'root' ? 'root' : `items/${parentFolderId}`;
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'POST',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/${parentPath}/children`,
+                            body: {
+                                name: folderName,
+                                folder: {},
+                                '@microsoft.graph.conflictBehavior': 'rename',
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'delete') {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'DELETE',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${folderId}`,
+                            json: true,
+                        });
+                        responseData = { success: true, folderId };
+                    }
+                    else if (operation === 'getItems') {
+                        const parentFolderId = this.getNodeParameter('parentFolderId', i);
+                        const parentPath = parentFolderId === 'root' ? 'root' : `items/${parentFolderId}`;
+                        const result = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/${parentPath}/children`,
+                            json: true,
+                        });
+                        responseData = result.value || [];
+                    }
+                    else if (operation === 'rename') {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        const newName = this.getNodeParameter('newName', i);
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'PATCH',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${folderId}`,
+                            body: {
+                                name: newName,
+                            },
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'search') {
+                        const query = this.getNodeParameter('query', i);
+                        const result = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/root/search(q='${encodeURIComponent(query)}')`,
+                            json: true,
+                        });
+                        const items = result.value || [];
+                        responseData = items.filter((item) => item.folder !== undefined);
+                    }
+                    else if (operation === 'share') {
+                        const folderId = this.getNodeParameter('folderId', i);
+                        const linkType = this.getNodeParameter('linkType', i);
+                        const linkScope = this.getNodeParameter('linkScope', i);
+                        responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'POST',
+                            url: `https://graph.microsoft.com/v1.0/drives/${actualDriveId}/items/${folderId}/createLink`,
+                            body: {
+                                type: linkType,
+                                scope: linkScope,
+                            },
+                            json: true,
+                        });
+                    }
+                }
+                if (Array.isArray(responseData)) {
+                    returnData.push(...responseData.map((item) => ({ json: item })));
+                }
+                else {
+                    returnData.push({ json: responseData });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    returnData.push({ json: { error: errorMessage } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.MicrosoftOneDriveBusiness = MicrosoftOneDriveBusiness;

package/dist/nodes/MicrosoftOneDriveBusiness/MicrosoftOneDriveBusinessTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class MicrosoftOneDriveBusinessTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

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

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrosoftOneDriveBusinessTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class MicrosoftOneDriveBusinessTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Microsoft OneDrive (Business) Trigger',
+            name: 'microsoftOneDriveBusinessTrigger',
+            icon: 'file:onedrive.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Triggers when OneDrive for Business events occur',
+            defaults: {
+                name: 'OneDrive (Business) Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'microsoftOneDriveBusinessOAuth2Api',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Site ID',
+                    name: 'siteId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'The SharePoint site ID',
+                },
+                {
+                    displayName: 'Drive ID',
+                    name: 'driveId',
+                    type: 'string',
+                    default: '',
+                    description: 'The drive ID. If not specified, the default drive for the site will be used.',
+                },
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    options: [
+                        {
+                            name: '⚡ On File Created',
+                            value: 'fileCreated',
+                            description: 'Trigger when a file is created',
+                        },
+                        {
+                            name: '⚡ On File Updated',
+                            value: 'fileUpdated',
+                            description: 'Trigger when a file is updated',
+                        },
+                        {
+                            name: '⚡ On Folder Created',
+                            value: 'folderCreated',
+                            description: 'Trigger when a folder is created',
+                        },
+                        {
+                            name: '⚡ On Folder Updated',
+                            value: 'folderUpdated',
+                            description: 'Trigger when a folder is updated',
+                        },
+                    ],
+                    default: 'fileCreated',
+                    description: 'The event to trigger on',
+                },
+                {
+                    displayName: 'Watch Folder ID',
+                    name: 'watchFolderId',
+                    type: 'string',
+                    default: 'root',
+                    description: 'The ID of the folder to watch. Use "root" to watch the entire drive.',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Poll Interval (minutes)',
+                            name: 'pollInterval',
+                            type: 'number',
+                            default: 5,
+                            description: 'How often to poll for changes (in minutes)',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.subscriptionId === undefined) {
+                        return false;
+                    }
+                    const siteId = this.getNodeParameter('siteId');
+                    const driveId = this.getNodeParameter('driveId', '');
+                    // Get drive ID if not provided
+                    let actualDriveId = driveId;
+                    if (!actualDriveId) {
+                        const driveResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/sites/${siteId}/drive`,
+                            json: true,
+                        });
+                        actualDriveId = driveResponse.id;
+                    }
+                    try {
+                        await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/subscriptions/${webhookData.subscriptionId}`,
+                            json: true,
+                        });
+                        return true;
+                    }
+                    catch (error) {
+                        return false;
+                    }
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const siteId = this.getNodeParameter('siteId');
+                    const driveId = this.getNodeParameter('driveId', '');
+                    const watchFolderId = this.getNodeParameter('watchFolderId');
+                    // Get drive ID if not provided
+                    let actualDriveId = driveId;
+                    if (!actualDriveId) {
+                        const driveResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'GET',
+                            url: `https://graph.microsoft.com/v1.0/sites/${siteId}/drive`,
+                            json: true,
+                        });
+                        actualDriveId = driveResponse.id;
+                    }
+                    const watchPath = watchFolderId === 'root' ? 'root' : `items/${watchFolderId}`;
+                    const resource = `/drives/${actualDriveId}/${watchPath}`;
+                    // Create subscription
+                    const expirationDateTime = new Date();
+                    expirationDateTime.setHours(expirationDateTime.getHours() + 72); // 72 hours max
+                    const body = {
+                        changeType: 'updated',
+                        notificationUrl: webhookUrl,
+                        resource,
+                        expirationDateTime: expirationDateTime.toISOString(),
+                        clientState: 'n8n-secret-token',
+                    };
+                    try {
+                        const responseData = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                            method: 'POST',
+                            url: 'https://graph.microsoft.com/v1.0/subscriptions',
+                            body,
+                            json: true,
+                        });
+                        webhookData.subscriptionId = responseData.id;
+                        webhookData.driveId = actualDriveId;
+                        webhookData.deltaLink = null;
+                    }
+                    catch (error) {
+                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Microsoft Graph subscription creation failed: ${errorMessage}`);
+                    }
+                    return true;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.subscriptionId !== undefined) {
+                        try {
+                            await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                                method: 'DELETE',
+                                url: `https://graph.microsoft.com/v1.0/subscriptions/${webhookData.subscriptionId}`,
+                                json: true,
+                            });
+                        }
+                        catch (error) {
+                            return false;
+                        }
+                        delete webhookData.subscriptionId;
+                        delete webhookData.driveId;
+                        delete webhookData.deltaLink;
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const bodyData = this.getBodyData();
+        const query = this.getQueryData();
+        const webhookData = this.getWorkflowStaticData('node');
+        // Handle validation request
+        if (query.validationToken) {
+            return {
+                webhookResponse: query.validationToken,
+            };
+        }
+        // Verify client state
+        const notification = bodyData.value?.[0];
+        if (notification?.clientState !== 'n8n-secret-token') {
+            return {
+                webhookResponse: 'Invalid client state',
+            };
+        }
+        const event = this.getNodeParameter('event');
+        const watchFolderId = this.getNodeParameter('watchFolderId');
+        const driveId = webhookData.driveId;
+        // Use delta query to get changes
+        let deltaUrl = webhookData.deltaLink;
+        if (!deltaUrl) {
+            const watchPath = watchFolderId === 'root' ? 'root' : `items/${watchFolderId}`;
+            deltaUrl = `https://graph.microsoft.com/v1.0/drives/${driveId}/${watchPath}/delta`;
+        }
+        try {
+            const deltaResponse = await this.helpers.requestOAuth2.call(this, 'microsoftOneDriveBusinessOAuth2Api', {
+                method: 'GET',
+                url: deltaUrl,
+                json: true,
+            });
+            // Store the new delta link
+            webhookData.deltaLink = deltaResponse['@odata.deltaLink'];
+            const changes = deltaResponse.value;
+            const filteredChanges = changes.filter((change) => {
+                const isFile = change.file !== undefined;
+                const isFolder = change.folder !== undefined;
+                const isDeleted = change.deleted !== undefined;
+                if (isDeleted)
+                    return false;
+                if (event === 'fileCreated' && isFile) {
+                    return change.createdDateTime === change.lastModifiedDateTime;
+                }
+                else if (event === 'fileUpdated' && isFile) {
+                    return change.createdDateTime !== change.lastModifiedDateTime;
+                }
+                else if (event === 'folderCreated' && isFolder) {
+                    return change.createdDateTime === change.lastModifiedDateTime;
+                }
+                else if (event === 'folderUpdated' && isFolder) {
+                    return change.createdDateTime !== change.lastModifiedDateTime;
+                }
+                return false;
+            });
+            if (filteredChanges.length === 0) {
+                return {
+                    webhookResponse: 'No matching changes',
+                    workflowData: [],
+                };
+            }
+            return {
+                workflowData: [filteredChanges.map((change) => ({ json: change }))],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to fetch delta changes: ${errorMessage}`);
+        }
+    }
+}
+exports.MicrosoftOneDriveBusinessTrigger = MicrosoftOneDriveBusinessTrigger;

package/dist/nodes/MicrosoftOneDriveBusiness/onedrive.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256">
+	<path fill="#0364B8" d="M154.4 90.93A66.31 66.31 0 0 0 92.38 56C64.25 56 41 78.55 40 106.64A63.67 63.67 0 0 0 0 167.68C0 198.16 24.73 223 55.21 223h98.11c36.51 0 66.16-29.65 66.16-66.16a66.37 66.37 0 0 0-65.08-65.91Z"/>
+	<path fill="#0078D4" d="M154.4 90.93A66.28 66.28 0 0 0 92.38 56a66.84 66.84 0 0 0-15.61 1.84a66.33 66.33 0 0 1 77.63 99.33a66.18 66.18 0 0 1 65.08 65.91c0 2.4-.13 4.77-.39 7.1A66.13 66.13 0 0 0 256 156.84a66.37 66.37 0 0 0-101.6-65.91Z"/>
+	<path fill="#1490DF" d="M154.4 90.93a66.54 66.54 0 0 0-3.65-1.52A66.36 66.36 0 0 0 92.38 56a66.84 66.84 0 0 0-15.61 1.84a67 67 0 0 1 9.09 1.16a66.32 66.32 0 0 1 53.48 83.45A63.67 63.67 0 0 0 99.85 120a63.87 63.87 0 0 0-59.85 40.71a63.87 63.87 0 0 1 15.21-54.07A63.67 63.67 0 0 1 95 81.24a66.36 66.36 0 0 1 59.4 9.69Z"/>
+	<path fill="#28A8EA" d="M154.4 90.93a63.67 63.67 0 0 1 44 66.63a66.18 66.18 0 0 1 21.08 65.91H153.32a66.16 66.16 0 0 0 66.16-66.63a66.36 66.36 0 0 0-65.08-65.91Z"/>
+</svg>

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "n8n-nodes-onedrive-business-sp",
+  "version": "1.0.0",
+  "description": "n8n node for Microsoft OneDrive for Business (SharePoint)",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "onedrive",
+    "sharepoint",
+    "microsoft",
+    "graph",
+    "business"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Your Name",
+    "email": "your.email@example.com"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && node copy-icons.js",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json",
+    "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/MicrosoftOneDriveBusinessOAuth2Api.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/MicrosoftOneDriveBusiness/MicrosoftOneDriveBusiness.node.js",
+      "dist/nodes/MicrosoftOneDriveBusiness/MicrosoftOneDriveBusinessTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "eslint-plugin-n8n-nodes-base": "^1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^3.0.0",
+    "typescript": "^5.3.3"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}