@limetech/n8n-nodes-lime 0.3.8 → 0.5.0

package/nodes/lime-crm/model.ts

@@ -0,0 +1,22 @@
+type LimetypeProperty = {
+    name: string;
+    localname: string;
+    type: string;
+} & Record<string, unknown>;
+
+type LimetypeLocalName = {
+    singular: string;
+    plural: string;
+};
+
+type Limetype = {
+    name: string;
+    localname: LimetypeLocalName;
+    properties: LimetypeProperty[];
+} & Record<string, unknown>;
+
+type Limeobject = {
+    id_: number;
+} & Record<string, unknown>;
+
+export { LimetypeProperty, Limetype, Limeobject };

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

@@ -0,0 +1,80 @@
+import {
+    INodeExecutionData,
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+import * as createSingleObject from './operations/createSingleObject';
+import * as getSingleObject from './operations/getSingleObject';
+import * as updateSingleObject from './operations/updateSingleObject.operation';
+import * as deleteSingleObject from './operations/deleteSingleObject';
+import * as getManyObjects from './operations/getManyObjects';
+import * as getSingleFile from './operations/getSingleFile';
+
+import { DATA_RESOURCE } from '../../commons';
+
+export const dataFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+            },
+        },
+        options: [
+            createSingleObject.description,
+            getSingleObject.description,
+            updateSingleObject.description,
+            deleteSingleObject.description,
+            getManyObjects.description,
+            getSingleFile.description,
+        ],
+        default: 'fetchMany',
+    },
+
+    ...createSingleObject.properties,
+    ...getSingleObject.properties,
+    ...updateSingleObject.properties,
+    ...deleteSingleObject.properties,
+    ...getSingleFile.properties,
+    ...getManyObjects.properties,
+];
+
+export async function dataOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+): Promise<INodeExecutionData> {
+    switch (operation) {
+        case 'createSingleObject': {
+            return { json: await createSingleObject.execute.call(this, i) };
+        }
+        case 'getSingleObject': {
+            return await getSingleObject.execute.call(this, i);
+        }
+        case 'updateSingleObject': {
+            return { json: await updateSingleObject.execute.call(this, i) };
+        }
+        case 'deleteSingleObject': {
+            await deleteSingleObject.execute.call(this, i);
+            return { json: { success: true } };
+        }
+        case 'getManyObjects': {
+            return {
+                json: await getManyObjects.execute.call(this, i),
+            };
+        }
+        case 'getSingleFile': {
+            return await getSingleFile.execute.call(this, i);
+        }
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The operation "${operation}" is not supported!`
+    );
+}

package/nodes/lime-crm/resources/{limeObject/operations/create.operation.ts → data/operations/createSingleObject.ts}

@@ -1,35 +1,38 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { createLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
+import { createLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+import {
+    getFileProperties,
+    processFileResponse,
+    setFileProperties,
+} from '../../../commons/files';
 
 export const description = {
-    name: 'Create Object',
-    value: 'create',
-    description: 'Create a new object',
-    action: 'Create an object',
+    name: 'Create Single Object',
+    value: 'createSingleObject',
+    description: 'Create a single new object',
+    action: 'Create single object',
 };
 
 export const properties: INodeProperties[] = [
     {
-        displayName: 'LimeType',
-        name: 'limeType',
+        displayName: 'Limetype',
+        name: 'limetype',
         type: 'options',
         typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
+            loadOptionsMethod: 'getLimetypes',
         },
         required: true,
         default: '',
         description: 'The type of entity to create',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
             },
         },
     },
-
-    // Object data input method
     {
         displayName: 'Input Method',
         name: 'inputMethod',
@@ -48,13 +51,11 @@ export const properties: INodeProperties[] = [
         description: 'How to input the object data',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
             },
         },
     },
-
-    // Dynamic properties for form input
     {
         displayName: 'Properties',
         name: 'properties',
@@ -62,15 +63,12 @@ export const properties: INodeProperties[] = [
         placeholder: 'Add Property',
         typeOptions: {
             multipleValues: true,
-            sortable: true,
-            loadOptionsMethod: 'getLimeTypeProperties',
-            loadOptionsDependsOn: ['limeType'],
         },
         default: {},
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
                 inputMethod: ['fields'],
             },
         },
@@ -84,8 +82,9 @@ export const properties: INodeProperties[] = [
                         name: 'name',
                         type: 'options',
                         typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
+                            sortable: true,
+                            loadOptionsMethod: 'getLimetypeProperties',
+                            loadOptionsDependsOn: ['limetype'],
                         },
                         default: '',
                         description: 'Name of the property',
@@ -101,8 +100,6 @@ export const properties: INodeProperties[] = [
             },
         ],
     },
-
-    // JSON input
     {
         displayName: 'Object (JSON)',
         name: 'objectJson',
@@ -111,8 +108,8 @@ export const properties: INodeProperties[] = [
         description: 'Object to create in JSON format',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
                 inputMethod: ['json'],
             },
         },
@@ -123,7 +120,7 @@ export const properties: INodeProperties[] = [
 ];
 
 export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
+    const limetype = this.getNodeParameter('limetype', i) as string;
     const inputMethod = this.getNodeParameter('inputMethod', i) as string;
 
     let objectData: IDataObject;
@@ -148,5 +145,31 @@ export async function execute(this: IExecuteFunctions, i: number) {
         }
     }
 
-    return await createLimeObject(this, limeType, objectData);
+    const fileProperties = await getFileProperties(
+        this,
+        limetype,
+        new Set(Object.keys(objectData))
+    );
+
+    const setFilePropertiesResponse = await setFileProperties(
+        this,
+        i,
+        fileProperties,
+        objectData
+    );
+    if (!setFilePropertiesResponse.success) return setFilePropertiesResponse;
+
+    const createLimeobjectResponse = await createLimeobject(
+        this,
+        limetype,
+        setFilePropertiesResponse.data
+    );
+    if (!createLimeobjectResponse.success) return createLimeobjectResponse;
+
+    const response = await processFileResponse(
+        this,
+        fileProperties,
+        createLimeobjectResponse.data
+    );
+    return response.json;
 }

package/nodes/lime-crm/resources/{limeObject/operations/delete.operation.ts → data/operations/deleteSingleObject.ts}

@@ -1,31 +1,31 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { deleteLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
+import { deleteLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
 
 export const description = {
-    name: 'Delete Object',
-    value: 'delete',
-    description: 'Delete an existing object',
-    action: 'Delete an object',
+    name: 'Delete Single Object',
+    value: 'deleteSingleObject',
+    description: 'Delete one specific object',
+    action: 'Delete single object',
 };
 
 export const properties: INodeProperties[] = [
     // Limetype selection
     {
-        displayName: 'Lime Type',
-        name: 'limeType',
+        displayName: 'Limetype',
+        name: 'limetype',
         type: 'options',
         typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
+            loadOptionsMethod: 'getLimetypes',
         },
         required: true,
         default: '',
         description: 'The type of entity to delete',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['delete'],
+                resource: [DATA_RESOURCE],
+                operation: ['deleteSingleObject'],
             },
         },
     },
@@ -40,16 +40,16 @@ export const properties: INodeProperties[] = [
         description: 'The ID of the object to delete',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['delete'],
+                resource: [DATA_RESOURCE],
+                operation: ['deleteSingleObject'],
             },
         },
     },
 ];
 
 export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
+    const limetype = this.getNodeParameter('limetype', i) as string;
     const objectId = this.getNodeParameter('objectId', i) as string;
 
-    return await deleteLimeObject(this, limeType, objectId);
+    return await deleteLimeobject(this, limetype, objectId);
 }

package/nodes/lime-crm/resources/data/operations/getManyObjects.ts

@@ -0,0 +1,356 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { queryLimeobjects } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Many Objects',
+    value: 'getManyObjects',
+    description: 'Get a list of many objects',
+    action: 'Get many objects',
+};
+
+const BATCHSIZE = 50;
+
+interface ResponseFormat {
+    object: {
+        [key: string]: string;
+    };
+}
+
+interface OrderByCollection {
+    orderByFields: {
+        propertyName: string;
+        sortDirection: 'ASC' | 'DESC';
+    }[];
+}
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to query',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Response Format',
+        name: 'responseFormatInputMethod',
+        type: 'options',
+        required: true,
+        default: 'fields',
+        description: 'Select how the response should be formatted',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+        options: [
+            {
+                name: 'Properties',
+                value: 'fields',
+            },
+            {
+                name: 'JSON',
+                value: 'json',
+            },
+        ],
+    },
+    {
+        displayName: 'Response Format (Form Fields)',
+        name: 'responseFormatProperties',
+        type: 'fixedCollection',
+        placeholder: 'Add Property',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                responseFormatInputMethod: ['fields'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Property',
+                name: 'property',
+                values: [
+                    {
+                        displayName: 'Property Name',
+                        name: 'name',
+                        type: 'options',
+                        typeOptions: {
+                            sortable: true,
+                            loadOptionsMethod: 'getNoHasManyProperties',
+                            loadOptionsDependsOn: ['limetype'],
+                        },
+                        default: '',
+                        description: 'Name of the property',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Response Format (JSON)',
+        name: 'responseFormatJson',
+        type: 'json',
+        required: true,
+        default: '{\n\t"object": {\n\t\t"_id": ""\n\t}\n}',
+        description:
+            'Information included in the response when using JSON format',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                responseFormatInputMethod: ['json'],
+            },
+        },
+    },
+    {
+        displayName: 'Filter (JSON)',
+        name: 'filter',
+        type: 'json',
+        default: '{}',
+        description: "The filter DSL defining the query's conditions",
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        description: 'The maximum number of records to return',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Order By',
+        name: 'orderByInputMethod',
+        type: 'options',
+        required: true,
+        default: 'fields',
+        description: 'Select how the response should be ordered',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+        options: [
+            {
+                name: 'Form Fields',
+                value: 'fields',
+            },
+            {
+                name: 'JSON',
+                value: 'json',
+            },
+        ],
+    },
+    {
+        displayName: 'Order By (Form Fields)',
+        name: 'orderByProperties',
+        type: 'fixedCollection',
+        placeholder: 'Add Property',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        description:
+            'The list of properties by which to order the query results',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                orderByInputMethod: ['fields'],
+            },
+        },
+        options: [
+            {
+                name: 'orderByFields',
+                displayName: 'Order By Fields',
+                values: [
+                    {
+                        displayName: 'Property Name',
+                        name: 'propertyName',
+                        type: 'options',
+                        required: true,
+                        typeOptions: {
+                            sortable: true,
+                            loadOptionsMethod: 'getNoHasManyProperties',
+                            loadOptionsDependsOn: ['limetype'],
+                        },
+                        default: '',
+                        description: 'Name of the property to order by',
+                    },
+                    {
+                        displayName: 'Sort Direction',
+                        name: 'sortDirection',
+                        type: 'options',
+                        default: 'ASC',
+                        description: 'Ordering direction',
+                        options: [
+                            { name: 'Ascending', value: 'ASC' },
+                            { name: 'Descending', value: 'DESC' },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Order By (JSON)',
+        name: 'orderByJson',
+        type: 'json',
+        required: true,
+        default: '[\n\t{\n\t\t"_id": "ASC"\n\t}\n]',
+        description: 'Provide ordering in JSON',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                orderByInputMethod: ['json'],
+            },
+        },
+    },
+];
+
+function _createResponseFormatObject(
+    properties: { name: string }[] = []
+): ResponseFormat {
+    const object: Record<string, string> = { _id: '' };
+    for (const { name } of properties) {
+        if (name) object[name] = '';
+    }
+    return { object };
+}
+
+function _getOrderBy(orderByCollection: OrderByCollection) {
+    const orderBy =
+        orderByCollection.orderByFields &&
+        orderByCollection.orderByFields.map((field) => ({
+            [field.propertyName]: field.sortDirection,
+        }));
+    return orderBy || [{ _id: 'ASC' }];
+}
+
+async function _fetchLimeObjectsInBatches(
+    this: IExecuteFunctions,
+    limetype: string,
+    responseFormat: ResponseFormat,
+    filter: string,
+    limit: number,
+    orderBy: Array<{ [key: string]: 'ASC' | 'DESC' }>
+) {
+    if (limit <= BATCHSIZE) {
+        const q = JSON.stringify({
+            limetype,
+            responseFormat: responseFormat,
+            filter: JSON.parse(filter),
+            limit: limit,
+            offset: 0,
+            orderBy: orderBy,
+        });
+        return queryLimeobjects(this, q);
+    } else {
+        let allResults: unknown[] = [];
+        let fetched = 0;
+        let currentOffset = 0;
+        while (fetched < limit) {
+            const currentLimit = Math.min(BATCHSIZE, limit - fetched);
+            const q = JSON.stringify({
+                limetype,
+                responseFormat: responseFormat,
+                filter: JSON.parse(filter),
+                limit: currentLimit,
+                offset: currentOffset,
+                orderBy,
+            });
+            const batch = await queryLimeobjects(this, q);
+            if (!batch.success) {
+                return batch;
+            }
+            const collected = batch.data.objects.length;
+            if (!batch || collected === 0) break;
+            allResults = [...allResults, ...batch.data.objects];
+            fetched += collected;
+            currentOffset += collected;
+
+            if (collected < currentLimit) break;
+        }
+        return {
+            success: true,
+            data: allResults,
+        };
+    }
+}
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limetype = this.getNodeParameter('limetype', i) as string;
+    const responseFormatInputMethod = this.getNodeParameter(
+        'responseFormatInputMethod',
+        i
+    ) as string;
+    const orderByInputMethod = this.getNodeParameter(
+        'orderByInputMethod',
+        i
+    ) as string;
+    const filter = this.getNodeParameter('filter', i) as string;
+    const limit = this.getNodeParameter('limit', i, 50) as number;
+
+    let response;
+    if (responseFormatInputMethod === 'fields') {
+        const properties = this.getNodeParameter(
+            'responseFormatProperties',
+            i
+        ) as { property: [{ name: string }] };
+        response = _createResponseFormatObject(properties.property);
+    } else if (responseFormatInputMethod === 'json') {
+        response = this.getNodeParameter('responseFormatJson', i) as string;
+        response = JSON.parse(response);
+    }
+
+    let orderBy;
+    if (orderByInputMethod === 'fields') {
+        const orderByCollection = this.getNodeParameter(
+            'orderByProperties',
+            i
+        ) as OrderByCollection;
+        orderBy = _getOrderBy(orderByCollection);
+    } else if (orderByInputMethod === 'json') {
+        orderBy = this.getNodeParameter('orderByJson', i) as string;
+        orderBy = JSON.parse(orderBy);
+    }
+
+    return await _fetchLimeObjectsInBatches.call(
+        this,
+        limetype,
+        response,
+        filter,
+        limit,
+        orderBy
+    );
+}