@limetech/n8n-nodes-lime 0.2.0 → 0.2.2

package/nodes/lime-crm/LimeCrmTrigger/LimeCrmTrigger.node.ts

@@ -1,461 +0,0 @@
-import {
-    IHookFunctions,
-    IWebhookFunctions,
-    IDataObject,
-    INodeType,
-    INodeTypeDescription,
-    IWebhookResponseData,
-    NodeOperationError,
-    ILoadOptionsFunctions,
-    INodePropertyOptions,
-    INodeExecutionData,
-    NodeConnectionType,
-    LoggerProxy as Logger
-} from 'n8n-workflow';
-
-import { IWebhookObject, IWebhookEventData } from '../GenericTypes';
-import * as crypto from 'crypto';
-import { getLimeTypes } from '../methods';
-
-export class LimeCrmTrigger implements INodeType {
-    description: INodeTypeDescription = {
-        displayName: 'Lime CRM Trigger',
-        name: 'limeCrmTrigger',
-        icon: 'file:lime.svg',
-        group: ['trigger'],
-        version: 1,
-        description: 'Handle Lime CRM webhook events',
-        defaults: {
-            name: 'Lime CRM Trigger',
-        },
-        inputs: [],
-        outputs: [NodeConnectionType.Main],
-        credentials: [
-            {
-                name: 'limeCrmApi',
-                required: true,
-            },
-        ],
-        webhooks: [
-            {
-                name: 'default',
-                httpMethod: 'POST',
-                responseMode: 'onReceived',
-                path: 'webhook',
-            },
-        ],
-        properties: [
-            {
-                displayName: 'Events',
-                name: 'events',
-                type: 'fixedCollection',
-                typeOptions: {
-                    multipleValues: true,
-                    required: true,
-                },
-                default: {},
-                placeholder: 'Add Event',
-                description: 'Events to subscribe to',
-                options: [
-                    {
-                        name: 'event',
-                        displayName: 'Event',
-                        values: [
-                            {
-                                displayName: 'Lime Type',
-                                name: 'limeType',
-                                type: 'options',
-                                typeOptions: {
-                                    loadOptionsMethod: 'getLimeTypes',
-                                },
-                                default: '',
-                                description: 'Lime Type to subscribe to events for',
-                            },
-                            {
-                                displayName: 'Event Type',
-                                name: 'eventType',
-                                type: 'options',
-                                options: [
-                                    {
-                                        name: 'New',
-                                        value: 'new',
-                                        description: 'When a new record is created',
-                                    },
-                                    {
-                                        name: 'Update',
-                                        value: 'update',
-                                        description: 'When a record is updated',
-                                    },
-                                    {
-                                        name: 'Delete',
-                                        value: 'delete',
-                                        description: 'When a record is deleted',
-                                    },
-                                ],
-                                default: 'new',
-                                description: 'Type of event to subscribe to',
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                displayName: 'Name',
-                name: 'name',
-                type: 'string',
-                default: '',
-                placeholder: 'my-lime-webhook',
-                required: true,
-                description: 'Name for this webhook subscription',
-            },
-            {
-                displayName: 'Options',
-                name: 'options',
-                type: 'collection',
-                placeholder: 'Add Option',
-                default: {},
-                options: [
-                    {
-                        displayName: 'Include Headers',
-                        name: 'includeHeaders',
-                        type: 'fixedCollection',
-                        typeOptions: {
-                            multipleValues: true,
-                        },
-                        default: {},
-                        placeholder: 'Add Header',
-                        description: 'Headers to add to webhook requests',
-                        options: [
-                            {
-                                name: 'header',
-                                displayName: 'Header',
-                                values: [
-                                    {
-                                        displayName: 'Name',
-                                        name: 'name',
-                                        type: 'string',
-                                        default: '',
-                                        description: 'Name of the header',
-                                    },
-                                    {
-                                        displayName: 'Value',
-                                        name: 'value',
-                                        type: 'string',
-                                        default: '',
-                                        description: 'Value of the header',
-                                    },
-                                    {
-                                        displayName: 'Is Secret',
-                                        name: 'isSecret',
-                                        type: 'boolean',
-                                        default: false,
-                                        description: 'Whether this value is a secret',
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    {
-                        displayName: 'Secret',
-                        name: 'secret',
-                        type: 'string',
-                        typeOptions: {
-                            password: true,
-                        },
-                        default: '',
-                        description: 'Secret to verify the authenticity of received data',
-                    },
-                ],
-            },
-        ],
-    };
-
-    methods = {
-        loadOptions: {
-            // Load available Lime types
-            async getLimeTypes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
-                return getLimeTypes.call(this);
-            },
-        },
-    };
-
-    webhookMethods = {
-        default: {
-            async checkExists(this: IHookFunctions): Promise<boolean> {
-                const nodeId = this.getNode().id;
-                const workflowId = this.getWorkflow().id;
-                const workflowName = this.getWorkflow().name;
-                const webhookData = this.getWorkflowStaticData('node');
-                const webhookUrl = this.getNodeWebhookUrl('default');
-
-                // If we have a webhook ID stored, check if it still exists
-                if (webhookData.webhookId) {
-                    try {
-                        // Get credentials for the API
-                        const credentials = await this.getCredentials('limeCrmApi');
-                        if (!credentials) {
-                            throw new Error('No credentials provided');
-                        }
-
-                        // Fetch the webhook to see if it exists
-                        const currentWebhook = await this.helpers.requestWithAuthentication.call(
-                            this,
-                            'limeCrmApi',
-                            {
-                                method: 'GET',
-                                uri: `/api/v1/subscription/${webhookData.webhookId}/`,
-                                json: true,
-                                baseURL: credentials.url as string,
-                                headers: {
-                                    'X-API-Key': credentials.apiKey as string,
-                                    'Accept': 'application/json',
-                                },
-                            },
-                        );
-
-                        // Check if the webhook exists and has the right URL
-                        if (currentWebhook && currentWebhook.target_url === webhookUrl) {
-                            Logger.debug(`Webhook exists: ${webhookData.webhookId}`, { webhookId: webhookData.webhookId, nodeId, workflowId, workflowName });
-                            return true;
-                        }
-                    } catch (error) {
-                        // If we get an error, the webhook likely doesn't exist
-                        Logger.warn(`Webhook check failed: ${error}`, { webhookId: webhookData.webhookId, nodeId, workflowId, workflowName, error });
-                        delete webhookData.webhookId;
-                        return false;
-                    }
-                }
-
-                return false;
-            },
-
-            async create(this: IHookFunctions): Promise<boolean> {
-                const nodeId = this.getNode().id;
-                const workflowId = this.getWorkflow().id;
-                const workflowName = this.getWorkflow().name;
-                const webhookData = this.getWorkflowStaticData('node');
-                const webhookUrl = this.getNodeWebhookUrl('default');
-
-                if (!webhookUrl) {
-                    throw new NodeOperationError(this.getNode(), 'No webhook URL was returned by the system');
-                }
-
-                const name = this.getNodeParameter('name') as string;
-                const eventsCollection = this.getNodeParameter('events.event', []) as Array<{ limeType: string, eventType: string }>;
-                const options = this.getNodeParameter('options', {}) as IDataObject;
-
-                // Get credentials for the API
-                const credentials = await this.getCredentials('limeCrmApi');
-                if (!credentials) {
-                    throw new Error('No credentials provided');
-                }
-
-                // Format events array for the Lime CRM API format
-                const events: string[] = [];
-                for (const eventItem of eventsCollection) {
-                    events.push(`${eventItem.limeType}.${eventItem.eventType}`);
-                }
-
-                // Sort events for consistent comparison
-                events.sort();
-
-                // Format headers if they exist
-                const headersCollection = (options.includeHeaders as IDataObject || {}).header as Array<{ name: string; value: string; isSecret: boolean }> || [];
-                const headers: Array<{ name: string; value: string; secret_value?: string; type: string }> = [];
-
-                for (const header of headersCollection) {
-                    if (header.isSecret) {
-                        headers.push({
-                            name: header.name,
-                            value: '',
-                            secret_value: header.value,
-                            type: 'text',
-                        });
-                    } else {
-                        headers.push({
-                            name: header.name,
-                            value: header.value,
-                            type: 'text',
-                        });
-                    }
-                }
-
-                // Prepare request body
-                const body: IWebhookObject = {
-                    name,
-                    events,
-                    target_url: webhookUrl,
-                    enabled: true,
-                    headers,
-                };
-
-                // If a secret is provided, add it
-                const secret = options.secret as string;
-                if (secret) {
-                    body.secret = secret;
-                }
-
-                try {
-                    // Create the webhook
-                    Logger.info('Creating new webhook subscription', { nodeId, workflowId, workflowName });
-                    const webhookResponse = await this.helpers.requestWithAuthentication.call(
-                        this,
-                        'limeCrmApi',
-                        {
-                            method: 'POST',
-                            uri: '/api/v1/subscription/',
-                            body,
-                            json: true,
-                            baseURL: credentials.url as string,
-                            headers: {
-                                'X-API-Key': credentials.apiKey as string,
-                                'Accept': 'application/json',
-                                'Content-Type': 'application/json',
-                            },
-                        },
-                    );
-
-                    // Store webhook ID in workflow data for later use
-                    if (webhookResponse.id) {
-                        webhookData.webhookId = webhookResponse.id;
-                        Logger.info(`Created webhook with ID: ${webhookResponse.id}`, { webhookId: webhookResponse.id, nodeId, workflowId, workflowName });
-                        return true;
-                    }
-
-                    throw new NodeOperationError(this.getNode(), 'Webhook creation failed: No ID was returned');
-                } catch (error) {
-                    Logger.error(`Webhook creation failed: ${error}`, { nodeId, workflowId, workflowName, error });
-                    throw new NodeOperationError(this.getNode(), `Webhook creation failed: ${error}`);
-                }
-            },
-
-            async delete(this: IHookFunctions): Promise<boolean> {
-                const nodeId = this.getNode().id;
-                const workflowId = this.getWorkflow().id;
-                const workflowName = this.getWorkflow().name;
-                const webhookData = this.getWorkflowStaticData('node');
-                const webhookId = webhookData.webhookId as string | undefined;
-
-                if (webhookId !== undefined) {
-                    try {
-                        Logger.info(`Deleting webhook with ID: ${webhookId}`, { webhookId, nodeId, workflowId, workflowName });
-                        // Get credentials for the API
-                        const credentials = await this.getCredentials('limeCrmApi');
-                        if (!credentials) {
-                            throw new Error('No credentials provided');
-                        }
-
-                        await this.helpers.requestWithAuthentication.call(
-                            this,
-                            'limeCrmApi',
-                            {
-                                method: 'DELETE' as 'DELETE',
-                                uri: `/api/v1/subscription/${webhookId}/`,
-                                json: true,
-                                baseURL: credentials.url as string,
-                                headers: {
-                                    'X-API-Key': credentials.apiKey as string,
-                                    'Accept': 'application/json',
-                                },
-                            },
-                        );
-
-                        delete webhookData.webhookId;
-                        Logger.info('Webhook deleted successfully', { webhookId, nodeId, workflowId, workflowName });
-                        return true;
-                    } catch (error) {
-                        Logger.error(`Webhook deletion failed: ${error}`, { webhookId, nodeId, workflowId, workflowName, error });
-                        return false;
-                    }
-                }
-
-                return true;
-            },
-        },
-    };
-
-    async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
-        const nodeId = this.getNode().id;
-        const workflowId = this.getWorkflow().id;
-        const workflowName = this.getWorkflow().name;
-
-        Logger.info('Webhook received. Starting webhook processing...', { nodeId, workflowId, workflowName });
-        try {
-            const options = this.getNodeParameter('options', {}) as IDataObject;
-            const secret = options.secret as string;
-
-            const bodyData = this.getBodyData();
-            const headerData = this.getHeaderData();
-
-            // If a secret is set, verify the signature
-            if (secret && headerData['x-lime-signature']) {
-                Logger.debug('Verifying webhook signature...', { nodeId, workflowId, workflowName });
-                const signature = headerData['x-lime-signature'] as string;
-
-                const req = this.getRequestObject();
-                const rawBody = req.rawBody || JSON.stringify(bodyData);
-
-                // Create the expected signature
-                const hmac = crypto.createHmac('sha256', secret);
-                hmac.update(rawBody);
-                const expectedSignature = hmac.digest('hex');
-
-                // Compare signatures
-                if (signature !== expectedSignature) {
-                    Logger.warn('Signature verification FAILED!', { nodeId, workflowId, workflowName });
-                    throw new NodeOperationError(this.getNode(), 'Invalid webhook signature');
-                }
-                Logger.debug('Signature verification successful', { nodeId, workflowId, workflowName });
-            }
-
-            // Cast bodyData to expected type after logging
-            const typedBodyData = bodyData as unknown as IWebhookEventData;
-
-            // Extract the relevant data
-            if (!typedBodyData || !typedBodyData.event || !typedBodyData.body) {
-                Logger.warn('Webhook data is invalid. Missing event or body', { nodeId, workflowId, workflowName });
-                throw new NodeOperationError(this.getNode(), 'Webhook data is invalid');
-            }
-
-            // Process the event
-            const eventParts = typedBodyData.event.split('.');
-            if (eventParts.length !== 2) {
-                Logger.warn(`Invalid event format: ${typedBodyData.event}`, { nodeId, workflowId, workflowName, event: typedBodyData.event });
-                throw new NodeOperationError(this.getNode(), `Invalid event format: ${typedBodyData.event}`);
-            }
-
-            const limeType = eventParts[0];
-            const eventType = eventParts[1];
-            Logger.info(`Processing ${limeType}.${eventType} event for ID: ${typedBodyData.body.id}`, {
-                limeType,
-                eventType,
-                recordId: typedBodyData.body.id,
-                nodeId,
-                workflowId,
-                workflowName
-            });
-
-            // Create a standardized response as a single object instead of an array
-            const data: INodeExecutionData[] = [
-                {
-                    json: {
-                        limeType,
-                        eventType,
-                        id: typedBodyData.body.id,
-                        data: typedBodyData.body.values || {}, // Ensure values is an object, default to empty object if null
-                        rawEvent: typedBodyData,
-                    },
-                },
-            ];
-
-            Logger.debug('Webhook processing complete', { nodeId, workflowId, workflowName });
-
-            return {
-                workflowData: [data],
-            };
-        } catch (error) {
-            Logger.error('Error in webhook execution', { error, nodeId, workflowId, workflowName });
-            throw error;
-        }
-    }
-}