@limetech/n8n-nodes-lime 0.1.0

package/nodes/lime-crm/resources/queryApi/operations/executeQuery.operation.ts

@@ -0,0 +1,605 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    IDataObject,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+export const description = {
+    name: 'Execute Query',
+    value: 'executeQuery',
+    description: 'Execute a custom query against the Lime CRM database',
+    action: 'Execute a custom query',
+};
+
+export const properties: INodeProperties[] = [
+    // Limetype selection (dropdown)
+    {
+        displayName: 'LimeType',
+        name: 'limeType',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypes',
+        },
+        required: true,
+        default: '',
+        description: 'The entity type in Lime CRM to query',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+            },
+        },
+    },
+
+    // Query Mode toggle
+    {
+        displayName: 'Query Mode',
+        name: 'queryMode',
+        type: 'options',
+        options: [
+            {
+                name: 'Guided (UI Builder)',
+                value: 'guided',
+                description: 'Build your query using the user interface',
+            },
+            {
+                name: 'Code (JSON)',
+                value: 'code',
+                description: 'Write your query as a JSON object',
+            },
+        ],
+        default: 'guided',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+            },
+        },
+    },
+
+    // Original JSON query field (for code mode)
+    {
+        displayName: 'Query',
+        name: 'query',
+        type: 'json',
+        default: '{\n  "limetype": "company",\n  "properties": ["name", "phone"],\n  "filter": {\n    "relation": {\n      "equals": "customer"\n    }\n  },\n  "take": 10\n}',
+        required: true,
+        description: 'The query to execute. Must be valid JSON format. See <a href="https://docs.lime-crm.com/query-api/" target="_blank">Query API documentation</a>.',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'code',
+                ],
+            },
+        },
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+        },
+    },
+
+    // Properties selection (UI for adding properties) - simplified without aliases
+    {
+        displayName: 'Properties',
+        name: 'properties',
+        type: 'multiOptions',
+        typeOptions: {
+            loadOptionsMethod: 'getLimeTypeProperties',
+            loadOptionsDependsOn: ['limeType'],
+        },
+        default: [],
+        description: 'Properties to retrieve from the selected Lime type',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+            },
+        },
+    },
+
+    // Relation properties (for accessing related objects)
+    {
+        displayName: 'Include Relations',
+        name: 'includeRelations',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to include properties from related objects',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+            },
+        },
+    },
+    {
+        displayName: 'Relations Configuration',
+        name: 'relationsConfig',
+        placeholder: 'Add Relation',
+        type: 'fixedCollection',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        description: 'Configure properties from related objects',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+                includeRelations: [
+                    true,
+                ],
+            },
+        },
+        options: [
+            {
+                name: 'relation',
+                displayName: 'Relation',
+                values: [
+                    {
+                        displayName: 'Relation Name',
+                        name: 'relationName',
+                        type: 'options',
+                        typeOptions: {
+                            loadOptionsMethod: 'getLimeTypeRelations',
+                            loadOptionsDependsOn: ['limetype'],
+                        },
+                        default: '',
+                        description: 'The name of the relation',
+                    },
+                    {
+                        displayName: 'Properties',
+                        name: 'properties',
+                        type: 'multiOptions',
+                        typeOptions: {
+                            loadOptionsMethod: 'getRelatedTypeProperties',
+                            loadOptionsDependsOn: ['limetype', 'relationsConfig.relation[].relationName'],
+                        },
+                        default: [],
+                        description: 'Properties from the related entity',
+                    },
+                ],
+            },
+        ],
+    },
+
+    // Filter (using code editor for flexibility)
+    {
+        displayName: 'Add Filter',
+        name: 'addFilter',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to add a filter to the query',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+            },
+        },
+    },
+    {
+        displayName: 'Filter',
+        name: 'filter',
+        type: 'json',
+        default: '{\n  "key": "name",\n  "op": "contains",\n  "exp": "Lime"\n}',
+        description: 'Filter to apply to the query (JSON format)',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+                addFilter: [
+                    true,
+                ],
+            },
+        },
+        typeOptions: {
+            alwaysOpenEditWindow: true,
+        },
+    },
+
+    // Pagination
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        description: 'Maximum number of records to return',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+                returnAll: [
+                    false,
+                ],
+            },
+        },
+    },
+    {
+        displayName: 'Offset',
+        name: 'offset',
+        type: 'number',
+        default: 0,
+        description: 'Number of records to skip',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+            },
+        },
+    },
+
+    // Sorting - simplified without nested structures
+    {
+        displayName: 'Add Sorting',
+        name: 'addSorting',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to add sorting to the query',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+            },
+        },
+    },
+    {
+        displayName: 'Sort Field',
+        name: 'sortField',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getAllSortableFields',
+            loadOptionsDependsOn: ['limetype', 'includeRelations', 'relationsConfig.relation'],
+        },
+        default: '',
+        description: 'Field to sort by',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+                addSorting: [
+                    true,
+                ],
+            },
+        },
+    },
+    {
+        displayName: 'Sort Direction',
+        name: 'sortDirection',
+        type: 'options',
+        options: [
+            {
+                name: 'Ascending (A-Z)',
+                value: 'ASC',
+            },
+            {
+                name: 'Descending (Z-A)',
+                value: 'DESC',
+            },
+        ],
+        default: 'ASC',
+        description: 'Sort direction',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+                queryMode: [
+                    'guided',
+                ],
+                addSorting: [
+                    true,
+                ],
+            },
+        },
+    },
+
+    // Return all or limit results
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+            },
+        },
+        default: false,
+        description: 'Whether to return all results or respect the limit parameter',
+    },
+
+    // Options for the query
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [
+                    'queryApi',
+                ],
+                operation: [
+                    'executeQuery',
+                ],
+            },
+        },
+        options: [
+            {
+                displayName: 'Include Metadata',
+                name: 'includeMetadata',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include metadata about the query result (total count, pagination info, etc.)',
+            },
+            {
+                displayName: 'Timeout (ms)',
+                name: 'timeout',
+                type: 'number',
+                default: 30000,
+                description: 'Timeout for the query in milliseconds',
+            },
+        ],
+    },
+];
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number,
+) {
+    // Use the API client from the transport directory
+    const { apiRequest } = await import('../../../transport');
+
+    const queryMode = this.getNodeParameter('queryMode', i) as string;
+    const returnAll = this.getNodeParameter('returnAll', i) as boolean;
+    const options = this.getNodeParameter('options', i, {}) as IDataObject;
+
+    let queryObject: IDataObject;
+
+    if (queryMode === 'code') {
+        // Handle code mode (direct JSON input)
+        const queryJson = this.getNodeParameter('query', i) as string;
+        try {
+            // Parse the JSON query
+            if (typeof queryJson === 'string') {
+                queryObject = JSON.parse(queryJson);
+            } else {
+                queryObject = queryJson as IDataObject;
+            }
+        } catch (error) {
+            throw new NodeOperationError(this.getNode(), 'Invalid JSON in query: ' + error.message);
+        }
+    } else {
+        // Handle guided mode (UI builder)
+        queryObject = {};
+
+        // 1. Add limetype
+        const limetype = this.getNodeParameter('limeType', i) as string;
+        queryObject.limetype = limetype;
+
+        // 2. Add properties - simplified approach without aliases
+        const properties = this.getNodeParameter('properties', i, []) as string[];
+        const responseFormat: IDataObject = { object: {} };
+
+        // Handle direct properties
+        properties.forEach((property) => {
+            (responseFormat.object as IDataObject)[property] = null;
+        });
+
+        // 3. Add relations if enabled
+        const includeRelations = this.getNodeParameter('includeRelations', i, false) as boolean;
+        if (includeRelations) {
+            const relations = this.getNodeParameter('relationsConfig.relation', i, []) as IDataObject[];
+
+            relations.forEach((relationConfig) => {
+                const relationName = relationConfig.relationName as string;
+                const relationProperties = relationConfig.properties as string[] || [];
+
+                if (relationName && relationProperties.length > 0) {
+                    const relationObject: IDataObject = {};
+
+                    relationProperties.forEach((property) => {
+                        relationObject[property] = null;
+                    });
+
+                    (responseFormat.object as IDataObject)[relationName] = relationObject;
+                }
+            });
+        }
+
+        queryObject.responseFormat = responseFormat;
+
+        // 4. Add filter if enabled
+        const addFilter = this.getNodeParameter('addFilter', i, false) as boolean;
+        if (addFilter) {
+            try {
+                const filterJson = this.getNodeParameter('filter', i) as string;
+                queryObject.filter = typeof filterJson === 'string' ? JSON.parse(filterJson) : filterJson;
+            } catch (error) {
+                throw new NodeOperationError(this.getNode(), 'Invalid JSON in filter: ' + error.message);
+            }
+        }
+
+        // 5. Add pagination
+        if (!returnAll) {
+            queryObject.limit = this.getNodeParameter('limit', i, 50) as number;
+        }
+        queryObject.offset = this.getNodeParameter('offset', i, 0) as number;
+
+        // 6. Add sorting if enabled - simplified approach
+        const addSorting = this.getNodeParameter('addSorting', i, false) as boolean;
+        if (addSorting) {
+            const sortField = this.getNodeParameter('sortField', i, '') as string;
+            const sortDirection = this.getNodeParameter('sortDirection', i, 'ASC') as string;
+
+            if (sortField) {
+                const orderBy: IDataObject[] = [];
+                const orderItem: IDataObject = {};
+                orderItem[sortField] = sortDirection;
+                orderBy.push(orderItem);
+                queryObject.orderBy = orderBy;
+            }
+        }
+    }
+
+    // If returnAll is true, set a high value to override any take/limit parameter
+    if (returnAll) {
+        queryObject.limit = 10000; // Use a very high value as a practical limit
+    }
+
+    // Add metadata option if requested
+    if (options.includeMetadata) {
+        queryObject.includemetadata = true;
+    }
+
+    const endpoint = '/api/v1/query/';
+
+    try {
+        // Set request options
+        const requestOptions: IDataObject = {
+            method: 'GET',
+            endpoint,
+            qs: { q: JSON.stringify(queryObject) },
+        };
+
+        if (options.timeout) {
+            requestOptions.timeout = options.timeout as number;
+        }
+
+        // If we need to handle pagination, do so
+        if (returnAll && queryObject.limit) {
+            const results: IDataObject[] = [];
+            let hasMoreData = true;
+            let currentOffset = queryObject.offset as number || 0;
+
+            while (hasMoreData) {
+                // Update offset for pagination
+                queryObject.offset = currentOffset;
+                requestOptions.qs = { q: JSON.stringify(queryObject) };
+
+                const response = await apiRequest.call(this, requestOptions);
+
+                // If data is received, add it to results
+                if (response && response.data && Array.isArray(response.data)) {
+                    results.push(...response.data);
+
+                    // If we received fewer records than limit, we've reached the end
+                    if (response.data.length < (queryObject.limit as number)) {
+                        hasMoreData = false;
+                    } else {
+                        // Otherwise, prepare for the next page
+                        currentOffset += response.data.length;
+                    }
+                } else {
+                    hasMoreData = false;
+                }
+            }
+
+            // Prepare final response with all data
+            const finalResponse: IDataObject = { data: results };
+
+            // Include metadata if available and requested
+            if (options.includeMetadata) {
+                finalResponse.metadata = {
+                    totalCount: results.length,
+                    // Add other metadata if available
+                };
+            }
+
+            return finalResponse.objects;
+        } else {
+            // Single request without pagination handling
+            const response = await apiRequest.call(this, requestOptions);
+            return response.objects;
+        }
+    } catch (error) {
+        throw new NodeOperationError(this.getNode(), `Query execution failed: ${error.message}`);
+    }
+}

package/nodes/lime-crm/transport/index.ts

@@ -0,0 +1,74 @@
+import { IExecuteFunctions, ILoadOptionsFunctions, IDataObject, NodeOperationError } from 'n8n-workflow';
+
+/**
+ * Make an API request to the Lime CRM API
+ */
+export async function apiRequest(
+    this: IExecuteFunctions | ILoadOptionsFunctions,
+    options: IDataObject,
+): Promise<any> {
+    // Get credentials for the API
+    const credentials = await this.getCredentials('limeCrmApi');
+
+    if (!credentials) {
+        throw new NodeOperationError(this.getNode(), 'No credentials provided');
+    }
+
+    const baseURL = credentials.url as string;
+    const apiKey = credentials.apiKey as string;
+
+    // Add common headers for all requests
+    const headers = {
+        'X-API-Key': apiKey,
+        'Accept': 'application/json',
+        'Content-Type': 'application/json',
+    };
+
+    const endpoint = options.endpoint as string;
+    const method = options.method as string || 'GET';
+
+    try {
+        const requestOptions: IDataObject = {
+            method,
+            uri: `${baseURL}${endpoint}`,
+            json: true,
+            headers,
+        };
+
+        // Add query string parameters if they exist
+        if (options.qs) {
+            requestOptions.qs = options.qs;
+        }
+
+        // Add request body if it exists and method is not GET
+        if (options.body && method !== 'GET') {
+            requestOptions.body = options.body;
+        }
+
+        // Add timeout if specified
+        if (options.timeout) {
+            requestOptions.timeout = options.timeout as number;
+        }
+
+        // Execute the request using n8n's helper
+        return await this.helpers.request(requestOptions);
+    } catch (error) {
+        // Add some context to the error message
+        if (error.response) {
+            // If we have a response with error info
+            const statusCode = error.response.statusCode;
+            const errorMessage = error.response.body?.message || error.message;
+
+            throw new NodeOperationError(
+                this.getNode(),
+                `API request failed [${statusCode}]: ${errorMessage}`
+            );
+        } else {
+            // Generic network error
+            throw new NodeOperationError(
+                this.getNode(),
+                `API request failed: ${error.message}`
+            );
+        }
+    }
+}