@limetech/n8n-nodes-lime 0.1.0

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

@@ -0,0 +1,505 @@
+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/lime-crm.svg

@@ -0,0 +1 @@
+<svg viewBox="0 0 1024 1025" xmlns="http://www.w3.org/2000/svg" xml:space="preserve"><clipPath id="a"><path d="M0 .03h1024v1024H0z"/></clipPath><g clip-path="url(#a)"><path d="M92.399 480.888c0-257.059 208.719-465.779 465.78-465.779C815.28 15.109 1024 223.829 1024 480.888c0 133.713-55.806 271.139-193.403 385.355-166.779 138.45-390.39 157.35-736.15 134.525-102.653-6.785-117.502-24.319-64.468-63.444 166.694-123.047 62.42-217.167 62.42-456.436Z" style="fill:#bee034"/><clipPath id="b"><path d="M92.399 480.888c0-257.059 208.719-465.779 465.78-465.779C815.28 15.109 1024 223.829 1024 480.888c0 133.713-55.806 271.139-193.403 385.355-166.779 138.45-390.39 157.35-736.15 134.525-102.653-6.785-117.502-24.319-64.468-63.444 166.694-123.047 62.42-217.167 62.42-456.436Z"/></clipPath><g clip-path="url(#b)"><path d="M1023-361.59c0 784.587-711.326 1420.62-1588.79 1420.62C-1402.638-283.55 1023-1146.18 1023-361.59Z" style="fill:#a6efff;filter:blur(200px)"/></g><path d="M433.85 723.911c-24.702-12.757-47.23-29.226-66.813-48.596-9.088-9.002-23.765-8.959-32.768.129-9.001 9.087-8.916 23.763.171 32.766 22.911 22.698 49.236 41.941 78.121 56.873 11.392 5.888 25.385 1.409 31.231-9.94 5.888-11.349 1.409-25.344-9.942-31.232Zm367.266-363.98a270.163 270.163 0 0 1 25.556 78.547c2.048 12.629 13.952 21.206 26.581 19.158 12.586-2.006 21.204-13.951 19.156-26.539a316.387 316.387 0 0 0-29.907-92.029c-5.803-11.434-19.754-15.999-31.146-10.24-11.393 5.76-16 19.713-10.24 31.103Zm-51.497 315.384c-19.584 19.37-42.069 35.839-66.815 48.596-11.349 5.888-15.786 19.883-9.94 31.232 5.887 11.349 19.881 15.828 31.229 9.94 28.929-14.932 55.253-34.175 78.164-56.873 9.045-9.003 9.131-23.679.128-32.766-9.002-9.088-23.678-9.131-32.766-.129ZM517.006 213.546a274.904 274.904 0 0 1 41.343-3.114c14.036 0 27.861 1.066 41.343 3.114 12.629 1.919 24.448-6.784 26.367-19.413 1.962-12.628-6.741-24.446-19.371-26.409a322.626 322.626 0 0 0-48.339-3.627 322.201 322.201 0 0 0-48.34 3.627c-12.672 1.963-21.332 13.781-19.413 26.409 1.92 12.629 13.739 21.332 26.41 19.413Zm41.343 490.355c-40.489 0-73.385 32.853-73.385 73.342s32.896 73.385 73.385 73.385c40.489 0 73.342-32.896 73.342-73.385 0-40.489-32.853-73.342-73.342-73.342ZM290.025 438.478c4.481-27.818 13.227-54.227 25.514-78.547 5.761-11.39 1.195-25.343-10.239-31.103-11.392-5.759-25.343-1.194-31.104 10.24a313.893 313.893 0 0 0-29.908 92.029c-2.048 12.588 6.527 24.533 19.157 26.539 12.629 2.048 24.532-6.529 26.58-19.158Zm479.092 112.254c-12.501 38.527 8.618 79.955 47.102 92.456 38.528 12.502 79.956-8.618 92.457-47.104 12.501-38.525-8.619-79.953-47.103-92.455-38.527-12.501-79.955 8.619-92.456 47.103Zm-80.51-247.802c32.766 23.808 78.675 16.554 102.482-16.212 23.808-32.767 16.512-78.675-16.256-102.482-32.723-23.809-78.675-16.512-102.439 16.254-23.808 32.725-16.555 78.633 16.213 102.44Zm-260.558 0c32.766-23.807 40.063-69.715 16.254-102.44-23.807-32.766-69.715-40.063-102.482-16.254-32.766 23.807-40.02 69.715-16.255 102.482 23.806 32.766 69.758 40.02 102.483 16.212Zm-80.51 247.802c-12.501-38.484-53.929-59.604-92.415-47.103-38.526 12.502-59.645 53.93-47.102 92.455 12.501 38.486 53.929 59.606 92.413 47.104 38.528-12.501 59.605-53.929 47.104-92.456Z" style="fill:#fff"/></g></svg>

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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,32 @@
+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;