@limetech/n8n-nodes-lime 0.2.8 → 0.3.0

package/nodes/lime-crm/resources/limeObject/operations/create.operation.ts

@@ -0,0 +1,152 @@
+import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { createLimeObject } from '../../../transport';
+import { LIMEOBJECT_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Create Object',
+    value: 'create',
+    description: 'Create a new object',
+    action: 'Create an object',
+};
+
+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: [LIMEOBJECT_RESOURCE],
+                operation: ['create'],
+            },
+        },
+    },
+
+    // Object data input method
+    {
+        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: [LIMEOBJECT_RESOURCE],
+                operation: ['create'],
+            },
+        },
+    },
+
+    // Dynamic properties for form input
+    {
+        displayName: 'Properties',
+        name: 'properties',
+        type: 'fixedCollection',
+        placeholder: 'Add Property',
+        typeOptions: {
+            multipleValues: true,
+            sortable: true,
+            loadOptionsMethod: 'getLimeTypeProperties',
+            loadOptionsDependsOn: ['limeType'],
+        },
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['create'],
+                inputMethod: ['fields'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Property',
+                name: 'property',
+                values: [
+                    {
+                        displayName: 'Property Name',
+                        name: 'name',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getLimeTypeProperties',
+                            loadOptionsDependsOn: ['limeType'],
+                        },
+                        default: '',
+                        description: 'Name of the property',
+                    },
+                    {
+                        displayName: 'Property Value',
+                        name: 'value',
+                        type: 'string',
+                        default: '',
+                        description: 'Value of the property',
+                    },
+                ],
+            },
+        ],
+    },
+
+    // JSON input
+    {
+        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: [LIMEOBJECT_RESOURCE],
+                operation: ['create'],
+                inputMethod: ['json'],
+            },
+        },
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+        },
+    },
+];
+
+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;
+
+    if (inputMethod === 'json') {
+        const jsonInput = this.getNodeParameter('objectJson', i) as string;
+        objectData = JSON.parse(jsonInput);
+    } else {
+        objectData = {};
+        const propertiesInput = this.getNodeParameter(
+            'properties.property',
+            i,
+            []
+        ) as IDataObject[];
+
+        if (propertiesInput && propertiesInput.length > 0) {
+            for (const prop of propertiesInput) {
+                if (prop.name && prop.value !== undefined) {
+                    objectData[prop.name as string] = prop.value;
+                }
+            }
+        }
+    }
+
+    return await createLimeObject(this, limeType, objectData);
+}

package/nodes/lime-crm/resources/limeObject/operations/delete.operation.ts

@@ -0,0 +1,55 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { deleteLimeObject } from '../../../transport';
+import { LIMEOBJECT_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Delete Object',
+    value: 'delete',
+    description: 'Delete an existing object',
+    action: 'Delete an object',
+};
+
+export const properties: INodeProperties[] = [
+    // Limetype selection
+    {
+        displayName: 'Lime Type',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to delete',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['delete'],
+            },
+        },
+    },
+
+    // Object ID
+    {
+        displayName: 'Object ID',
+        name: 'objectId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the object to delete',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['delete'],
+            },
+        },
+    },
+];
+
+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);
+}

package/nodes/lime-crm/resources/limeObject/operations/get.operation.ts

@@ -0,0 +1,54 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { getLimeObject } from '../../../transport';
+import { LIMEOBJECT_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Object',
+    value: 'get',
+    description: 'Get a single object by ID',
+    action: 'Get an object',
+};
+
+export const properties: INodeProperties[] = [
+    // Limetype selection
+    {
+        displayName: 'Lime Type',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to retrieve',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['get'],
+            },
+        },
+    },
+
+    // Object ID
+    {
+        displayName: 'Object ID',
+        name: 'objectId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the object to retrieve',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['get'],
+            },
+        },
+    },
+];
+
+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 getLimeObject(this, limeType, objectId);
+}

package/nodes/lime-crm/resources/limeObject/operations/search.operation.ts

@@ -0,0 +1,99 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { searchLimeObject } from '../../../transport';
+import { LIMEOBJECT_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Search',
+    value: 'search',
+    description: 'Search for objects',
+    action: 'Search for objects',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Lime Type',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to search for',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['search'],
+            },
+        },
+    },
+
+    // Search parameters
+    {
+        displayName: 'Search Term',
+        name: 'searchTerm',
+        type: 'string',
+        default: '',
+        description: 'Term to search for',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['search'],
+            },
+        },
+    },
+
+    // Search fields
+    {
+        displayName: 'Search Fields',
+        name: 'searchField',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypeProperties',
+            loadOptionsDependsOn: ['limeType'],
+        },
+        default: [],
+        description:
+            'Fields to search in. If none selected, searches across all searchable fields',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['search'],
+            },
+        },
+    },
+
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        description: 'Max number of results to return',
+        typeOptions: {
+            minValue: 1,
+        },
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['search'],
+            },
+        },
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limeType = this.getNodeParameter('limeType', i) as string;
+    const searchTerm = this.getNodeParameter('searchTerm', i, '') as string;
+    const searchField = this.getNodeParameter('searchField', i) as string;
+    const limit = this.getNodeParameter('limit', i, 50);
+    const options = this.getNodeParameter('options', i, {});
+
+    return await searchLimeObject(
+        this,
+        limeType,
+        searchField,
+        searchTerm,
+        limit || null,
+        (options.sortField as string) || null
+    );
+}

package/nodes/lime-crm/resources/limeObject/operations/update.operation.ts

@@ -0,0 +1,157 @@
+import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { updateLimeObject } from '../../../transport';
+import { LIMEOBJECT_RESOURCE } from '../../../commons';
+
+// Input fields for update operation
+export const description = {
+    name: 'Update',
+    value: 'update',
+    description: 'Update an existing record',
+    action: 'Update a record',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'LimeType',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to update',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['update'],
+            },
+        },
+    },
+    {
+        displayName: 'Record ID',
+        name: 'id',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'ID of the record to update',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['update'],
+            },
+        },
+    },
+    {
+        displayName: 'Input Type',
+        name: 'inputType',
+        type: 'options',
+        options: [
+            {
+                name: 'Simple Fields',
+                value: 'simple',
+                description: 'Define fields using the UI',
+            },
+            {
+                name: 'JSON Object',
+                value: 'json',
+                description: 'Define fields using JSON',
+            },
+        ],
+        default: 'simple',
+        description: 'How to input the data',
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['update'],
+            },
+        },
+    },
+    {
+        displayName: 'Data',
+        name: 'jsonData',
+        type: 'json',
+        default:
+            '{\n  "name": "Updated Company Name",\n  "phone": "+987654321"\n}',
+        description:
+            'Key-value pairs for fields to update. Property names must match the Lime CRM field names.',
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+        },
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['update'],
+                inputType: ['json'],
+            },
+        },
+    },
+    {
+        displayName: 'Fields',
+        name: 'simpleFields',
+        placeholder: 'Add Field',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+            sortable: true,
+        },
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['update'],
+                inputType: ['simple'],
+            },
+        },
+        options: [
+            {
+                name: 'field',
+                displayName: 'Field',
+                values: [
+                    {
+                        displayName: 'Field Name',
+                        name: 'fieldName',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getLimeTypeProperties',
+                            loadOptionsDependsOn: ['limeType'],
+                        },
+                        default: '',
+                        description: 'The name of the field',
+                    },
+                    {
+                        displayName: 'Field Value',
+                        name: 'fieldValue',
+                        type: 'string',
+                        default: '',
+                        description: 'The value of the field',
+                    },
+                ],
+            },
+        ],
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limeType = this.getNodeParameter('limeType', i) as string;
+    const id = this.getNodeParameter('id', i) as string;
+    const inputType = this.getNodeParameter('inputType', i) as string;
+
+    let body: IDataObject = {};
+
+    if (inputType === 'json') {
+        const jsonData = this.getNodeParameter('jsonData', i) as string;
+        body = JSON.parse(jsonData);
+    } else {
+        const simpleFields = this.getNodeParameter(
+            'simpleFields.field',
+            i,
+            []
+        ) as IDataObject[];
+        for (const field of simpleFields) {
+            body[field.fieldName as string] = field.fieldValue;
+        }
+    }
+
+    return updateLimeObject(this, limeType, id, body);
+}

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

@@ -0,0 +1,58 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+} from 'n8n-workflow';
+
+import * as getType from './operations/getType.operation';
+import * as listTypes from './operations/listTypes.operation';
+import * as getProperties from './operations/getProperties.operation';
+import { LIMETYPE_RESOURCE } from '../../commons';
+
+export const limeTypeFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [LIMETYPE_RESOURCE],
+            },
+        },
+        options: [
+            {
+                ...listTypes.description,
+            },
+            {
+                ...getType.description,
+            },
+            {
+                ...getProperties.description,
+            },
+        ],
+        default: 'listTypes',
+    },
+
+    // Operation-specific fields
+    ...getType.properties,
+    ...getProperties.properties,
+];
+
+// Operations router
+export async function limeTypeOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+) {
+    if (operation === 'listTypes') {
+        return await listTypes.execute.call(this);
+    }
+    if (operation === 'getType') {
+        return await getType.execute.call(this, i);
+    }
+    if (operation === 'getProperties') {
+        return await getProperties.execute.call(this, i);
+    }
+
+    return null;
+}

package/nodes/lime-crm/resources/limeType/operations/getProperties.operation.ts

@@ -0,0 +1,42 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { getProperties } from '../../../transport';
+import { LIMETYPE_RESOURCE, LimeTypeProperty } from '../../../commons';
+import { NodeResponse } from '../../../../nodeResponse';
+
+export const description = {
+    name: 'Get Properties',
+    value: 'getProperties',
+    description: 'Get all properties for a specific entity type',
+    action: 'Get entity type properties',
+};
+
+export const properties: INodeProperties[] = [
+    // Limetype selection
+    {
+        displayName: 'Type Name',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The name of the entity type to get properties for',
+        displayOptions: {
+            show: {
+                resource: [LIMETYPE_RESOURCE],
+                operation: ['getProperties'],
+            },
+        },
+    },
+];
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<NodeResponse<LimeTypeProperty[]>> {
+    const limeType = this.getNodeParameter('limeType', i) as string;
+
+    return getProperties(this, limeType);
+}

package/nodes/lime-crm/resources/limeType/operations/getType.operation.ts

@@ -0,0 +1,36 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { getLimeType } from '../../../transport/limetypes';
+import { LIMETYPE_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Type',
+    value: 'getType',
+    description: 'Get details about a specific entity type',
+    action: 'Get entity type details',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Type Name',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The name of the entity type to get details for',
+        displayOptions: {
+            show: {
+                resource: [LIMETYPE_RESOURCE],
+                operation: ['getType'],
+            },
+        },
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limeType = this.getNodeParameter('limeType', i) as string;
+
+    return getLimeType(this, limeType);
+}

package/nodes/lime-crm/resources/limeType/operations/listTypes.operation.ts

@@ -0,0 +1,18 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+
+import { getLimeTypesFromApi } from '../../../transport';
+import { LimeType } from '../../../commons';
+import { NodeResponse } from '../../../../nodeResponse';
+
+export const description = {
+    name: 'List Types',
+    value: 'listTypes',
+    description: 'Get a list of all available entity types',
+    action: 'List all entity types',
+};
+
+export async function execute(
+    this: IExecuteFunctions
+): Promise<NodeResponse<LimeType[]>> {
+    return await getLimeTypesFromApi(this);
+}