n8n-nodes-confirm8 0.1.0 → 0.3.0

package/dist/nodes/ApiCustom/ApiAgentNode.node.js

@@ -0,0 +1,599 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiAgentNode = void 0;
+class ApiAgentNode {
+    constructor() {
+        this.description = {
+            displayName: 'API Agent Node',
+            name: 'apiAgentNode',
+            icon: 'file:api-agent.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + " - " + $parameter["operation"]}}',
+            description: 'AI-optimized node for API operations with batch processing and flexible input',
+            defaults: {
+                name: 'API Agent Node',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'apiCustomCredentials',
+                    required: true,
+                },
+            ],
+            properties: [
+                // Mode Selection
+                {
+                    displayName: 'Mode',
+                    name: 'mode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Simple',
+                            value: 'simple',
+                            description: 'Use dropdown menus to configure the operation',
+                        },
+                        {
+                            name: 'Advanced (JSON)',
+                            value: 'advanced',
+                            description: 'Provide complete JSON configuration for maximum flexibility',
+                        },
+                        {
+                            name: 'Batch',
+                            value: 'batch',
+                            description: 'Process multiple operations in a single execution',
+                        },
+                    ],
+                    default: 'simple',
+                    description: 'Choose how to configure the API call',
+                },
+                // ===== SIMPLE MODE =====
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Users',
+                            value: 'users',
+                            description: 'Manage system users - create, retrieve, update, activate/deactivate users, manage tasks and permissions',
+                        },
+                        {
+                            name: 'Clients',
+                            value: 'clients',
+                            description: 'Manage clients - create, retrieve, update client information and status',
+                        },
+                        {
+                            name: 'Items',
+                            value: 'items',
+                            description: 'Manage inventory items - create, retrieve, update items and their status',
+                        },
+                        {
+                            name: 'Item Types',
+                            value: 'itemTypes',
+                            description: 'Manage item type categories and classifications',
+                        },
+                        {
+                            name: 'Tasks',
+                            value: 'tasks',
+                            description: 'Manage checklists and tasks - create, assign, update task status',
+                        },
+                        {
+                            name: 'Services',
+                            value: 'services',
+                            description: 'Manage services offered - create, update service definitions and availability',
+                        },
+                        {
+                            name: 'Products',
+                            value: 'products',
+                            description: 'Manage product catalog - create, update products and pricing',
+                        },
+                        {
+                            name: 'Orders (WOS)',
+                            value: 'wos',
+                            description: 'Manage work orders - create, track, update service orders',
+                        },
+                        {
+                            name: 'Modalities',
+                            value: 'modalities',
+                            description: 'Manage order modalities - different types of service delivery methods',
+                        },
+                        {
+                            name: 'Tickets',
+                            value: 'tickets',
+                            description: 'Manage support tickets - create, track, resolve customer issues',
+                        },
+                        {
+                            name: 'Properties',
+                            value: 'properties',
+                            description: 'Manage properties - real estate or asset management',
+                        },
+                    ],
+                    default: 'users',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a new record. Requires JSON body with required fields.',
+                            action: 'Create a new record',
+                        },
+                        {
+                            name: 'Get by ID',
+                            value: 'get',
+                            description: 'Retrieve a specific record by its unique identifier',
+                            action: 'Get record by ID',
+                        },
+                        {
+                            name: 'Get by Username',
+                            value: 'getByUsername',
+                            description: 'Retrieve a user by username (users only)',
+                            action: 'Get user by username',
+                        },
+                        {
+                            name: 'Get All',
+                            value: 'getAll',
+                            description: 'Retrieve list of all records. Supports pagination and filtering.',
+                            action: 'Get all records',
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            description: 'Update an existing record. Provide ID and fields to update.',
+                            action: 'Update record',
+                        },
+                        {
+                            name: 'Activate',
+                            value: 'activate',
+                            description: 'Set record status to active/enabled',
+                            action: 'Activate record',
+                        },
+                        {
+                            name: 'Deactivate',
+                            value: 'deactivate',
+                            description: 'Set record status to inactive/disabled',
+                            action: 'Deactivate record',
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            description: 'Permanently delete a record',
+                            action: 'Delete record',
+                        },
+                        {
+                            name: 'Link Tasks (Users)',
+                            value: 'linkTasks',
+                            description: 'Associate tasks with a user',
+                            action: 'Link tasks to user',
+                        },
+                        {
+                            name: 'Unlink Tasks (Users)',
+                            value: 'unlinkTasks',
+                            description: 'Remove task associations from a user',
+                            action: 'Unlink tasks from user',
+                        },
+                        {
+                            name: 'Get User Tasks',
+                            value: 'getUserTasks',
+                            description: 'Get all tasks assigned to a specific user',
+                            action: 'Get user tasks',
+                        },
+                        {
+                            name: 'Get User Tickets',
+                            value: 'getUserTickets',
+                            description: 'Get all tickets owned by a specific user',
+                            action: 'Get user tickets',
+                        },
+                        {
+                            name: 'Get User Permissions',
+                            value: 'getUserPermissions',
+                            description: 'Get permissions and access rights for a user',
+                            action: 'Get user permissions',
+                        },
+                        {
+                            name: 'Upload Photo',
+                            value: 'uploadPhoto',
+                            description: 'Upload user profile photo (users only)',
+                            action: 'Upload photo',
+                        },
+                        {
+                            name: 'Upload Signature',
+                            value: 'uploadSignature',
+                            description: 'Upload user signature file (users only)',
+                            action: 'Upload signature',
+                        },
+                    ],
+                    default: 'getAll',
+                },
+                // ID Field - Dynamic label based on resource
+                {
+                    displayName: 'Record ID',
+                    name: 'recordId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                            operation: ['get', 'update', 'activate', 'deactivate', 'delete', 'getUserTasks', 'getUserTickets', 'getUserPermissions', 'uploadPhoto', 'uploadSignature'],
+                        },
+                    },
+                    default: '',
+                    description: 'The unique identifier of the record to operate on',
+                    required: true,
+                },
+                // Username field
+                {
+                    displayName: 'Username',
+                    name: 'username',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                            operation: ['getByUsername'],
+                            resource: ['users'],
+                        },
+                    },
+                    default: '',
+                    description: 'The username to search for',
+                    required: true,
+                },
+                // Employee ID for unlinking tasks
+                {
+                    displayName: 'Employee ID',
+                    name: 'employeeId',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                            operation: ['unlinkTasks'],
+                        },
+                    },
+                    default: '',
+                    description: 'The employee ID to unlink tasks from',
+                    required: true,
+                },
+                // Request Body (JSON)
+                {
+                    displayName: 'Request Body (JSON)',
+                    name: 'requestBody',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                            operation: ['create', 'update', 'linkTasks'],
+                        },
+                    },
+                    default: '{}',
+                    description: 'JSON object containing the data for the operation. Structure depends on the resource type.',
+                    placeholder: '{\n  "name": "John Doe",\n  "email": "john@example.com"\n}',
+                },
+                // Query Parameters
+                {
+                    displayName: 'Query Parameters',
+                    name: 'queryParameters',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            mode: ['simple'],
+                            operation: ['getAll'],
+                        },
+                    },
+                    default: '{}',
+                    description: 'Optional query parameters for filtering, pagination, sorting. Example: {"limit": 10, "offset": 0, "status": "active"}',
+                    placeholder: '{\n  "limit": 10,\n  "offset": 0,\n  "search": "keyword"\n}',
+                },
+                // ===== ADVANCED MODE =====
+                {
+                    displayName: 'Configuration JSON',
+                    name: 'configJson',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            mode: ['advanced'],
+                        },
+                    },
+                    default: '{\n  "method": "GET",\n  "endpoint": "/users",\n  "body": {},\n  "queryParams": {}\n}',
+                    description: 'Complete JSON configuration for the API call',
+                    placeholder: '{\n  "method": "POST",\n  "endpoint": "/users",\n  "body": {\n    "username": "newuser",\n    "email": "user@example.com"\n  },\n  "queryParams": {},\n  "headers": {}\n}',
+                    required: true,
+                },
+                // ===== BATCH MODE =====
+                {
+                    displayName: 'Batch Operations',
+                    name: 'batchOperations',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            mode: ['batch'],
+                        },
+                    },
+                    default: '[\n  {\n    "method": "GET",\n    "endpoint": "/users"\n  },\n  {\n    "method": "POST",\n    "endpoint": "/clients",\n    "body": {"name": "New Client"}\n  }\n]',
+                    description: 'Array of operations to execute in sequence. Each operation is a complete configuration.',
+                    placeholder: '[\n  {\n    "method": "GET",\n    "endpoint": "/users/123"\n  },\n  {\n    "method": "PUT",\n    "endpoint": "/users/123",\n    "body": {"status": "active"}\n  }\n]',
+                    required: true,
+                },
+                // Options
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Continue on Fail',
+                            name: 'continueOnFail',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to continue execution if this operation fails',
+                        },
+                        {
+                            displayName: 'Timeout',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 30000,
+                            description: 'Request timeout in milliseconds',
+                        },
+                        {
+                            displayName: 'Return Full Response',
+                            name: 'fullResponse',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to return full response including headers and status code',
+                        },
+                        {
+                            displayName: 'Custom Headers',
+                            name: 'customHeaders',
+                            type: 'json',
+                            default: '{}',
+                            description: 'Additional headers to include in the request',
+                            placeholder: '{\n  "X-Custom-Header": "value"\n}',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('apiCustomCredentials');
+        const baseUrl = credentials.baseUrl; // injected via credentials
+        // headers injected via credentials (Bearer + X-API-DOMAIN + X-APIKEY-TOKEN)
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const mode = this.getNodeParameter('mode', i);
+                const options = this.getNodeParameter('options', i, {});
+                const customHeaders = options.customHeaders ? JSON.parse(options.customHeaders) : {};
+                if (mode === 'simple') {
+                    const result = await this.executeSimpleMode(i, baseUrl, customHeaders, options, this);
+                    returnData.push(result);
+                }
+                else if (mode === 'advanced') {
+                    const result = await this.executeAdvancedMode(i, baseUrl, customHeaders, options, this);
+                    returnData.push(result);
+                }
+                else if (mode === 'batch') {
+                    const results = await this.executeBatchMode(i, baseUrl, customHeaders, options, this);
+                    returnData.push(...results);
+                }
+            }
+            catch (error) {
+                const options = this.getNodeParameter('options', i, {});
+                if (options.continueOnFail) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const statusCode = error instanceof Error && 'statusCode' in error ? error.statusCode : 500;
+                    returnData.push({
+                        error: errorMessage,
+                        statusCode: statusCode,
+                        resource: this.getNodeParameter('resource', i, ''),
+                        operation: this.getNodeParameter('operation', i, ''),
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [this.helpers.returnJsonArray(returnData)];
+    }
+    async executeSimpleMode(itemIndex, baseUrl, customHeaders, options, executeFunctions) {
+        const resource = executeFunctions.getNodeParameter('resource', itemIndex);
+        const operation = executeFunctions.getNodeParameter('operation', itemIndex);
+        let endpoint = '';
+        let method = 'GET';
+        let body = {};
+        let queryParams = {};
+        // Build endpoint based on resource and operation
+        const resourceMap = {
+            'users': '/users',
+            'clients': '/clients',
+            'items': '/items',
+            'itemTypes': '/itemTypes',
+            'tasks': '/tasks',
+            'services': '/services',
+            'products': '/products',
+            'wos': '/wos',
+            'modalities': '/modalities',
+            'tickets': '/tickets',
+            'properties': '/properties',
+        };
+        const baseEndpoint = resourceMap[resource] || '/users';
+        switch (operation) {
+            case 'create':
+                endpoint = baseEndpoint;
+                method = 'POST';
+                const createBody = executeFunctions.getNodeParameter('requestBody', itemIndex);
+                body = JSON.parse(createBody);
+                break;
+            case 'get':
+                const recordId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `${baseEndpoint}/${recordId}`;
+                method = 'GET';
+                break;
+            case 'getByUsername':
+                const username = executeFunctions.getNodeParameter('username', itemIndex);
+                endpoint = `${baseEndpoint}/${username}/user`;
+                method = 'GET';
+                break;
+            case 'getAll':
+                endpoint = baseEndpoint;
+                method = 'GET';
+                const queryParamsStr = executeFunctions.getNodeParameter('queryParameters', itemIndex, '{}');
+                queryParams = JSON.parse(queryParamsStr);
+                break;
+            case 'update':
+                const updateId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `${baseEndpoint}/${updateId}`;
+                method = 'PUT';
+                const updateBody = executeFunctions.getNodeParameter('requestBody', itemIndex);
+                body = JSON.parse(updateBody);
+                break;
+            case 'activate':
+                const activateId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `${baseEndpoint}/${activateId}/active`;
+                method = resource === 'users' ? 'PATCH' : 'PUT';
+                break;
+            case 'deactivate':
+                const deactivateId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `${baseEndpoint}/${deactivateId}/inactive`;
+                method = resource === 'users' ? 'PATCH' : 'PUT';
+                break;
+            case 'delete':
+                const deleteId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `${baseEndpoint}/${deleteId}`;
+                method = 'DELETE';
+                break;
+            case 'linkTasks':
+                endpoint = '/users/tasks';
+                method = 'POST';
+                const linkBody = executeFunctions.getNodeParameter('requestBody', itemIndex);
+                body = JSON.parse(linkBody);
+                break;
+            case 'unlinkTasks':
+                const employeeId = executeFunctions.getNodeParameter('employeeId', itemIndex);
+                endpoint = `/users/tasks/${employeeId}`;
+                method = 'DELETE';
+                break;
+            case 'getUserTasks':
+                const userTasksId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `/users/${userTasksId}/tasks`;
+                method = 'GET';
+                break;
+            case 'getUserTickets':
+                const userTicketsId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `/users/${userTicketsId}/tickets`;
+                method = 'GET';
+                break;
+            case 'getUserPermissions':
+                const userPermId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `/users/${userPermId}/permissions`;
+                method = 'GET';
+                break;
+            case 'uploadPhoto':
+                const photoUserId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `/users/${photoUserId}/photos`;
+                method = 'PATCH';
+                break;
+            case 'uploadSignature':
+                const sigUserId = executeFunctions.getNodeParameter('recordId', itemIndex);
+                endpoint = `/users/${sigUserId}/signatures`;
+                method = 'PATCH';
+                break;
+        }
+        return await this.makeRequest(baseUrl, endpoint, method, body, queryParams, customHeaders, options, executeFunctions);
+    }
+    async executeAdvancedMode(itemIndex, baseUrl, customHeaders, options, executeFunctions) {
+        const configStr = executeFunctions.getNodeParameter('configJson', itemIndex);
+        const config = JSON.parse(configStr);
+        const method = config.method || 'GET';
+        const endpoint = config.endpoint || '/';
+        const body = config.body || {};
+        const queryParams = config.queryParams || {};
+        const additionalHeaders = config.headers || {};
+        const mergedHeaders = { ...customHeaders, ...additionalHeaders };
+        return await this.makeRequest(baseUrl, endpoint, method, body, queryParams, mergedHeaders, options, executeFunctions);
+    }
+    async executeBatchMode(itemIndex, baseUrl, customHeaders, options, executeFunctions) {
+        const batchStr = executeFunctions.getNodeParameter('batchOperations', itemIndex);
+        const batchOps = JSON.parse(batchStr);
+        const results = [];
+        for (const op of batchOps) {
+            try {
+                const method = op.method || 'GET';
+                const endpoint = op.endpoint || '/';
+                const body = op.body || {};
+                const queryParams = op.queryParams || {};
+                const additionalHeaders = op.headers || {};
+                const mergedHeaders = { ...customHeaders, ...additionalHeaders };
+                const result = await this.makeRequest(baseUrl, endpoint, method, body, queryParams, mergedHeaders, options, executeFunctions);
+                results.push({
+                    ...result,
+                    _batchOperation: {
+                        method,
+                        endpoint,
+                        success: true,
+                    },
+                });
+            }
+            catch (error) {
+                if (options.continueOnFail) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    results.push({
+                        error: errorMessage,
+                        _batchOperation: {
+                            method: op.method,
+                            endpoint: op.endpoint,
+                            success: false,
+                        },
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return results;
+    }
+    async makeRequest(baseUrl, endpoint, method, body, queryParams, customHeaders, options, executeFunctions) {
+        const url = new URL(`${baseUrl}${endpoint}`);
+        // Add query parameters
+        Object.keys(queryParams).forEach(key => {
+            url.searchParams.append(key, String(queryParams[key]));
+        });
+        const requestOptions = {
+            method: method,
+            url: url.toString(),
+            headers: {
+                'Content-Type': 'application/json',
+                ...customHeaders,
+            },
+            json: true,
+            timeout: options.timeout || 30000,
+        };
+        if (method !== 'GET' && method !== 'DELETE' && Object.keys(body).length > 0) {
+            requestOptions.body = body;
+        }
+        if (options.fullResponse) {
+            requestOptions.returnFullResponse = true;
+        }
+        const responseData = await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, 'apiCustomCredentials', requestOptions);
+        return responseData;
+    }
+}
+exports.ApiAgentNode = ApiAgentNode;

package/dist/nodes/ApiCustom/ApiAgentTool.node.d.ts

@@ -0,0 +1,19 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, IDataObject } from 'n8n-workflow';
+/**
+ * AI Agent Tool node
+ *
+ * - Designed to be easy for LLMs to call (OpenAI-friendly schema)
+ * - Uses apiCustomCredentials to inject:
+ *   Authorization: Bearer <token>
+ *   X-API-DOMAIN: <domain>
+ *   X-APIKEY-TOKEN: <apikey>
+ */
+export declare class ApiAgentTool implements INodeType {
+    description: INodeTypeDescription;
+    /**
+     * Tool schema + semantic auto-description
+     * The AI Agent uses this to decide WHEN to call the tool and HOW to format inputs.
+     */
+    getToolDescription(): IDataObject;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}