@limetech/n8n-nodes-lime 0.2.0 → 0.2.1

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

@@ -1,242 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    IDataObject,
-    NodeOperationError,
-} from 'n8n-workflow';
-
-export const description = {
-    name: 'Search',
-    value: 'search',
-    description: 'Search for objects',
-    action: 'Search for objects',
-};
-
-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 search for',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'search',
-                ],
-            },
-        },
-    },
-
-    // Search parameters
-    {
-        displayName: 'Search Term',
-        name: 'searchTerm',
-        type: 'string',
-        default: '',
-        description: 'Term to search for',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'search',
-                ],
-            },
-        },
-    },
-
-    // Search fields
-    {
-        displayName: 'Search Fields',
-        name: 'searchFields',
-        type: 'multiOptions',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypeProperties',
-            loadOptionsDependsOn: ['limeType'],
-        },
-        default: [],
-        description: 'Fields to search in. If none selected, searches across all searchable fields',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'search',
-                ],
-            },
-        },
-    },
-
-    // Return options
-    {
-        displayName: 'Return All',
-        name: 'returnAll',
-        type: 'boolean',
-        default: false,
-        description: 'Whether to return all results or only up to a limit',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'search',
-                ],
-            },
-        },
-    },
-
-    {
-        displayName: 'Limit',
-        name: 'limit',
-        type: 'number',
-        default: 50,
-        description: 'Max number of results to return',
-        typeOptions: {
-            minValue: 1,
-        },
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'search',
-                ],
-                returnAll: [
-                    false,
-                ],
-            },
-        },
-    },
-
-    // Advanced options
-    {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'search',
-                ],
-            },
-        },
-        options: [
-            {
-                displayName: 'Include Related Objects',
-                name: 'includeRelated',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to include related objects in the response',
-            },
-            {
-                displayName: 'Sort Field',
-                name: 'sortField',
-                type: 'options',
-                typeOptions: {
-                    loadOptionsMethod: 'getLimeTypeProperties',
-                    loadOptionsDependsOn: ['limeType'],
-                },
-                default: '',
-                description: 'Field to sort results by',
-            },
-            {
-                displayName: 'Sort Direction',
-                name: 'sortDirection',
-                type: 'options',
-                options: [
-                    {
-                        name: 'Ascending',
-                        value: 'asc',
-                    },
-                    {
-                        name: 'Descending',
-                        value: 'desc',
-                    },
-                ],
-                default: 'asc',
-                description: 'Direction to sort results',
-            },
-        ],
-    },
-];
-
-export async function execute(
-    this: IExecuteFunctions,
-    i: number,
-) {
-    const { apiRequest } = await import('../../../transport');
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const searchTerm = this.getNodeParameter('searchTerm', i, '') as string;
-    const searchFields = this.getNodeParameter('searchFields', i, []) as string[];
-    const returnAll = this.getNodeParameter('returnAll', i) as boolean;
-    const limit = returnAll ? 0 : this.getNodeParameter('limit', i, 50) as number;
-    const options = this.getNodeParameter('options', i, {}) as IDataObject;
-
-    if (!limeType) {
-        throw new NodeOperationError(this.getNode(), 'Lime type must be provided');
-    }
-
-    // Build search endpoint and parameters
-    const endpoint = `/api/v1/limeobject/${encodeURIComponent(limeType)}/search/`;
-    const queryParams: IDataObject = {};
-
-    // Add search parameters
-    if (searchTerm) {
-        queryParams.q = searchTerm;
-    }
-
-    // Add fields to search in if specified
-    if (searchFields && searchFields.length > 0) {
-        queryParams.fields = searchFields.join(',');
-    }
-
-    // Add limit parameter
-    if (!returnAll && limit > 0) {
-        queryParams._limit = limit;
-    }
-
-    // Add sorting if specified in options
-    if (options.sortField) {
-        const sortDirection = options.sortDirection || 'asc';
-        queryParams._sort = `${options.sortField}:${sortDirection}`;
-    }
-
-    // Include related objects if requested
-    if (options.includeRelated === true) {
-        queryParams._embed = 'all';
-    }
-
-    try {
-        const response = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint,
-            qs: queryParams,
-        });
-
-        // Return search results
-        return response._embedded?.limeobjects || [];
-    } catch (error) {
-        throw new NodeOperationError(
-            this.getNode(),
-            `Failed to search for ${limeType} objects: ${error.message}`
-        );
-    }
-}

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

@@ -1,201 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    IDataObject,
-    NodeOperationError,
-} from 'n8n-workflow';
-import { apiRequest } from '../../../transport';
-
-// 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',
-                ],
-                operation: [
-                    'update',
-                ],
-            },
-        },
-    },
-    {
-        displayName: 'Record ID',
-        name: 'id',
-        type: 'string',
-        required: true,
-        default: '',
-        description: 'ID of the record to update',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                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',
-                ],
-                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',
-                ],
-                operation: [
-                    'update',
-                ],
-                inputType: [
-                    'json',
-                ],
-            },
-        },
-    },
-    {
-        displayName: 'Fields',
-        name: 'simpleFields',
-        placeholder: 'Add Field',
-        type: 'fixedCollection',
-        typeOptions: {
-            multipleValues: true,
-            sortable: true,
-        },
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                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',
-                    },
-                ],
-            },
-        ],
-    },
-];
-
-// Execute function for update operation
-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;
-    const options = this.getNodeParameter('options', i, {}) as IDataObject;
-    const rawResponse = options.rawResponse as boolean || false;
-
-    // Build the request body based on the input type
-    let body: IDataObject = {};
-
-    if (inputType === 'json') {
-        // JSON input mode
-        const jsonData = this.getNodeParameter('jsonData', i) as string;
-        try {
-            body = typeof jsonData === 'string' ? JSON.parse(jsonData) : jsonData as IDataObject;
-        } catch (error) {
-            throw new NodeOperationError(this.getNode(), 'Invalid JSON: ' + error.message);
-        }
-    } else {
-        // Simple input mode
-        const simpleFields = this.getNodeParameter('simpleFields.field', i, []) as IDataObject[];
-        simpleFields.forEach(field => {
-            body[field.fieldName as string] = field.fieldValue;
-        });
-    }
-
-    const endpoint = `/api/v1/limeobject/${limeType}/${id}/`;
-
-    // Make the API request to update the record
-    const response = await apiRequest.call(
-        this,
-        {
-            method: 'PATCH',
-            url: endpoint,
-            body
-        }
-    );
-
-    return rawResponse ? response : response;
-}

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

@@ -1,66 +0,0 @@
-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 * as getRelations from './operations/getRelations.operation';
-
-// Export fields for the node
-export const limeTypeFields: INodeProperties[] = [
-    // Operation selection for LimeType
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeType',
-                ],
-            },
-        },
-        options: [
-            {
-                ...listTypes.description,
-            },
-            {
-                ...getType.description,
-            },
-            {
-                ...getProperties.description,
-            },
-            {
-                ...getRelations.description,
-            },
-        ],
-        default: 'listTypes',
-    },
-
-    // Operation-specific fields
-    ...listTypes.properties,
-    ...getType.properties,
-    ...getProperties.properties,
-    ...getRelations.properties,
-];
-
-// Operations router
-export async function limeTypeOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number },
-) {
-    if (operation === 'listTypes') {
-        return await listTypes.execute.call(this, i);
-    }
-    if (operation === 'getType') {
-        return await getType.execute.call(this, i);
-    }
-    if (operation === 'getProperties') {
-        return await getProperties.execute.call(this, i);
-    }
-    if (operation === 'getRelations') {
-        return await getRelations.execute.call(this, i);
-    }
-
-    return null;
-}

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

@@ -1,105 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    IDataObject,
-    NodeOperationError,
-} from 'n8n-workflow';
-
-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: 'typeName',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The name of the entity type to get properties for',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeType',
-                ],
-                operation: [
-                    'getProperties',
-                ],
-            },
-        },
-    },
-
-    // Options for the operation
-    {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeType',
-                ],
-                operation: [
-                    'getProperties',
-                ],
-            },
-        },
-        options: [
-            {
-                displayName: 'Include System Properties',
-                name: 'includeSystemProperties',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to include system properties in the response',
-            },
-            {
-                displayName: 'Include Hidden Properties',
-                name: 'includeHiddenProperties',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to include hidden properties in the response',
-            },
-        ],
-    },
-];
-
-export async function execute(
-    this: IExecuteFunctions,
-    i: number,
-) {
-    const { apiRequest } = await import('../../../transport');
-    const typeName = this.getNodeParameter('typeName', i) as string;
-    const options = this.getNodeParameter('options', i, {}) as IDataObject;
-
-    if (!typeName) {
-        throw new NodeOperationError(this.getNode(), 'Type name must be provided');
-    }
-
-    // Prepare query parameters
-    const qs: IDataObject = {};
-    if (options.includeSystemProperties) {
-        qs.includeSystem = true;
-    }
-    if (options.includeHiddenProperties) {
-        qs.includeHidden = true;
-    }
-
-    // Make API request
-    const response = await apiRequest.call(this, {
-        method: 'GET',
-        endpoint: `/api/v1/limetype/${encodeURIComponent(typeName)}/property`,
-        qs,
-    });
-
-    // Return the response data
-    return response;
-}