@limetech/n8n-nodes-lime 0.1.0 → 0.2.1

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

@@ -1,505 +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';
-
-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[]> {
-                const returnData: INodePropertyOptions[] = [];
-
-                try {
-                    // Get credentials for the API
-                    const credentials = await this.getCredentials('limeCrmApi');
-
-                    if (!credentials) {
-                        throw new Error('No credentials provided');
-                    }
-
-                    const endpoint = '/api/v1/limetype/';
-
-                    // Make sure baseURL is properly configured
-                    const options = {
-                        method: 'GET' as 'GET',
-                        uri: endpoint,
-                        json: true,
-                        baseURL: credentials.url as string,  // Add the base URL from credentials
-                        headers: {
-                            'X-API-Key': credentials.apiKey as string,
-                            'Accept': 'application/json',
-                        },
-                    };
-
-                    const response = await this.helpers.requestWithAuthentication.call(
-                        this,
-                        'limeCrmApi',
-                        options,
-                    );
-
-                    if (response._links && response._links.limetypes) {
-                        // Parse response to extract lime types
-                        for (const limeType of response._links.limetypes) {
-                            if (limeType.name) {
-                                returnData.push({
-                                    name: limeType.name,
-                                    value: limeType.name,
-                                });
-                            }
-                        }
-                    }
-
-                    return returnData;
-                } catch (error) {
-                    throw new NodeOperationError(this.getNode(), `Failed to load Lime Types: ${error}`);
-                }
-            },
-        },
-    };
-
-    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;
-        }
-    }
-}

package/nodes/lime-crm/methods/getAllSortableFields.ts

@@ -1,73 +0,0 @@
-import { ILoadOptionsFunctions, IDataObject } from 'n8n-workflow';
-import { apiRequest } from '../transport';
-
-/**
- * Interface for sortable fields
- */
-interface SortableField {
-    name: string;
-    value: string;
-}
-
-/**
- * Get all sortable fields (properties from main type and related types)
- */
-export async function getAllSortableFields(this: ILoadOptionsFunctions): Promise<SortableField[]> {
-    const limeType = this.getNodeParameter('limetype', '') as string;
-    const includeRelations = this.getNodeParameter('includeRelations', false) as boolean;
-
-    if (!limeType) return [];
-
-    try {
-        // Get main type properties
-        const propertiesResponse = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint: `/api/v1/limetype/${limeType}/property`,
-        });
-
-        let sortableFields: SortableField[] = [];
-
-        if (propertiesResponse && Array.isArray(propertiesResponse)) {
-            sortableFields = propertiesResponse.map((property: IDataObject) => ({
-                name: property.name as string,
-                value: property.name as string,
-            }));
-        }
-
-        // If includeRelations is true, get related type properties
-        if (includeRelations) {
-            const relationsResponse = await apiRequest.call(this, {
-                method: 'GET',
-                endpoint: `/api/v1/limetype/${limeType}/relation`,
-            });
-
-            if (relationsResponse && Array.isArray(relationsResponse)) {
-                for (const relation of relationsResponse) {
-                    const targetType = relation.targettype as string;
-                    const relationName = relation.name as string;
-
-                    const targetPropertiesResponse = await apiRequest.call(this, {
-                        method: 'GET',
-                        endpoint: `/api/v1/limetype/${targetType}/property`,
-                    });
-
-                    if (targetPropertiesResponse && Array.isArray(targetPropertiesResponse)) {
-                        sortableFields.push(
-                            ...targetPropertiesResponse.map((property: IDataObject) => ({
-                                name: `${relationName}.${property.name}`,
-                                value: `${relationName}.${property.name}`,
-                            }))
-                        );
-                    }
-                }
-            }
-        }
-
-        return sortableFields;
-    } catch (error) {
-        console.error(`Error loading sortable fields for ${limeType}:`, error);
-        return [];
-    }
-}
-
-export default getAllSortableFields;

package/nodes/lime-crm/methods/getLimeTypeProperties.ts

@@ -1,48 +0,0 @@
-import { ILoadOptionsFunctions, IDataObject, INodePropertyOptions } from 'n8n-workflow';
-import { apiRequest } from '../transport';
-
-/**
- * Load properties for a selected Lime type
- */
-export async function getLimeTypeProperties(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
-    const limeType = this.getNodeParameter('limeType', '') as string;
-    console.log('Fetching properties for Lime type:', limeType); // Log the Lime type being fetched
-    if (!limeType) return [];
-
-    try {
-        const response = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint: `/api/v1/limetype/${limeType}/`,
-            qs: {
-                _embed: 'properties',
-            },
-        });
-
-        // Define the system properties that should always be included
-        const systemProperties: INodePropertyOptions[] = [
-            { name: 'ID', value: 'id', description: 'Unique identifier (integer)' },
-            { name: 'Updated (System)', value: 'timestamp', description: 'Last update timestamp (datetime)' },
-            { name: 'Created (System)', value: 'createdtime', description: 'Creation timestamp (datetime)' },
-            { name: 'Created By', value: 'createduser', description: 'User ID that created the record (integer)' },
-            { name: 'Updated By', value: 'updateduser', description: 'User ID that last updated the record (integer)' },
-        ];
-
-        // Handle API response properties
-        let apiProperties: INodePropertyOptions[] = [];
-
-        // Check if response contains embedded properties
-        apiProperties = response._embedded.properties.map((property: IDataObject) => ({
-            name: (property.localname as string) || (property.name as string),
-            value: property.name as string,
-            description: `Type: ${property.type as string}${(property.required as boolean) ? ' (Required)' : ''} | DB: ${property.name as string}`,
-        }));
-
-        // Combine system properties with API properties
-        return [...systemProperties, ...apiProperties];
-    } catch (error) {
-        console.error(`Error loading properties for ${limeType}:`, error);
-        return [];
-    }
-}
-
-export default getLimeTypeProperties;

package/nodes/lime-crm/methods/getLimeTypeRelations.ts

@@ -1,32 +0,0 @@
-import { ILoadOptionsFunctions, IDataObject } from 'n8n-workflow';
-import { apiRequest } from '../transport';
-
-/**
- * Load relations for a selected Lime type
- */
-export async function getLimeTypeRelations(this: ILoadOptionsFunctions) {
-    const limeType = this.getNodeParameter('limetype', '') as string;
-    if (!limeType) return [];
-
-    try {
-        const response = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint: `/api/v1/limetype/${limeType}/`,
-        });
-
-        if (!response || !Array.isArray(response)) {
-            return [];
-        }
-
-        return response.map((relation: IDataObject) => ({
-            name: relation.name as string,
-            value: relation.name as string,
-            description: `Target: ${relation.targettype}`,
-        }));
-    } catch (error) {
-        console.error(`Error loading relations for ${limeType}:`, error);
-        return [];
-    }
-}
-
-export default getLimeTypeRelations;