@limetech/n8n-nodes-lime 0.4.0 → 2.3.1-dev.1

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

@@ -0,0 +1,117 @@
+import {
+    INodeExecutionData,
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+import * as operations from './operations';
+
+import { DATA_RESOURCE } from '../../models';
+import { N8NOperationModuleHandler } from '../../../modules';
+
+/**
+ * List of modules consisting data operations
+ */
+const moduleHandler = new N8NOperationModuleHandler([
+    operations.createSingleObject,
+    operations.getSingleObject,
+    operations.updateSingleObject,
+    operations.deleteSingleObject,
+    operations.getManyObjects,
+    operations.getSingleFile,
+]);
+
+/**
+ * Fields and operations for the **Data** resource in Lime CRM.
+ *
+ * @remarks
+ * - These fields are displayed in the n8n node UI when the resource is set to `Data`.
+ * - Each operation corresponds to a CRUD action or a file retrieval for Lime objects.
+ *
+ * @group Resources
+ * @public
+ *
+ * @see {@link createSingleObject} - Operation to create a single Limeobject
+ * @see {@link getSingleObject} - Operation to retrieve a single Limeobject by ID
+ * @see {@link updateSingleObject} - Operation to update a single Limeobject by ID
+ * @see {@link deleteSingleObject} - Operation to delete a single Limeobject by ID
+ * @see {@link getManyObjects} - Operation to fetch multiple Limeobjects based on search criteria
+ * @see {@link getSingleFile} - Operation to retrieve a single from Lime CRM
+ */
+export const dataFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+            },
+        },
+        options: moduleHandler.getDescriptions(),
+        default: 'fetchMany',
+    },
+
+    ...moduleHandler.getProperties(),
+];
+
+/**
+ * Execute a specific **Data** operation on Lime CRM objects.
+ *
+ * @param args - Contextual parameters for the operation being executed
+ * @param args.operation - The operation to perform (e.g., `createSingleObject`, `getManyObjects`)
+ * @param args.i - The index of the input item to process
+ *
+ * @returns A promise resolving to the n8n object containing the result of the operation.
+ *
+ * @throws NodeOperationError if the operation is unsupported or fails.
+ *
+ * @public
+ * @group Resources
+ */
+export async function dataOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+): Promise<INodeExecutionData | INodeExecutionData[]> {
+    switch (operation) {
+        case 'createSingleObject': {
+            return {
+                json: await operations.createSingleObject.execute.call(this, i),
+            };
+        }
+        case 'getSingleObject': {
+            return await operations.getSingleObject.execute.call(this, i);
+        }
+        case 'updateSingleObject': {
+            return {
+                json: await operations.updateSingleObject.execute.call(this, i),
+            };
+        }
+        case 'deleteSingleObject': {
+            await operations.deleteSingleObject.execute.call(this, i);
+            return { json: {} };
+        }
+        case 'getManyObjects': {
+            const result = await operations.getManyObjects.execute.call(
+                this,
+                i
+            );
+            return result.map((item) => ({
+                json: item,
+            }));
+        }
+        case 'getSingleFile': {
+            return await operations.getSingleFile.execute.call(this, i);
+        }
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The operation "${operation}" is not supported!`
+    );
+}
+
+export * from './operations';

package/nodes/lime-crm/resources/data/operations/createSingleObject.operation.ts

@@ -0,0 +1,231 @@
+import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { createLimeobject, getProperties } from '../../../transport';
+import { DATA_RESOURCE, LimetypeProperty } from '../../../models';
+import {
+    adaptProperty,
+    getFilePropertiesNames,
+    getPropertyType,
+    processFileResponse,
+    setFileProperties,
+} from '../../../utils';
+
+/**
+ * Description and metadata for the "Create Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
+export const description = {
+    name: 'Create Single Object',
+    value: 'createSingleObject',
+    description: 'Create a single new object',
+    action: 'Create single object',
+};
+
+/**
+ * Node properties for the "Create Single Object" operation.
+ *
+ * @param {string} limetype - The type of entity to create
+ * @param {'fields' | 'json'} inputMethod - How the user provides object data: 'fields' for form inputs, 'json' for raw JSON
+ * @param {Array<{ name: string; value: string }>} properties - Used if inputMethod is 'fields'. List of property name/value pairs to set on the object
+ * @param {string} objectJson - Used if inputMethod is 'json'. The full object data in JSON format
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to create',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
+            },
+        },
+    },
+    {
+        displayName: 'Input Method',
+        name: 'inputMethod',
+        type: 'options',
+        options: [
+            {
+                name: 'Form Fields',
+                value: 'fields',
+            },
+            {
+                name: 'JSON',
+                value: 'json',
+            },
+        ],
+        default: 'fields',
+        description: 'How to input the object data',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
+            },
+        },
+    },
+    {
+        displayName: 'Properties',
+        name: 'properties',
+        type: 'fixedCollection',
+        placeholder: 'Add Property',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
+                inputMethod: ['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: 'Property Value',
+                        name: 'value',
+                        type: 'string',
+                        default: '',
+                        description: 'Value of the property',
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Object (JSON)',
+        name: 'objectJson',
+        type: 'json',
+        default: '{\n  "name": "New Company",\n  "phone": "123-456-7890"\n}',
+        description: 'Object to create in JSON format',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
+                inputMethod: ['json'],
+            },
+        },
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+        },
+    },
+];
+
+/**
+ *
+ * @param context - Node execution context
+ * @param i - The index of the current item in the workflow execution
+ * @param properties - List of {@link LimeTypeProperty} fetched from Lime CRM
+ * @returns IDataObject - parsed data from Simple Fields mode
+ */
+function parseSimpleFieldsData(
+    context: IExecuteFunctions,
+    i: number,
+    properties: LimetypeProperty[]
+): IDataObject {
+    const objectData: IDataObject = {};
+    const propertiesInput = context.getNodeParameter(
+        'properties.property',
+        i,
+        []
+    ) as IDataObject[];
+
+    if (propertiesInput && propertiesInput.length > 0) {
+        for (const prop of propertiesInput) {
+            if (prop.name && prop.value !== undefined) {
+                const propertyName = prop.name as string;
+                objectData[propertyName] = adaptProperty(
+                    prop.value as string,
+                    getPropertyType(propertyName, properties)
+                );
+            }
+        }
+    }
+    return objectData;
+}
+
+/**
+ * Execute the "Create Single Object" operation for Lime CRM.
+ *
+ * @param i - The index of the current item in the workflow execution
+ * @remarks
+ * This method handles creating a single Lime CRM object. It supports two input methods:
+ * - `fields`: where the user provides property values via form fields.
+ * - `json`: where the user provides a full JSON object representing the entity.
+ *
+ * The method performs the following steps:
+ * 1. Reads the limetype and input method from node parameters.
+ * 2. Parses input data according to the selected input method.
+ * 3. Resolves any file properties present in the object and sets the file properties on the object.
+ * 4. Sends a request to the Lime API to create the object.
+ * 5. Processes any returned file data and formats the response.
+ *
+ * @returns The newly created Lime object.
+ *
+ * @public
+ */
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limetype = this.getNodeParameter('limetype', i) as string;
+    const inputMethod = this.getNodeParameter('inputMethod', i) as string;
+
+    let objectData: IDataObject;
+
+    const properties = await getProperties(this, limetype);
+
+    if (inputMethod === 'json') {
+        const jsonInput = this.getNodeParameter('objectJson', i) as string;
+        objectData = JSON.parse(jsonInput);
+    } else {
+        objectData = parseSimpleFieldsData(this, i, properties);
+    }
+
+    const fileProperties = getFilePropertiesNames(
+        properties,
+        new Set(Object.keys(objectData))
+    );
+
+    const setFilePropertiesResponse = await setFileProperties(
+        this,
+        i,
+        fileProperties,
+        objectData
+    );
+
+    const createLimeobjectResponse = await createLimeobject(
+        this,
+        limetype,
+        setFilePropertiesResponse
+    );
+
+    const response = await processFileResponse(
+        this,
+        fileProperties,
+        createLimeobjectResponse
+    );
+    return response.json;
+}

package/nodes/lime-crm/resources/data/operations/deleteSingleObject.operation.ts

@@ -0,0 +1,83 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { deleteLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../models';
+
+/**
+ * Description and metadata for the "Delete Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
+export const description = {
+    name: 'Delete Single Object',
+    value: 'deleteSingleObject',
+    description: 'Delete one specific object',
+    action: 'Delete single object',
+};
+
+/**
+ * Node properties for the "Delete Single Object" operation.
+ *
+ *
+ * @param {string} limetype - The type of entity to delete. Loaded from available Limetypes
+ * @param {string} objectId - The ID of the object to delete
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to delete',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['deleteSingleObject'],
+            },
+        },
+    },
+    {
+        displayName: 'Object ID',
+        name: 'objectId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the object to delete',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['deleteSingleObject'],
+            },
+        },
+    },
+];
+
+/**
+ * Execute the "Delete Single Object" operation for Lime CRM.
+ *
+ * @remarks
+ * This operation deletes a single Lime CRM object identified by its object ID.
+ * The object type is determined by the selected limetype.
+ *
+ * The method performs the following steps:
+ * 1. Retrieves the `limetype` and `objectId` from {@link properties}.
+ * 2. Calls the {@link deleteLimeobject} function to delete the object from Lime CRM.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The response from the Lime API after attempting deletion.
+ *
+ * @public
+ */
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limetype = this.getNodeParameter('limetype', i) as string;
+    const objectId = this.getNodeParameter('objectId', i) as string;
+
+    return await deleteLimeobject(this, limetype, objectId);
+}