@limetech/n8n-nodes-lime 0.3.8 → 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/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/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/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

@@ -14,4 +14,5 @@ export {
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "description": "n8n node to connect to Lime CRM",
   "license": "MIT",
   "main": "index.js",