@limetech/n8n-nodes-lime 0.3.7 → 0.4.0

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

@@ -14,12 +14,14 @@ import {
 } from './resources/erpConnector';
 import { limeTypeFields, limeTypeOperations } from './resources/limeType';
 import { limeObjectFields, limeObjectOperations } from './resources/limeObject';
+import { queryFields, queryOperations } from './resources/limeQuery';
 
 import {
     LIMEOBJECT_RESOURCE,
     LIMETYPE_RESOURCE,
     LIME_CRM_API_CREDENTIAL_KEY,
     ERP_CONNECTOR_RESOURCE,
+    LIME_QUERY_RESOURCE,
 } from './commons';
 
 import {
@@ -71,6 +73,12 @@ export class LimeCrmNode implements INodeType {
                         value: ERP_CONNECTOR_RESOURCE,
                         description: 'Integrate data between ERP and Lime CRM',
                     },
+                    {
+                        name: 'Lime Query',
+                        value: LIME_QUERY_RESOURCE,
+                        description:
+                            'Easily gather a particular set of limeobjects',
+                    },
                 ],
                 default: LIMEOBJECT_RESOURCE,
             },
@@ -78,6 +86,7 @@ export class LimeCrmNode implements INodeType {
             ...(limeTypeFields as INodeProperties[]),
             ...(limeObjectFields as INodeProperties[]),
             ...(erpConnectorFields as INodeProperties[]),
+            ...(queryFields as INodeProperties[]),
         ],
     };
 
@@ -114,6 +123,11 @@ export class LimeCrmNode implements INodeType {
                         operation,
                         i,
                     });
+                } else if (resource === LIME_QUERY_RESOURCE) {
+                    responseData = await queryOperations.call(this, {
+                        operation,
+                        i,
+                    });
                 }
 
                 returnData.push({ json: responseData });

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

@@ -19,6 +19,8 @@ import {
     listSubscriptionsWithExistingData,
 } from './transport';
 
+import { verifyHmac } from './commons/hmac';
+
 export class LimeCrmTrigger implements INodeType {
     description: INodeTypeDescription = {
         displayName: 'Lime CRM Trigger',
@@ -174,9 +176,17 @@ export class LimeCrmTrigger implements INodeType {
                 }
 
                 if (existingSubscriptionResponse.data.length === 0) {
+                    const credentials = await this.getCredentials(
+                        LIME_CRM_API_CREDENTIAL_KEY
+                    );
+                    const webhookCreateData = {
+                        ...webhook,
+                        secret: credentials.webhookSecret as string,
+                    };
+
                     const createSubscriptionResponse = await createSubscription(
                         this,
-                        webhook
+                        webhookCreateData
                     );
 
                     if (!createSubscriptionResponse.success) {
@@ -238,7 +248,24 @@ export class LimeCrmTrigger implements INodeType {
         Logger.info('Webhook received. Starting webhook processing...', {
             ...webhook.context,
         });
+        const credentials = await this.getCredentials(
+            LIME_CRM_API_CREDENTIAL_KEY
+        );
+        const webhookSecret = credentials.webhookSecret as string;
+        const requestObject = this.getRequestObject();
+        const headerData = this.getHeaderData();
         const bodyData = this.getBodyData();
+        const limeSignature = headerData['x-lime-signature'] as string;
+
+        if (
+            (webhookSecret || limeSignature) &&
+            !verifyHmac(webhookSecret, requestObject.rawBody, limeSignature)
+        ) {
+            throw new NodeOperationError(
+                this.getNode(),
+                'Webhook authentication failed, secret keys do not match!'
+            );
+        }
 
         if (!bodyData || !bodyData.event || !bodyData.body) {
             Logger.warn('Webhook data is invalid. Missing event or body', {
@@ -251,10 +278,9 @@ export class LimeCrmTrigger implements INodeType {
         }
 
         const returnData: IDataObject[] = [];
-
         returnData.push({
             body: bodyData,
-            headers: this.getHeaderData(),
+            headers: headerData,
             query: this.getQueryData(),
         });
 

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

@@ -7,3 +7,4 @@ export const LIME_CRM_API_CREDENTIAL_KEY = 'limeCrmApi';
 export const LIMEOBJECT_RESOURCE = 'limeObject';
 export const LIMETYPE_RESOURCE = 'limeType';
 export const ERP_CONNECTOR_RESOURCE = 'erpConnector';
+export const LIME_QUERY_RESOURCE = 'limeQuery';

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

@@ -0,0 +1,13 @@
+import { createHmac } from 'node:crypto';
+
+function _generateHmac(key: string, data: Buffer): string {
+    return 'sha256=' + createHmac('sha256', key).update(data).digest('hex');
+}
+
+export function verifyHmac(
+    key: string,
+    data: Buffer,
+    comparedHmac: string
+): boolean {
+    return _generateHmac(key, data) === comparedHmac;
+}

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

@@ -3,6 +3,7 @@ export {
     LIMEOBJECT_RESOURCE,
     LIMETYPE_RESOURCE,
     ERP_CONNECTOR_RESOURCE,
+    LIME_QUERY_RESOURCE,
 } from './constants';
 export { Webhook, getWebhook } from './webhook';
 

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

@@ -17,6 +17,10 @@ export interface Webhook {
     name: string;
 }
 
+export interface CreateWebhook extends Webhook {
+    secret?: string;
+}
+
 function _getEvents(hookData: WebhookFunctions): string[] {
     const eventData = hookData.getNodeParameter('events', []) as {
         event: Array<{

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

@@ -8,7 +8,7 @@ import * as create from './operations/create.operation';
 import * as get from './operations/get.operation';
 import * as update from './operations/update.operation';
 import * as delete_ from './operations/delete.operation';
-import * as search from './operations/search.operation';
+import * as fetchMany from './operations/fetchMany.operation';
 
 import { LIMEOBJECT_RESOURCE } from '../../commons';
 
@@ -28,16 +28,16 @@ export const limeObjectFields: INodeProperties[] = [
             get.description,
             update.description,
             delete_.description,
-            search.description,
+            fetchMany.description,
         ],
-        default: 'search',
+        default: 'fetchMany',
     },
 
     ...create.properties,
     ...get.properties,
     ...update.properties,
     ...delete_.properties,
-    ...search.properties,
+    ...fetchMany.properties,
 ];
 
 export async function limeObjectOperations(
@@ -56,8 +56,8 @@ export async function limeObjectOperations(
     if (operation === 'delete') {
         return await delete_.execute.call(this, i);
     }
-    if (operation === 'search') {
-        return await search.execute.call(this, i);
+    if (operation === 'fetchMany') {
+        return await fetchMany.execute.call(this, i);
     }
 
     return null;

package/nodes/lime-crm/resources/limeObject/operations/{search.operation.ts → fetchMany.operation.ts}

@@ -1,12 +1,12 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { searchLimeObject } from '../../../transport';
+import { fetchManyLimeObjects } from '../../../transport';
 import { LIMEOBJECT_RESOURCE } from '../../../commons';
 
 export const description = {
-    name: 'Search',
-    value: 'search',
-    description: 'Search for objects',
-    action: 'Search for objects',
+    name: 'Fetch many',
+    value: 'fetchMany',
+    description: 'Fetch many Lime objects',
+    action: 'Fetch many objects',
 };
 
 export const properties: INodeProperties[] = [
@@ -23,7 +23,7 @@ export const properties: INodeProperties[] = [
         displayOptions: {
             show: {
                 resource: [LIMEOBJECT_RESOURCE],
-                operation: ['search'],
+                operation: ['fetchMany'],
             },
         },
     },
@@ -36,7 +36,7 @@ export const properties: INodeProperties[] = [
         displayOptions: {
             show: {
                 resource: [LIMEOBJECT_RESOURCE],
-                operation: ['search'],
+                operation: ['fetchMany'],
             },
         },
     },
@@ -54,7 +54,7 @@ export const properties: INodeProperties[] = [
         displayOptions: {
             show: {
                 resource: [LIMEOBJECT_RESOURCE],
-                operation: ['search'],
+                operation: ['fetchMany'],
             },
         },
     },
@@ -70,7 +70,7 @@ export const properties: INodeProperties[] = [
         displayOptions: {
             show: {
                 resource: [LIMEOBJECT_RESOURCE],
-                operation: ['search'],
+                operation: ['fetchMany'],
             },
         },
     },
@@ -86,7 +86,7 @@ export const properties: INodeProperties[] = [
         displayOptions: {
             show: {
                 resource: [LIMEOBJECT_RESOURCE],
-                operation: ['search'],
+                operation: ['fetchMany'],
             },
         },
     },
@@ -100,7 +100,7 @@ export async function execute(this: IExecuteFunctions, i: number) {
     const offset = this.getNodeParameter('offset', i, 0) as number;
     const options = this.getNodeParameter('options', i, {});
 
-    return await searchLimeObject(
+    return await fetchManyLimeObjects(
         this,
         limeType,
         searchField,

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

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

package/nodes/lime-crm/resources/limeQuery/operations/query.operation.ts

@@ -0,0 +1,222 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { queryLimeObjects } from '../../../transport';
+import { LIME_QUERY_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Query',
+    value: 'query',
+    description: 'Query objects with Lime Query API',
+    action: 'Query objects',
+};
+
+interface OrderByCollection {
+    orderByFields: {
+        propertyName: string;
+        sortDirection: 'ASC' | 'DESC';
+    }[];
+}
+
+interface ActiveObjectCollection {
+    activeObjectFields: {
+        limetype: string;
+        id: number;
+    };
+}
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Lime Type',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to query',
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+    },
+    {
+        displayName: 'Response Format (JSON)',
+        name: 'responseFormat',
+        type: 'json',
+        required: true,
+        default: '{}',
+        description: 'Information that should be included in the response',
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+    },
+    {
+        displayName: 'Filter (JSON)',
+        name: 'filter',
+        type: 'json',
+        default: '{}',
+        description: "The filter DSL defining the query's conditions",
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: null,
+        description: 'The maximum number of records to return',
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+    },
+    {
+        displayName: 'Order By',
+        name: 'orderBy',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        description:
+            'The list of properties by which to order the query results',
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+        options: [
+            {
+                name: 'orderByFields',
+                displayName: 'Order By Fields',
+                values: [
+                    {
+                        displayName: 'Property Name',
+                        name: 'propertyName',
+                        type: 'string',
+                        description: 'Name of the property to order by',
+                        default: '',
+                        required: true,
+                    },
+                    {
+                        displayName: 'Sort Direction',
+                        name: 'sortDirection',
+                        type: 'options',
+                        default: 'ASC',
+                        description: 'Ordering direction',
+                        options: [
+                            { name: 'ASC', value: 'ASC' },
+                            { name: 'DESC', value: 'DESC' },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Offset',
+        name: 'offset',
+        type: 'number',
+        default: null,
+        description:
+            'The offset from which to start returning records. This operation requires the `Order By` field to be set',
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+    },
+    {
+        displayName: 'Active Object',
+        name: 'activeObject',
+        type: 'fixedCollection',
+        default: {},
+        description:
+            "A dict with keys 'limetype' and 'id' representing the active object in the context of the query",
+        displayOptions: {
+            show: {
+                resource: [LIME_QUERY_RESOURCE],
+                operation: ['query'],
+            },
+        },
+        options: [
+            {
+                name: 'activeObjectFields',
+                displayName: 'Active Object Fields',
+                values: [
+                    {
+                        displayName: 'Lime Type',
+                        name: 'limetype',
+                        type: 'options',
+                        description: 'Name of the limetype',
+                        default: '',
+                        typeOptions: {
+                            loadOptionsMethod: 'getLimeTypes',
+                        },
+                        required: true,
+                    },
+                    {
+                        displayName: 'Lime Object ID',
+                        name: 'id',
+                        type: 'number',
+                        default: 0,
+                        description:
+                            'ID representing the object in the context of the query',
+                        required: true,
+                    },
+                ],
+            },
+        ],
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limeType = this.getNodeParameter('limeType', i) as string;
+    const responseFormat = this.getNodeParameter('responseFormat', i) as string;
+    const filter = this.getNodeParameter('filter', i) as string;
+    const limit = this.getNodeParameter('limit', i) as number;
+    const offset = this.getNodeParameter('offset', i) as number;
+    const orderByCollection = this.getNodeParameter(
+        'orderBy',
+        i
+    ) as OrderByCollection;
+    const activeObjectCollection = this.getNodeParameter(
+        'activeObject',
+        i
+    ) as ActiveObjectCollection;
+
+    const orderBy =
+        orderByCollection.orderByFields &&
+        orderByCollection.orderByFields.map((field) => ({
+            [field.propertyName]: field.sortDirection,
+        }));
+
+    const q = JSON.stringify({
+        limetype: limeType,
+        responseFormat: JSON.parse(responseFormat),
+        filter: JSON.parse(filter),
+        limit: limit,
+        offset: offset,
+        orderBy: orderBy,
+    });
+
+    const activeObject = JSON.stringify(
+        activeObjectCollection.activeObjectFields
+    );
+
+    return queryLimeObjects(this, q, activeObject);
+}

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

@@ -11,7 +11,8 @@ export {
     deleteLimeObject,
     updateLimeObject,
     getLimeObject,
-    searchLimeObject,
+    fetchManyLimeObjects,
 } from './limeobjects';
 export { startCreateOrUpdateObjectsTask } from './erpConnector';
+export { queryLimeObjects } from './limeQuery';
 export { callLimeApi } from './commons';

package/nodes/lime-crm/transport/limeQuery.ts

@@ -0,0 +1,28 @@
+import { IAllExecuteFunctions } from 'n8n-workflow';
+import { NodeResponse } from '../../nodeResponse';
+import { callLimeApi } from './commons';
+
+const LIME_QUERY_URL = '/api/v1/query/';
+
+interface IncludedProperties {
+    [key: string]: IncludedProperties | string | number | boolean | null;
+}
+
+export interface QueryResponse {
+    objects: IncludedProperties[];
+}
+
+export async function queryLimeObjects(
+    nodeContext: IAllExecuteFunctions,
+    q: string,
+    activeObject: string
+): Promise<NodeResponse<QueryResponse>> {
+    const queryParameters = {
+        q: q,
+        activeObject: activeObject,
+    };
+
+    return await callLimeApi(nodeContext, 'GET', LIME_QUERY_URL, {
+        qs: queryParameters,
+    });
+}

package/nodes/lime-crm/transport/limeobjects.ts

@@ -4,7 +4,7 @@ import { NodeResponse } from '../../nodeResponse';
 
 const LIMEOBJECT_URL = '/api/v1/limeobject/';
 
-interface SearchLimeobjectApiResponse {
+interface FetchManyLimeObjectsApiResponse {
     _embedded: {
         limeobjects: Array<object>;
     };
@@ -103,7 +103,7 @@ async function _searchLimeObjectWithLimit(
     limit: number,
     offset: number,
     qs: IDataObject
-): Promise<NodeResponse<SearchLimeobjectApiResponse>> {
+): Promise<NodeResponse<FetchManyLimeObjectsApiResponse>> {
     const returnData = [];
     let hasMoreData = true;
     let currentOffset = Math.max(0, offset);
@@ -113,7 +113,7 @@ async function _searchLimeObjectWithLimit(
         qs._limit = Math.min(limit, pageLimit);
         qs._offset = currentOffset;
 
-        const response = await callLimeApi<SearchLimeobjectApiResponse>(
+        const response = await callLimeApi<FetchManyLimeObjectsApiResponse>(
             nodeContext,
             'GET',
             url,
@@ -143,7 +143,7 @@ async function _searchLimeObjectWithLimit(
     };
 }
 
-export async function searchLimeObject(
+export async function fetchManyLimeObjects(
     nodeContext: IAllExecuteFunctions,
     limeType: string,
     searchField: string,
@@ -169,7 +169,7 @@ export async function searchLimeObject(
             qs
         );
     } else {
-        response = await callLimeApi<SearchLimeobjectApiResponse>(
+        response = await callLimeApi<FetchManyLimeObjectsApiResponse>(
             nodeContext,
             'GET',
             url,
@@ -186,7 +186,9 @@ export async function searchLimeObject(
         };
     }
     return {
-        ...response,
+        success: response.success,
+        error: response.error,
+        status: response.status,
         metadata: {
             ...response.metadata,
             limeType: limeType,

package/nodes/lime-crm/transport/webhooks.ts

@@ -2,6 +2,7 @@ import { Webhook } from '../commons';
 import { callLimeApi } from '.';
 import { IAllExecuteFunctions } from 'n8n-workflow';
 import { NodeResponse } from '../../nodeResponse';
+import { CreateWebhook } from '../commons/webhook';
 
 const SUBSCRIPTION_URL = 'api/v1/subscription/';
 
@@ -39,13 +40,14 @@ export async function listSubscriptionsWithExistingData(
 
 export async function createSubscription(
     nodeContext: IAllExecuteFunctions,
-    webhook: Webhook
+    webhook: CreateWebhook
 ): Promise<NodeResponse<ApiResponseWebhook>> {
     return await callLimeApi(nodeContext, 'POST', SUBSCRIPTION_URL, {
         body: {
             events: webhook.events,
             target_url: webhook.url,
             name: webhook.name,
+            secret: webhook.secret,
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.3.7",
+  "version": "0.4.0",
   "description": "n8n node to connect to Lime CRM",
   "license": "MIT",
   "main": "index.js",
@@ -30,6 +30,7 @@
     ],
     "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"
     ]