@limetech/n8n-nodes-lime 0.2.0 → 0.2.1

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

@@ -1,605 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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}`
-            );
-        }
-    }
-}