n8n-nodes-script-runner 1.0.0 → 1.1.0

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

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

package/dist/nodes/HttpRequestRunner/HttpRequestRunner.node.js

@@ -0,0 +1,357 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpRequestRunner = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const axios_1 = __importDefault(require("axios"));
+const USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/120.0.0.0',
+    'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0',
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0',
+];
+function getRandomUserAgent() {
+    return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+class HttpRequestRunner {
+    constructor() {
+        this.description = {
+            displayName: 'HTTP Request Runner',
+            name: 'httpRequestRunner',
+            icon: 'file:httprequest.svg',
+            group: ['transform'],
+            version: 1,
+            maxNodes: 1,
+            subtitle: '={{$parameter["library"]}}',
+            description: 'Make HTTP requests with axios, fetch, or custom scripts',
+            defaults: {
+                name: 'HTTP Request Runner',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                {
+                    displayName: 'Library',
+                    name: 'library',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Axios',
+                            value: 'axios',
+                            description: 'Promise-based HTTP client with interceptors',
+                        },
+                        {
+                            name: 'Fetch',
+                            value: 'fetch',
+                            description: 'Native fetch API for HTTP requests',
+                        },
+                        {
+                            name: 'Custom Script',
+                            value: 'custom',
+                            description: 'Write custom HTTP request code with all libraries',
+                        },
+                    ],
+                    default: 'axios',
+                    description: 'Choose the library to use for HTTP requests',
+                },
+                {
+                    displayName: 'Method',
+                    name: 'method',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                        },
+                    },
+                    options: [
+                        { name: 'GET', value: 'GET' },
+                        { name: 'POST', value: 'POST' },
+                        { name: 'PUT', value: 'PUT' },
+                        { name: 'PATCH', value: 'PATCH' },
+                        { name: 'DELETE', value: 'DELETE' },
+                        { name: 'HEAD', value: 'HEAD' },
+                        { name: 'OPTIONS', value: 'OPTIONS' },
+                    ],
+                    default: 'GET',
+                    description: 'HTTP method to use',
+                },
+                {
+                    displayName: 'URL',
+                    name: 'url',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                        },
+                    },
+                    default: '',
+                    placeholder: 'https://api.example.com/data',
+                    description: 'The URL to make the request to',
+                    required: true,
+                },
+                {
+                    displayName: 'Headers',
+                    name: 'headers',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                        },
+                    },
+                    default: '{\n  "Content-Type": "application/json"\n}',
+                    description: 'Request headers as JSON object',
+                },
+                {
+                    displayName: 'Random User-Agent',
+                    name: 'randomUserAgent',
+                    type: 'boolean',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                        },
+                    },
+                    default: true,
+                    description: 'Whether to use a random User-Agent header automatically',
+                },
+                {
+                    displayName: 'Body',
+                    name: 'body',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                            method: ['POST', 'PUT', 'PATCH'],
+                        },
+                    },
+                    default: '{}',
+                    description: 'Request body as JSON',
+                },
+                {
+                    displayName: 'Query Parameters',
+                    name: 'queryParams',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                        },
+                    },
+                    default: '{}',
+                    description: 'URL query parameters as JSON object',
+                },
+                {
+                    displayName: 'Timeout (ms)',
+                    name: 'timeout',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            library: ['axios', 'fetch'],
+                        },
+                    },
+                    default: 30000,
+                    description: 'Request timeout in milliseconds',
+                },
+                {
+                    displayName: 'Custom Script',
+                    name: 'script',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            library: ['custom'],
+                        },
+                    },
+                    typeOptions: {
+                        rows: 15,
+                        alwaysOpenEditWindow: true,
+                    },
+                    default: `// Axios example:
+const response = await axios({
+  method: 'GET',
+  url: 'https://api.example.com/data',
+  headers: { 'Content-Type': 'application/json' }
+});
+return response.data;
+
+// Fetch example:
+// const response = await fetch('https://api.example.com/data', {
+//   method: 'POST',
+//   headers: { 'Content-Type': 'application/json' },
+//   body: JSON.stringify({ key: 'value' })
+// });
+// return await response.json();
+
+// Access current item: $item.json
+// Access all items: items`,
+                    description: 'Custom JavaScript code for HTTP requests. Available: axios, fetch, items, $item, itemIndex',
+                },
+                {
+                    displayName: 'Return Full Response',
+                    name: 'returnFullResponse',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to return full response including headers and status',
+                },
+                {
+                    displayName: 'Parallel Execution',
+                    name: 'parallelExecution',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to process items in parallel for faster execution',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const library = this.getNodeParameter('library', 0);
+        const returnFullResponse = this.getNodeParameter('returnFullResponse', 0);
+        const parallelExecution = this.getNodeParameter('parallelExecution', 0);
+        const processItem = async (itemIndex) => {
+            try {
+                const $item = items[itemIndex];
+                let result;
+                if (library === 'custom') {
+                    // Custom script execution
+                    const script = this.getNodeParameter('script', itemIndex);
+                    const executeScript = new Function('axios', 'fetch', 'items', '$item', 'itemIndex', `return (async () => { ${script} })();`);
+                    result = await executeScript(axios_1.default, fetch, items, $item, itemIndex);
+                }
+                else if (library === 'axios') {
+                    // Axios execution
+                    const method = this.getNodeParameter('method', itemIndex);
+                    const url = this.getNodeParameter('url', itemIndex);
+                    const headersJson = this.getNodeParameter('headers', itemIndex, '{}');
+                    const queryParamsJson = this.getNodeParameter('queryParams', itemIndex, '{}');
+                    const timeout = this.getNodeParameter('timeout', itemIndex, 30000);
+                    const randomUserAgent = this.getNodeParameter('randomUserAgent', itemIndex, true);
+                    const headers = JSON.parse(headersJson);
+                    const params = JSON.parse(queryParamsJson);
+                    // Add random user-agent if enabled and not already set
+                    if (randomUserAgent && !headers['User-Agent'] && !headers['user-agent']) {
+                        headers['User-Agent'] = getRandomUserAgent();
+                    }
+                    const config = {
+                        method: method,
+                        url,
+                        headers,
+                        params,
+                        timeout,
+                    };
+                    if (['POST', 'PUT', 'PATCH'].includes(method)) {
+                        const bodyJson = this.getNodeParameter('body', itemIndex, '{}');
+                        config.data = JSON.parse(bodyJson);
+                    }
+                    const response = await (0, axios_1.default)(config);
+                    if (returnFullResponse) {
+                        result = {
+                            data: response.data,
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: response.headers,
+                        };
+                    }
+                    else {
+                        result = response.data;
+                    }
+                }
+                else if (library === 'fetch') {
+                    // Fetch execution
+                    const method = this.getNodeParameter('method', itemIndex);
+                    const url = this.getNodeParameter('url', itemIndex);
+                    const headersJson = this.getNodeParameter('headers', itemIndex, '{}');
+                    const queryParamsJson = this.getNodeParameter('queryParams', itemIndex, '{}');
+                    const timeout = this.getNodeParameter('timeout', itemIndex, 30000);
+                    const randomUserAgent = this.getNodeParameter('randomUserAgent', itemIndex, true);
+                    const headers = JSON.parse(headersJson);
+                    const params = JSON.parse(queryParamsJson);
+                    // Add random user-agent if enabled and not already set
+                    if (randomUserAgent && !headers['User-Agent'] && !headers['user-agent']) {
+                        headers['User-Agent'] = getRandomUserAgent();
+                    }
+                    // Build URL with query params
+                    const urlObj = new URL(url);
+                    Object.entries(params).forEach(([key, value]) => {
+                        urlObj.searchParams.append(key, String(value));
+                    });
+                    const fetchOptions = {
+                        method,
+                        headers,
+                    };
+                    if (['POST', 'PUT', 'PATCH'].includes(method)) {
+                        const bodyJson = this.getNodeParameter('body', itemIndex, '{}');
+                        fetchOptions.body = bodyJson;
+                    }
+                    // Timeout handling
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), timeout);
+                    fetchOptions.signal = controller.signal;
+                    try {
+                        const response = await fetch(urlObj.toString(), fetchOptions);
+                        clearTimeout(timeoutId);
+                        const contentType = response.headers.get('content-type');
+                        let data;
+                        if (contentType?.includes('application/json')) {
+                            data = await response.json();
+                        }
+                        else {
+                            data = await response.text();
+                        }
+                        if (returnFullResponse) {
+                            result = {
+                                data,
+                                status: response.status,
+                                statusText: response.statusText,
+                                headers: Object.fromEntries(response.headers.entries()),
+                            };
+                        }
+                        else {
+                            result = data;
+                        }
+                    }
+                    catch (error) {
+                        clearTimeout(timeoutId);
+                        throw error;
+                    }
+                }
+                return {
+                    json: typeof result === 'object' ? result : { result },
+                    pairedItem: { item: itemIndex },
+                };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (this.continueOnFail()) {
+                    return {
+                        json: {
+                            error: errorMessage,
+                        },
+                        pairedItem: { item: itemIndex },
+                    };
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `HTTP request failed: ${errorMessage}`, { itemIndex });
+            }
+        };
+        let returnData;
+        if (parallelExecution && items.length > 1) {
+            // Process all items in parallel
+            returnData = await Promise.all(items.map((_, index) => processItem(index)));
+        }
+        else {
+            // Process items sequentially
+            returnData = [];
+            for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+                const result = await processItem(itemIndex);
+                returnData.push(result);
+            }
+        }
+        return [returnData];
+    }
+}
+exports.HttpRequestRunner = HttpRequestRunner;

package/dist/nodes/HttpRequestRunner/httprequest.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+  <path d="M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8"/>
+  <path d="M21 3v5h-5"/>
+  <path d="M12 8v4l3 3"/>
+</svg>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-script-runner",
-  "version": "1.0.0",
-  "description": "Custom n8n node to run scripts with jsdom or cheerio",
+  "version": "1.1.0",
+  "description": "Custom n8n nodes for script execution (jsdom, cheerio) and HTTP requests (axios, fetch)",
   "main": "index.js",
   "scripts": {
     "build": "tsc && gulp build:icons",
@@ -15,7 +15,10 @@
     "n8n",
     "jsdom",
     "cheerio",
-    "script"
+    "script",
+    "axios",
+    "fetch",
+    "http"
   ],
   "files": [
     "dist"
@@ -24,7 +27,8 @@
     "n8nNodesApiVersion": 1,
     "credentials": [],
     "nodes": [
-      "dist/nodes/ScriptRunner/ScriptRunner.node.js"
+      "dist/nodes/ScriptRunner/ScriptRunner.node.js",
+      "dist/nodes/HttpRequestRunner/HttpRequestRunner.node.js"
     ]
   },
   "devDependencies": {
@@ -35,6 +39,7 @@
     "typescript": "^5.3.0"
   },
   "dependencies": {
+    "axios": "^1.6.0",
     "cheerio": "^1.0.0-rc.12",
     "jsdom": "^23.0.0"
   },