n8n-nodes-onedrive-business 1.0.0

package/dist/utils/helpers.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphError = exports.cleanupProcessedVersions = exports.buildVersionKey = exports.getMimeType = exports.isFolder = exports.isFile = exports.isValidItemId = exports.generateSecureRandomString = exports.parseRetryAfter = exports.sleep = exports.calculateBackoffDelay = exports.formatBytes = exports.getFileExtension = exports.buildItemPath = exports.sanitizePath = exports.resolveSubscriptionResource = exports.resolveDrivePath = void 0;
+/**
+ * Helper Functions for OneDrive Business Node
+ *
+ * These utilities handle common operations like drive resolution,
+ * path sanitization, and binary data handling.
+ */
+/**
+ * Resolve the drive path for Microsoft Graph API
+ *
+ * OneDrive Business drives are accessed through:
+ * - User context: /users/{userId}/drive
+ * - Site context: /sites/{siteId}/drive
+ *
+ * NEVER use /me/drive without tenant context
+ */
+function resolveDrivePath(location) {
+    if (location.type === 'user' && location.userId) {
+        return `/users/${location.userId}/drive`;
+    }
+    if (location.type === 'site' && location.siteId) {
+        return `/sites/${location.siteId}/drive`;
+    }
+    throw new Error('Invalid drive location. Must specify either userId for user drive or siteId for site drive.');
+}
+exports.resolveDrivePath = resolveDrivePath;
+/**
+ * Resolve the subscription resource for webhooks
+ *
+ * For delta queries and webhooks, we use:
+ * - User context: /users/{userId}/drive/root
+ * - Site context: /sites/{siteId}/drive
+ */
+function resolveSubscriptionResource(location) {
+    if (location.type === 'user' && location.userId) {
+        return `/users/${location.userId}/drive/root`;
+    }
+    if (location.type === 'site' && location.siteId) {
+        return `/sites/${location.siteId}/drive`;
+    }
+    throw new Error('Invalid drive location for subscription. Must specify either userId or siteId.');
+}
+exports.resolveSubscriptionResource = resolveSubscriptionResource;
+/**
+ * Sanitize file or folder path for OneDrive API
+ *
+ * - Removes leading/trailing slashes
+ * - Converts backslashes to forward slashes
+ * - Encodes special characters
+ */
+function sanitizePath(path) {
+    if (!path) {
+        return '';
+    }
+    // Convert backslashes to forward slashes
+    let sanitized = path.replace(/\\/g, '/');
+    // Remove leading and trailing slashes
+    sanitized = sanitized.replace(/^\/+|\/+$/g, '');
+    // Encode special characters but preserve forward slashes
+    const parts = sanitized.split('/');
+    const encodedParts = parts.map(part => encodeURIComponent(part));
+    return encodedParts.join('/');
+}
+exports.sanitizePath = sanitizePath;
+/**
+ * Build the full item path for OneDrive API
+ *
+ * Constructs paths like:
+ * - /drive/root:/Documents/file.pdf
+ * - /drive/items/{itemId}
+ */
+function buildItemPath(drivePath, itemPath, itemId) {
+    if (itemId) {
+        return `${drivePath}/items/${itemId}`;
+    }
+    if (itemPath) {
+        const sanitized = sanitizePath(itemPath);
+        if (sanitized) {
+            return `${drivePath}/root:/${sanitized}`;
+        }
+        return `${drivePath}/root`;
+    }
+    return `${drivePath}/root`;
+}
+exports.buildItemPath = buildItemPath;
+/**
+ * Extract file extension from filename
+ */
+function getFileExtension(filename) {
+    const lastDot = filename.lastIndexOf('.');
+    if (lastDot === -1 || lastDot === 0) {
+        return '';
+    }
+    return filename.substring(lastDot + 1).toLowerCase();
+}
+exports.getFileExtension = getFileExtension;
+/**
+ * Format bytes to human-readable size
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+exports.formatBytes = formatBytes;
+/**
+ * Calculate exponential backoff delay for retries
+ *
+ * Used for throttling (429) and transient errors
+ */
+function calculateBackoffDelay(retryCount, initialDelayMs = 1000, maxDelayMs = 60000, backoffMultiplier = 2) {
+    const delay = initialDelayMs * Math.pow(backoffMultiplier, retryCount);
+    return Math.min(delay, maxDelayMs);
+}
+exports.calculateBackoffDelay = calculateBackoffDelay;
+/**
+ * Sleep for specified milliseconds
+ * Used in retry logic
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+/**
+ * Parse Retry-After header from 429 responses
+ * Returns delay in milliseconds
+ */
+function parseRetryAfter(retryAfterHeader) {
+    if (!retryAfterHeader) {
+        return 1000; // Default 1 second
+    }
+    // Try to parse as seconds (integer)
+    const seconds = parseInt(retryAfterHeader, 10);
+    if (!isNaN(seconds)) {
+        return seconds * 1000;
+    }
+    // Try to parse as HTTP date
+    const date = new Date(retryAfterHeader);
+    if (!isNaN(date.getTime())) {
+        const delayMs = date.getTime() - Date.now();
+        return Math.max(0, delayMs);
+    }
+    return 1000; // Default 1 second
+}
+exports.parseRetryAfter = parseRetryAfter;
+/**
+ * Generate a cryptographically secure random string
+ * Used for clientState in webhook subscriptions
+ */
+function generateSecureRandomString(length = 32) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const crypto = require('crypto');
+    const randomBytes = crypto.randomBytes(length);
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars[randomBytes[i] % chars.length];
+    }
+    return result;
+}
+exports.generateSecureRandomString = generateSecureRandomString;
+/**
+ * Validate Microsoft Graph item ID format
+ */
+function isValidItemId(itemId) {
+    if (!itemId || typeof itemId !== 'string') {
+        return false;
+    }
+    // Graph item IDs are typically base64-encoded strings
+    // They should not contain spaces or special characters except !, _, -, and =
+    return /^[A-Za-z0-9!_\-=]+$/.test(itemId);
+}
+exports.isValidItemId = isValidItemId;
+/**
+ * Check if an item is a file (vs folder)
+ */
+function isFile(item) {
+    return !!item.file && !item.folder;
+}
+exports.isFile = isFile;
+/**
+ * Check if an item is a folder (vs file)
+ */
+function isFolder(item) {
+    return !!item.folder && !item.file;
+}
+exports.isFolder = isFolder;
+/**
+ * Extract MIME type from DriveItem
+ */
+function getMimeType(item) {
+    var _a;
+    return ((_a = item.file) === null || _a === void 0 ? void 0 : _a.mimeType) || 'application/octet-stream';
+}
+exports.getMimeType = getMimeType;
+/**
+ * Build a version key for deduplication
+ * Format: ${itemId}_${eTag}
+ */
+function buildVersionKey(itemId, eTag) {
+    return `${itemId}_${eTag}`;
+}
+exports.buildVersionKey = buildVersionKey;
+/**
+ * Clean up old processed versions to prevent memory bloat
+ * Keeps only the most recent maxVersions per item
+ */
+function cleanupProcessedVersions(processedVersions, maxVersionsPerItem = 10) {
+    // Group by itemId
+    const itemVersions = {};
+    for (const versionKey of Object.keys(processedVersions)) {
+        const [itemId] = versionKey.split('_');
+        if (!itemVersions[itemId]) {
+            itemVersions[itemId] = [];
+        }
+        itemVersions[itemId].push(versionKey);
+    }
+    // Keep only the most recent versions
+    const cleaned = {};
+    for (const itemId of Object.keys(itemVersions)) {
+        const versions = itemVersions[itemId];
+        // Keep the last N versions
+        const toKeep = versions.slice(-maxVersionsPerItem);
+        for (const versionKey of toKeep) {
+            cleaned[versionKey] = true;
+        }
+    }
+    return cleaned;
+}
+exports.cleanupProcessedVersions = cleanupProcessedVersions;
+/**
+ * Parse Graph API error response
+ */
+function parseGraphError(error) {
+    if (error === null || error === void 0 ? void 0 : error.error) {
+        return {
+            code: error.error.code || 'UnknownError',
+            message: error.error.message || 'An unknown error occurred',
+        };
+    }
+    return {
+        code: 'UnknownError',
+        message: (error === null || error === void 0 ? void 0 : error.message) || 'An unknown error occurred',
+    };
+}
+exports.parseGraphError = parseGraphError;

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "n8n-nodes-onedrive-business",
+    "version": "1.0.0",
+    "description": "n8n custom node for OneDrive Business with robust deduplication and webhook triggers",
+    "keywords": [
+        "n8n",
+        "n8n-nodes",
+        "onedrive",
+        "onedrive-business",
+        "sharepoint",
+        "microsoft-graph"
+    ],
+    "license": "MIT",
+    "homepage": "",
+    "author": {
+        "name": "CS1ANHNT",
+        "email": "anhntuyentuan713@gmail.com"
+    },
+    "repository": {
+        "type": "git",
+        "url": ""
+    },
+    "main": "index.js",
+    "scripts": {
+        "build": "tsc && npm run copy-icons",
+        "copy-icons": "copyfiles -u 1 \"nodes/**/*.{png,svg}\" dist/",
+        "dev": "tsc --watch",
+        "format": "prettier nodes --write",
+        "lint": "tslint -p tsconfig.json -c tslint.json",
+        "lintfix": "tslint --fix -p tsconfig.json -c tslint.json",
+        "prepublishOnly": "npm run build"
+    },
+    "files": [
+        "dist"
+    ],
+    "n8n": {
+        "n8nNodesApiVersion": 1,
+        "credentials": [
+            "dist/credentials/OneDriveBusinessOAuth2.credentials.js"
+        ],
+        "nodes": [
+            "dist/nodes/OneDriveBusiness.node.js",
+            "dist/nodes/OneDriveBusinessTrigger.node.js"
+        ]
+    },
+    "devDependencies": {
+        "@types/node": "^18.0.0",
+        "copyfiles": "^2.4.1",
+        "prettier": "^2.7.1",
+        "tslint": "^6.1.3",
+        "typescript": "^5.3.3"
+    },
+    "dependencies": {
+        "n8n-workflow": "^1.0.0"
+    }
+}