@limetech/n8n-nodes-lime 2.5.5-dev.1 → 2.6.0

package/nodes/index.ts

@@ -2,3 +2,4 @@ export * from './response';
 export * from './lime-crm';
 export * from './fortnox';
 export * from './modules';
+export * from './lime-forms';

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

@@ -20,7 +20,8 @@ import {
     listSubscriptionsWithExistingData,
 } from './transport';
 
-import { getWebhook, verifyHmac } from './utils';
+import { getWebhook } from './utils';
+import { verifyHmac } from '../common';
 
 /**
  * Trigger node for handling incoming webhooks from **Lime CRM**.

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

@@ -5,6 +5,5 @@ export {
     processFileResponse,
     setFileProperties,
 } from './files';
-export { verifyHmac } from './hmac';
 export { getWebhook } from './webhook';
 export { handleWorkflowError, WorkflowErrorContext } from '../../errorHandling';

package/nodes/lime-forms/LimeFormsTrigger.node.ts

@@ -0,0 +1,258 @@
+import {
+    IHookFunctions,
+    ILoadOptionsFunctions,
+    INodePropertyOptions,
+    INodeType,
+    INodeTypeDescription,
+    IWebhookFunctions,
+    IWebhookResponseData,
+    NodeConnectionTypes,
+    LoggerProxy as Logger,
+    NodeOperationError,
+    NodeApiError,
+    IDataObject,
+} from 'n8n-workflow';
+import { LimeFormsRequest } from './transport/request';
+import { FormExternalIntegrationSimpleResource } from './types/resources/FormExternalIntegrationSimpleResource';
+import {
+    ObservableWebhookDetailedResource,
+    ObservableWebhookSimpleResource,
+} from './types/resources/ObservableWebhookResources';
+import { ObservableActionType } from './types/enums/ObservableAction';
+import { ObservableType } from './types/enums/ObservableType';
+import { FORMS_API_CREDENTIALS_NAME } from '../../credentials';
+import { getWorkflowUrl } from './utils/workflow';
+import { verifyHmac } from '../common';
+import { handleWorkflowError } from '../errorHandling';
+
+const FORMS_OBSERVABLE_WEBHOOK_NAME_PREFIX = 'N8N';
+
+export class LimeFormsTrigger implements INodeType {
+    description: INodeTypeDescription = {
+        displayName: 'Lime Forms Trigger',
+        name: 'limeFormsTrigger',
+        group: ['trigger'],
+        version: 1,
+        icon: 'file:lime-forms.svg',
+        description: 'Handle webhooks from Lime Forms',
+        defaults: {
+            name: 'Lime Forms',
+        },
+        credentials: [
+            {
+                name: FORMS_API_CREDENTIALS_NAME,
+                required: true,
+            },
+        ],
+        inputs: [],
+        outputs: [NodeConnectionTypes.Main],
+        webhooks: [
+            {
+                name: 'default',
+                httpMethod: 'POST',
+                responseMode: 'onReceived',
+                path: 'lime-forms',
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Trigger Name',
+                name: 'name',
+                type: 'string',
+                default: '',
+                placeholder: 'my-lime-webhook',
+                required: true,
+                description: 'Name for this webhook subscription',
+            },
+            {
+                displayName: 'Form to monitor',
+                name: 'formId',
+                type: 'options',
+                typeOptions: {
+                    loadOptionsMethod: 'getForms',
+                },
+                default: '',
+                description:
+                    'Lime Forms to observe submissions for. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+            },
+        ],
+    };
+
+    methods = {
+        loadOptions: {
+            async getForms(
+                this: ILoadOptionsFunctions
+            ): Promise<INodePropertyOptions[]> {
+                const response = await new LimeFormsRequest<
+                    FormExternalIntegrationSimpleResource[]
+                >(this).get('/api/v1/external-integrations/forms/');
+
+                if (!response.success) {
+                    Logger.error(`Lime Forms: Failed to load list of forms`);
+                    return [];
+                }
+
+                return response.data.map((form) => {
+                    return {
+                        name: form.name,
+                        value: form.id,
+                    };
+                });
+            },
+        },
+    };
+
+    webhookMethods = {
+        default: {
+            async checkExists(this: IHookFunctions): Promise<boolean> {
+                const webhookData = this.getWorkflowStaticData('node');
+                const webhookId = webhookData.id;
+                if (webhookId === undefined) {
+                    return false;
+                }
+                try {
+                    const response =
+                        await new LimeFormsRequest<ObservableWebhookSimpleResource>(
+                            this
+                        ).get(`/api/v1/observable-webhooks/${webhookId}`);
+                    return response.data !== null;
+                } catch (error) {
+                    if (error?.response && error.response?.status === 404) {
+                        return false;
+                    }
+                    if (error.message) {
+                        Logger.error(`Lime Forms: ${error.message}`);
+                    }
+                    throw new NodeApiError(this.getNode(), {
+                        message:
+                            'Failed to check if webhook exists in Lime Forms',
+                    });
+                }
+            },
+
+            async create(this: IHookFunctions): Promise<boolean> {
+                const credentials = await this.getCredentials(
+                    FORMS_API_CREDENTIALS_NAME
+                );
+                const data = {
+                    name: `${FORMS_OBSERVABLE_WEBHOOK_NAME_PREFIX}: ${this.getNodeParameter('name')}`,
+                    observableType: ObservableType.FORM,
+                    observableId: this.getNodeParameter('formId'),
+                    action: ObservableActionType.FORM_SUBMITTED,
+                    webhookUrl: this.getNodeWebhookUrl('default'),
+                    secret: credentials.webhookSecret as string,
+                    workflowUrl: getWorkflowUrl(
+                        this.getNode(),
+                        this.getWorkflow().id
+                    ),
+                };
+                const webhookData = this.getWorkflowStaticData('node');
+
+                try {
+                    const response =
+                        await new LimeFormsRequest<ObservableWebhookDetailedResource>(
+                            this
+                        ).post('/api/v1/observable-webhooks', data);
+
+                    if (!response.success) {
+                        throw new NodeApiError(this.getNode(), {
+                            message: 'Failed to create webhook in Lime Forms',
+                        });
+                    }
+
+                    webhookData.id = response.data.id;
+
+                    return true;
+                } catch (error) {
+                    // 409 Indicates duplicate exists
+                    if (error?.httpCode == '409') {
+                        Logger.info(
+                            `Webhook ${webhookData.name} already exists in Lime Forms, retrieving existing webhook ID`,
+                            { errorResponse: error.context?.data }
+                        );
+                        /**
+                         * Error response structure reference:
+                         * @see https://github.com/n8n-io/n8n/blob/n8n%401.120.0/packages/core/src/execution-engine/node-execution-context/utils/request-helper-functions.ts#L1280
+                         */
+                        const errorResponse = error.context?.data?.error;
+                        webhookData.id = errorResponse.id;
+                        webhookData.name = errorResponse.name.replace(
+                            `${FORMS_OBSERVABLE_WEBHOOK_NAME_PREFIX}: `,
+                            ''
+                        );
+                        return true;
+                    }
+                    throw new NodeApiError(this.getNode(), {
+                        message: 'Failed to create webhook in Lime Forms',
+                    });
+                }
+            },
+
+            async delete(this: IHookFunctions): Promise<boolean> {
+                const webhookData = this.getWorkflowStaticData('node');
+                const webhookId = webhookData.id;
+                if (webhookId === undefined) {
+                    return false;
+                }
+
+                const response =
+                    await new LimeFormsRequest<ObservableWebhookSimpleResource>(
+                        this
+                    ).delete(`/api/v1/observable-webhooks/${webhookId}`);
+
+                if (!response.success) {
+                    throw new NodeApiError(this.getNode(), {
+                        message: 'Failed to delete webhook in Lime Forms',
+                    });
+                }
+
+                delete webhookData.id;
+                delete webhookData.secret;
+
+                return true;
+            },
+        },
+    };
+
+    async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
+        const body = this.getBodyData();
+        const headers = this.getHeaderData();
+        const returnData: IDataObject[] = [];
+
+        try {
+            if (!('x-signature' in headers)) {
+                throw new NodeOperationError(
+                    this.getNode(),
+                    'No signature header passed. Unable to verify integrity of the data.'
+                );
+            }
+
+            const webhookSecret = await this.getCredentials(
+                FORMS_API_CREDENTIALS_NAME
+            ).then((c) => c.webhookSecret as string);
+            const isValidSignature = verifyHmac(
+                webhookSecret,
+                Buffer.from(JSON.stringify(body)),
+                ('sha256=' + headers['x-signature']) as string
+            );
+
+            if (!isValidSignature) {
+                throw new NodeOperationError(
+                    this.getNode(),
+                    'Invalid signature'
+                );
+            }
+            returnData.push(body);
+        } catch (error) {
+            const response = handleWorkflowError(this, {
+                message: error.message,
+            });
+
+            returnData.push(response as IDataObject);
+        }
+
+        return {
+            workflowData: [this.helpers.returnJsonArray(returnData)],
+        };
+    }
+}

package/nodes/lime-forms/index.ts

@@ -0,0 +1 @@
+export * from './LimeFormsTrigger.node';

package/nodes/lime-forms/lime-forms.svg

@@ -0,0 +1,6 @@
+<svg viewBox="0 0 1025 1025" xmlns="http://www.w3.org/2000/svg" xml:space="preserve"><clipPath id="a"><path d="M.067.03h1024v1024H.067z"/></clipPath>
+    <g clip-path="url(#a)"><path d="M92.466 480.888c0-257.059 208.718-465.779 465.78-465.779 257.101 0 465.821 208.72 465.821 465.779 0 133.713-55.806 271.139-193.404 385.355-166.779 138.45-390.389 157.35-736.149 134.525-102.653-6.785-117.502-24.319-64.469-63.444C196.74 814.277 92.466 720.157 92.466 480.888Z" style="fill:#a6efff"/>
+        <clipPath id="b"><path d="M92.466 480.888c0-257.059 208.718-465.779 465.78-465.779 257.101 0 465.821 208.72 465.821 465.779 0 133.713-55.806 271.139-193.404 385.355-166.779 138.45-390.389 157.35-736.149 134.525-102.653-6.785-117.502-24.319-64.469-63.444C196.74 814.277 92.466 720.157 92.466 480.888Z"/></clipPath>
+        <g clip-path="url(#b)"><path d="M-810.991 1517.47c-520.197-174.655 602.109-1999.19 1122.31-1824.54 520.198 174.652 347.26 364.038 243.982 791.188-103.277 427.149-846.091 1208-1366.29 1033.35Z" style="fill:#ffa6ea;filter:blur(200px)"/></g>
+        <path d="M415.273 301.267c-40.49 0-73.342 32.894-73.342 73.385 0 40.489 32.852 73.342 73.342 73.342 40.489 0 73.384-32.853 73.384-73.342 0-40.491-32.895-73.385-73.384-73.385Zm168.017 96.552h175.653c12.8 0 23.168-10.368 23.168-23.167 0-12.801-10.368-23.168-23.168-23.168H583.29c-12.8 0-23.168 10.367-23.168 23.168 0 12.799 10.368 23.167 23.168 23.167Zm0 212.345h175.653c12.8 0 23.168-10.367 23.168-23.167 0-12.756-10.368-23.166-23.168-23.166H583.29c-12.8 0-23.168 10.41-23.168 23.166 0 12.8 10.368 23.167 23.168 23.167Zm-168.017-96.509c-40.49 0-73.342 32.853-73.342 73.342 0 40.49 32.852 73.385 73.342 73.385 40.489 0 73.384-32.895 73.384-73.385 0-40.489-32.895-73.342-73.384-73.342Z"
+              style="fill:#fff"/></g></svg>

package/nodes/lime-forms/transport/request.ts

@@ -0,0 +1,60 @@
+import {
+    IHookFunctions,
+    ILoadOptionsFunctions,
+    IHttpRequestMethods,
+    NodeApiError,
+} from 'n8n-workflow';
+import { FORMS_API_CREDENTIALS_NAME } from '../../../credentials';
+import { BaseResponse } from '../types/resources/BaseResponse';
+
+export class LimeFormsRequest<T = unknown> {
+    constructor(
+        private readonly loader: ILoadOptionsFunctions | IHookFunctions
+    ) {}
+
+    public async get(url: string): Promise<BaseResponse<T>> {
+        return this.baseRequest('GET', url, undefined);
+    }
+
+    public async post(url: string, data: object): Promise<BaseResponse<T>> {
+        return this.baseRequest('POST', url, data);
+    }
+
+    public async put(url: string, data: object): Promise<BaseResponse<T>> {
+        return this.baseRequest('PUT', url, data);
+    }
+
+    public async delete(url: string): Promise<BaseResponse<T>> {
+        return this.baseRequest('DELETE', url);
+    }
+
+    private async baseRequest(
+        method: string,
+        url: string,
+        data: object | undefined = undefined
+    ): Promise<BaseResponse<T>> {
+        // Get credentials for the API
+        const credentials = await this.loader.getCredentials(
+            FORMS_API_CREDENTIALS_NAME
+        );
+        if (credentials === undefined) {
+            throw new NodeApiError(this.loader.getNode(), {
+                message: 'No credentials provided',
+            });
+        }
+        return await this.loader.helpers.httpRequestWithAuthentication.call(
+            this.loader,
+            FORMS_API_CREDENTIALS_NAME,
+            {
+                method: method as IHttpRequestMethods,
+                url: url,
+                json: true,
+                body: data,
+                baseURL: credentials.url as string,
+                headers: {
+                    Accept: 'application/json',
+                },
+            }
+        );
+    }
+}

package/nodes/lime-forms/types/enums/ObservableAction.ts

@@ -0,0 +1,7 @@
+export enum ObservableActionType {
+    GENERIC_CREATE = 'GENERIC_CREATE',
+    GENERIC_UPDATE = 'GENERIC_UPDATE',
+    GENERIC_DELETE = 'GENERIC_DELETE',
+
+    FORM_SUBMITTED = 'FORM_SUBMITTED',
+}

package/nodes/lime-forms/types/enums/ObservableType.ts

@@ -0,0 +1,3 @@
+export enum ObservableType {
+    FORM = 'FORM',
+}

package/nodes/lime-forms/types/resources/BaseResponse.ts

@@ -0,0 +1,4 @@
+export type BaseResponse<T = null> = {
+    success: boolean;
+    data: T;
+};

package/nodes/lime-forms/types/resources/FormExternalIntegrationSimpleResource.ts

@@ -0,0 +1,4 @@
+export type FormExternalIntegrationSimpleResource = {
+    id: number;
+    name: string;
+};

package/nodes/lime-forms/types/resources/ObservableWebhookResources.ts

@@ -0,0 +1,16 @@
+import { ObservableActionType } from '../enums/ObservableAction';
+import { ObservableType } from '../enums/ObservableType';
+
+export type ObservableWebhookSimpleResource = {
+    id: number;
+    name: string;
+    observableType: ObservableType;
+    observableId: number;
+    action: ObservableActionType;
+    webhookUrl: string;
+};
+
+export type ObservableWebhookDetailedResource =
+    ObservableWebhookSimpleResource & {
+        secret: string;
+    };

package/nodes/lime-forms/utils/workflow.ts

@@ -0,0 +1,17 @@
+import { URL } from 'node:url';
+import { INode, NodeOperationError } from 'n8n-workflow';
+
+export function getWorkflowUrl(
+    node: INode,
+    workflowId: string | undefined
+): string | undefined {
+    const baseUrl = process.env.WEBHOOK_URL;
+    if (baseUrl === undefined || workflowId === undefined) {
+        throw new NodeOperationError(
+            node,
+            'WEBHOOK_URL is not set or workflowId is undefined'
+        );
+    }
+
+    return new URL(`${baseUrl}/workflow/${workflowId}`).href;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "2.5.5-dev.1",
+  "version": "2.6.0",
   "description": "n8n node to connect to Lime CRM",
   "license": "Apache-2.0",
   "main": "nodes/index.ts",
@@ -22,19 +22,24 @@
     "n8n-node",
     "lime-crm",
     "crm",
+    "lime-forms",
+    "lime-technologies",
+    "lundalogik",
     "n8n-community-node-package"
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,
     "credentials": [
       "dist/credentials/LimeCrmApi.credentials.js",
-      "dist/credentials/FortnoxApi.credentials.js"
+      "dist/credentials/FortnoxApi.credentials.js",
+      "dist/credentials/LimeFormsApi.credentials.js"
     ],
     "nodes": [
       "dist/nodes/lime-crm/LimeCrmNode.node.js",
       "dist/nodes/lime-crm/LimeCrmTrigger.node.js",
       "dist/nodes/fortnox/Fortnox.node.js",
-      "dist/nodes/fortnox/FortnoxTrigger.node.js"
+      "dist/nodes/fortnox/FortnoxTrigger.node.js",
+      "dist/nodes/lime-forms/LimeFormsTrigger.node.js"
     ]
   },
   "devDependencies": {

package/.prettierignore

@@ -1,6 +0,0 @@
-dist/
-node_modules/
-restore_script/
-package-lock.json
-CHANGELOG.md
-README

package/dist/nodes/lime-crm/utils/hmac.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hmac.js","sourceRoot":"","sources":["../../../../nodes/lime-crm/utils/hmac.ts"],"names":[],"mappings":";;AA4BA,gCAMC;AAlCD,6CAAyC;AAYzC,SAAS,YAAY,CAAC,GAAW,EAAE,IAAY;IAC3C,OAAO,SAAS,GAAG,IAAA,wBAAU,EAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC5E,CAAC;AAcD,SAAgB,UAAU,CACtB,GAAW,EACX,IAAY,EACZ,YAAoB;IAEpB,OAAO,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,YAAY,CAAC;AACpD,CAAC"}