@limetech/n8n-nodes-lime 0.2.8 → 0.3.0

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

@@ -0,0 +1,135 @@
+import {
+    IExecuteFunctions,
+    INodeExecutionData,
+    INodeProperties,
+    INodeType,
+    INodeTypeDescription,
+    NodeConnectionType,
+    NodePropertyTypes,
+} from 'n8n-workflow';
+
+import {
+    erpConnectorFields,
+    erpConnectorOperations,
+} from './resources/erpConnector';
+import { limeTypeFields, limeTypeOperations } from './resources/limeType';
+import { limeObjectFields, limeObjectOperations } from './resources/limeObject';
+
+import {
+    LIMEOBJECT_RESOURCE,
+    LIMETYPE_RESOURCE,
+    LIME_CRM_API_CREDENTIAL_KEY,
+    ERP_CONNECTOR_RESOURCE,
+} from './commons';
+
+import {
+    getEntitiesForErpSystem,
+    getLimeTypeProperties,
+    getLimeTypes,
+} from './methods';
+
+export class LimeCrmNode implements INodeType {
+    description: INodeTypeDescription = {
+        displayName: 'Lime CRM',
+        name: 'limeCrm',
+        icon: 'file:assets/lime-crm.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle:
+            '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: 'Consume the Lime CRM API',
+        defaults: {
+            name: 'Lime CRM',
+        },
+        inputs: [NodeConnectionType.Main],
+        outputs: [NodeConnectionType.Main],
+        credentials: [
+            {
+                name: LIME_CRM_API_CREDENTIAL_KEY,
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options' as NodePropertyTypes,
+                noDataExpression: true,
+                options: [
+                    {
+                        name: 'Lime Type',
+                        value: LIMETYPE_RESOURCE,
+                        description: 'Work with entity type definitions',
+                    },
+                    {
+                        name: 'Lime Object',
+                        value: LIMEOBJECT_RESOURCE,
+                        description: 'Work with actual data records',
+                    },
+                    {
+                        name: 'ERP Connector',
+                        value: ERP_CONNECTOR_RESOURCE,
+                        description: 'Integrate data between ERP and Lime CRM',
+                    },
+                ],
+                default: LIMEOBJECT_RESOURCE,
+            },
+
+            ...(limeTypeFields as INodeProperties[]),
+            ...(limeObjectFields as INodeProperties[]),
+            ...(erpConnectorFields as INodeProperties[]),
+        ],
+    };
+
+    methods = {
+        loadOptions: {
+            getEntitiesForErpSystem,
+            getLimeTypes,
+            getLimeTypeProperties,
+        },
+    };
+
+    async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+        const items = this.getInputData();
+        const returnData = [];
+
+        const resource = this.getNodeParameter('resource', 0) as string;
+        const operation = this.getNodeParameter('operation', 0) as string;
+
+        for (let i = 0; i < items.length; i++) {
+            let responseData;
+            try {
+                if (resource === LIMETYPE_RESOURCE) {
+                    responseData = await limeTypeOperations.call(this, {
+                        operation,
+                        i,
+                    });
+                } else if (resource === LIMEOBJECT_RESOURCE) {
+                    responseData = await limeObjectOperations.call(this, {
+                        operation,
+                        i,
+                    });
+                } else if (resource === ERP_CONNECTOR_RESOURCE) {
+                    responseData = await erpConnectorOperations.call(this, {
+                        operation,
+                        i,
+                    });
+                }
+
+                returnData.push({ json: responseData });
+            } catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        error: error.message,
+                        json: { error: error.message },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [this.helpers.returnJsonArray(returnData)];
+    }
+}
+
+export { LimeCrmTrigger } from './LimeCrmTrigger.node';

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

@@ -0,0 +1,263 @@
+import {
+    IHookFunctions,
+    IWebhookFunctions,
+    IDataObject,
+    INodeType,
+    INodeTypeDescription,
+    IWebhookResponseData,
+    NodeOperationError,
+    LoggerProxy as Logger,
+    NodeConnectionType,
+} from 'n8n-workflow';
+
+import { getWebhook, LIME_CRM_API_CREDENTIAL_KEY } from './commons';
+import { getLimeTypes } from './methods';
+import {
+    createSubscription,
+    deleteSubscription,
+    getSubscription,
+    listSubscriptionsWithExistingData,
+} from './transport';
+
+export class LimeCrmTrigger implements INodeType {
+    description: INodeTypeDescription = {
+        displayName: 'Lime CRM Trigger',
+        name: 'limeCrmTrigger',
+        icon: 'file:assets/lime-crm.svg',
+        group: ['trigger'],
+        version: 1,
+        description:
+            'Trigger which handles webhooks coming from Lime, e.g when ' +
+            'LimeObject is updated',
+        defaults: {
+            name: 'Lime CRM Trigger',
+        },
+        inputs: [],
+        outputs: [NodeConnectionType.Main],
+        credentials: [
+            {
+                name: LIME_CRM_API_CREDENTIAL_KEY,
+                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',
+            },
+        ],
+    };
+
+    methods = {
+        loadOptions: {
+            getLimeTypes,
+        },
+    };
+
+    webhookMethods = {
+        default: {
+            async checkExists(this: IHookFunctions): Promise<boolean> {
+                const webhook = getWebhook(this);
+
+                if (!webhook.data.webhookId) {
+                    return false;
+                }
+
+                const response = await getSubscription(this, webhook);
+                if (!response.success) {
+                    if (response.status === 404) {
+                        delete webhook.data.webhookId;
+                        delete webhook.data.webhookEvents;
+                        return false;
+                    }
+                    Logger.warn(
+                        `There was en error while getting a webhook from Lime CRM: ${response.error}`
+                    );
+                    throw new NodeOperationError(
+                        this.getNode(),
+                        response.error
+                    );
+                }
+                return true;
+            },
+
+            async create(this: IHookFunctions): Promise<boolean> {
+                const webhook = getWebhook(this);
+                const webhookUrl = webhook.url;
+                if (!webhookUrl) {
+                    throw new NodeOperationError(
+                        this.getNode(),
+                        'Invalid Webhook URL. Please make sure that it is not localhost!'
+                    );
+                }
+
+                // Check if a webhook already exists in order to not duplicate it in Lime
+                // This is a different check then 'checkExists' which only takes an ID,
+                // but it's only suited for production environment
+
+                const existingSubscriptionResponse =
+                    await listSubscriptionsWithExistingData(this, webhook);
+                if (!existingSubscriptionResponse.success) {
+                    throw new NodeOperationError(
+                        this.getNode(),
+                        existingSubscriptionResponse.error
+                    );
+                }
+
+                if (existingSubscriptionResponse.data.length === 0) {
+                    const createSubscriptionResponse = await createSubscription(
+                        this,
+                        webhook
+                    );
+
+                    if (!createSubscriptionResponse.success) {
+                        throw new NodeOperationError(
+                            this.getNode(),
+                            createSubscriptionResponse.error
+                        );
+                    }
+
+                    const subscriptionId = createSubscriptionResponse.data.id;
+                    const events = createSubscriptionResponse.data.events;
+
+                    webhook.data.webhookId = subscriptionId;
+                    webhook.data.webhookEvents = events;
+                    Logger.info(
+                        `Webhook with URL ${webhook.url}, ID ${subscriptionId} and events ${events} created!`
+                    );
+                    return true;
+                } else {
+                    const limeWebhook = existingSubscriptionResponse.data[0];
+                    webhook.data.webhookId = limeWebhook.id;
+                    webhook.data.webhookEvents = limeWebhook.events;
+                    Logger.info(
+                        `Webhook with URL ${webhook.url}, and events ${webhook.events} exists in Lime. 
+                        ID ${limeWebhook.id} set up to the N8N data.`
+                    );
+                    return true;
+                }
+            },
+
+            async delete(this: IHookFunctions): Promise<boolean> {
+                const webhook = getWebhook(this);
+                Logger.info(
+                    `Deleting webhook with ID: ${webhook.data.webhookId}`,
+                    { ...webhook }
+                );
+                if (webhook.data.webhookId !== undefined) {
+                    const response = await deleteSubscription(this, webhook);
+                    if (!response.success) {
+                        Logger.error(
+                            `Failed to delete webhook with ID: ${webhook.data.webhookId}`,
+                            {
+                                ...webhook,
+                            }
+                        );
+                        return false;
+                    }
+                    delete webhook.data.webhookId;
+                    Logger.info('Webhook deleted successfully', { ...webhook });
+                    return true;
+                }
+                return false;
+            },
+        },
+    };
+
+    async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
+        const webhook = getWebhook(this);
+        Logger.info('Webhook received. Starting webhook processing...', {
+            ...webhook.context,
+        });
+        const bodyData = this.getBodyData();
+
+        if (!bodyData || !bodyData.event || !bodyData.body) {
+            Logger.warn('Webhook data is invalid. Missing event or body', {
+                ...webhook.context,
+            });
+            throw new NodeOperationError(
+                this.getNode(),
+                'Webhook data is invalid'
+            );
+        }
+
+        const returnData: IDataObject[] = [];
+
+        returnData.push({
+            body: bodyData,
+            headers: this.getHeaderData(),
+            query: this.getQueryData(),
+        });
+
+        return { workflowData: [this.helpers.returnJsonArray(returnData)] };
+    }
+}

package/nodes/lime-crm/assets/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/commons/constants.ts

@@ -0,0 +1,9 @@
+// Credentials
+
+export const LIME_CRM_API_CREDENTIAL_KEY = 'limeCrmApi';
+
+// Resources
+
+export const LIMEOBJECT_RESOURCE = 'limeObject';
+export const LIMETYPE_RESOURCE = 'limeType';
+export const ERP_CONNECTOR_RESOURCE = 'erpConnector';

package/nodes/lime-crm/commons/index.ts

@@ -0,0 +1,9 @@
+export {
+    LIME_CRM_API_CREDENTIAL_KEY,
+    LIMEOBJECT_RESOURCE,
+    LIMETYPE_RESOURCE,
+    ERP_CONNECTOR_RESOURCE,
+} from './constants';
+export { Webhook, getWebhook } from './webhook';
+
+export { LimeType, LimeTypeProperty } from './limetype';

package/nodes/lime-crm/commons/limetype.ts

@@ -0,0 +1,11 @@
+export interface LimeType {
+    name: string;
+    href?: string;
+}
+
+export interface LimeTypeProperty {
+    name: string;
+    localname: string;
+    type: string;
+    required: boolean;
+}

package/nodes/lime-crm/commons/task.ts

@@ -0,0 +1,55 @@
+import { getTasks } from '../transport/task';
+import { IExecuteFunctions } from 'n8n-workflow';
+
+export async function waitForTaskCompletion(
+    nodeContext: IExecuteFunctions,
+    taskId: string,
+    pollInterval: number,
+    timeout: number
+) {
+    const startTime = Date.now();
+
+    while (Date.now() - startTime <= timeout) {
+        const taskResponse = await getTasks(nodeContext, taskId);
+
+        if (!taskResponse.success) continue;
+
+        const task = taskResponse.data._embedded.tasks[0];
+        switch (task.status) {
+            case 'FAILURE': {
+                return {
+                    success: false,
+                    error: `Task ${taskId} failed: ${task.result}`,
+                    metadata: {
+                        taskId: taskId,
+                    },
+                };
+            }
+            case 'REVOKED': {
+                return {
+                    success: false,
+                    error: `Task ${taskId} was revoked`,
+                    metadata: {
+                        taskId: taskId,
+                    },
+                };
+            }
+            case 'SUCCESS': {
+                return {
+                    success: true,
+                    data: task.result,
+                };
+            }
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+
+    return {
+        success: false,
+        error: `Task ${taskId} did not complete within ${timeout / 1000}s`,
+        metadata: {
+            taskId: taskId,
+        },
+    };
+}

package/nodes/lime-crm/commons/webhook.ts

@@ -0,0 +1,50 @@
+import { IDataObject, IHookFunctions, IWebhookFunctions } from 'n8n-workflow';
+
+type WebhookFunctions = IHookFunctions | IWebhookFunctions;
+
+interface WebhookContext {
+    nodeId: string;
+    nodeName?: string;
+    workflowId?: string;
+    workflowName?: string;
+}
+
+export interface Webhook {
+    data: IDataObject;
+    events: string[];
+    url?: string;
+    context: WebhookContext;
+}
+
+function _getEvents(hookData: WebhookFunctions): string[] {
+    const eventData = hookData.getNodeParameter('events', []) as {
+        event: Array<{
+            limeType: string;
+            eventType: string;
+        }>;
+    };
+    const eventItems = eventData.event;
+    const events: string[] = [];
+    for (const eventItem of eventItems) {
+        events.push(`${eventItem.limeType}.${eventItem.eventType}`);
+    }
+    return events;
+}
+
+export function getWebhook(hookData: WebhookFunctions): Webhook {
+    const node = hookData.getNode();
+    const workflow = hookData.getWorkflow();
+    const context: WebhookContext = {
+        nodeId: node.id,
+        nodeName: node.name,
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+    };
+
+    return {
+        data: hookData.getWorkflowStaticData('node'),
+        events: _getEvents(hookData),
+        url: hookData.getNodeWebhookUrl('default'),
+        context: context,
+    };
+}

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

@@ -0,0 +1,11 @@
+import { ILoadOptionsFunctions } from 'n8n-workflow';
+
+export async function getEntitiesForErpSystem(this: ILoadOptionsFunctions) {
+    const erpSystem = this.getCurrentNodeParameter('erpSystem') as string;
+
+    if (erpSystem === 'fortnox') {
+        return [{ name: 'Invoice', value: 'invoice' }];
+    }
+
+    return [];
+}

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

@@ -0,0 +1,27 @@
+import {
+    ILoadOptionsFunctions,
+    INodePropertyOptions,
+    LoggerProxy as Logger,
+} from 'n8n-workflow';
+import { getProperties } from '../transport/';
+
+/**
+ * Load properties for a selected Lime type
+ */
+export async function getLimeTypeProperties(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    const limeType = this.getNodeParameter('limeType', '') as string;
+    Logger.info(`Fetching properties for Lime type: ${limeType}`);
+    if (!limeType) return [];
+
+    const response = await getProperties(this, limeType);
+
+    if (!response.success) return [];
+
+    return response.data.map((property) => ({
+        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)' : ''}`,
+    }));
+}

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

@@ -0,0 +1,23 @@
+import { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+import { getLimeTypesFromApi } from '../transport';
+
+/**
+ * Load available Lime types from the API
+ */
+export async function getLimeTypes(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    const data: INodePropertyOptions[] = [];
+    const response = await getLimeTypesFromApi(this);
+    if (response.success && response.data) {
+        for (const limeType of response.data) {
+            if (limeType.name) {
+                data.push({
+                    name: limeType.name,
+                    value: limeType.name,
+                });
+            }
+        }
+    }
+    return data;
+}

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

@@ -0,0 +1,3 @@
+export { getEntitiesForErpSystem } from './getEntitiesForErpSystem';
+export { getLimeTypes } from './getLimeTypes';
+export { getLimeTypeProperties } from './getLimeTypeProperties';

package/nodes/lime-crm/resources/erpConnector/index.ts

@@ -0,0 +1,43 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+} from 'n8n-workflow';
+
+import * as createOrUpdateObjects from './operations/createOrUpdateObjects.operation';
+import * as transform from './operations/transform.operation';
+
+import { ERP_CONNECTOR_RESOURCE } from '../../commons';
+
+export const erpConnectorFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [ERP_CONNECTOR_RESOURCE],
+            },
+        },
+        options: [createOrUpdateObjects.description, transform.description],
+        default: 'transformErpData',
+    },
+
+    ...createOrUpdateObjects.properties,
+    ...transform.properties,
+];
+
+export async function erpConnectorOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+) {
+    if (operation === 'createOrUpdateObjects') {
+        return await createOrUpdateObjects.execute.call(this, i);
+    }
+    if (operation === 'transformErpData') {
+        return await transform.execute.call(this, i);
+    }
+
+    return null;
+}