@limetech/n8n-nodes-lime 0.2.0 → 0.2.2

package/nodes/lime-crm/methods/getLimeTypes.ts

@@ -1,33 +0,0 @@
-import { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
-import { apiRequest } from '../transport';
-
-/**
- * Load available Lime types from the API
- */
-export async function getLimeTypes(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
-    try {
-        const response = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint: '/api/v1/limetype/',
-            qs: {
-                _embed: 'limetypes',
-            },
-        });
-
-        // Check if response contains embedded limetypes
-        if (response && response._embedded && Array.isArray(response._embedded.limetypes)) {
-            return response._embedded.limetypes.map((type: any) => ({
-                name: type.localname?.singular || type.name,
-                value: type.name,
-                description: `LimeType: ${type.name}`,
-            }));
-        }
-
-        return [];
-    } catch (error) {
-        console.error('Error loading Lime types:', error);
-        return [];
-    }
-}
-
-export default getLimeTypes;

package/nodes/lime-crm/methods/getRelatedTypeProperties.ts

@@ -1,47 +0,0 @@
-import { ILoadOptionsFunctions, IDataObject } from 'n8n-workflow';
-import { apiRequest } from '../transport';
-
-/**
- * Load properties for a related Lime type
- */
-export async function getRelatedTypeProperties(this: ILoadOptionsFunctions) {
-    const limeType = this.getNodeParameter('limetype', '') as string;
-    const relationName = this.getNodeParameter('relationsConfig.relation[].relationName', '') as string;
-
-    if (!limeType || !relationName) return [];
-
-    try {
-        // First get the relation to determine the target type
-        const relationsResponse = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint: `/api/v1/limetype/${limeType}/relation/${relationName}`,
-        });
-
-        if (!relationsResponse || !relationsResponse.targettype) {
-            return [];
-        }
-
-        const targetType = relationsResponse.targettype as string;
-
-        // Then get properties for the target type
-        const propertiesResponse = await apiRequest.call(this, {
-            method: 'GET',
-            endpoint: `/api/v1/limetype/${targetType}/`,
-        });
-
-        if (!propertiesResponse || !Array.isArray(propertiesResponse)) {
-            return [];
-        }
-
-        return propertiesResponse.map((property: IDataObject) => ({
-            name: property.name as string,
-            value: property.name as string,
-            description: property.description as string || '',
-        }));
-    } catch (error) {
-        console.error(`Error loading related properties for ${limeType}.${relationName}:`, error);
-        return [];
-    }
-}
-
-export default getRelatedTypeProperties;

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

@@ -1,5 +0,0 @@
-export { getLimeTypes } from './getLimeTypes';
-export { getLimeTypeProperties } from './getLimeTypeProperties';
-export { getLimeTypeRelations } from './getLimeTypeRelations';
-export { getRelatedTypeProperties } from './getRelatedTypeProperties';
-export { getAllSortableFields } from './getAllSortableFields';

package/nodes/lime-crm/resources/limeObject/commonFields.ts

@@ -1,179 +0,0 @@
-import { INodeProperties } from 'n8n-workflow';
-
-/**
- * Common property input fields for Lime CRM objects
- * These can be reused across different operations
- */
-export const propertyInputFields: INodeProperties[] = [
-    // Property fields for simple mode
-    {
-        displayName: 'Properties',
-        name: 'properties',
-        type: 'fixedCollection',
-        placeholder: 'Add Property',
-        typeOptions: {
-            multipleValues: true,
-            sortable: true,
-        },
-        default: {},
-        options: [
-            {
-                name: 'property',
-                displayName: 'Property',
-                values: [
-                    {
-                        displayName: 'Property Name',
-                        name: 'name',
-                        type: 'options',
-                        typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
-                        },
-                        default: '',
-                        description: 'Name of the property to set',
-                    },
-                    {
-                        displayName: 'Property Value',
-                        name: 'value',
-                        type: 'string',
-                        default: '',
-                        description: 'Value of the property',
-                    },
-                ],
-            },
-        ],
-        description: 'Properties to set on the Lime CRM object',
-    },
-
-    // Property fields for mapping mode
-    {
-        displayName: 'Property Mappings',
-        name: 'propertyMappings',
-        placeholder: 'Add Property Mapping',
-        type: 'fixedCollection',
-        typeOptions: {
-            multipleValues: true,
-            sortable: true,
-        },
-        default: {},
-        options: [
-            {
-                name: 'mapping',
-                displayName: 'Property Mapping',
-                values: [
-                    {
-                        displayName: 'Lime CRM Property',
-                        name: 'limeProperty',
-                        type: 'options',
-                        typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
-                        },
-                        default: '',
-                        description: 'The Lime CRM property to map to',
-                    },
-                    {
-                        displayName: 'Source Value',
-                        name: 'sourceValue',
-                        type: 'string',
-                        default: '',
-                        description: 'The value to map (can use expressions like {{ $json.fieldName }})',
-                    },
-                ],
-            },
-        ],
-        description: 'Map input data to Lime CRM properties using expressions',
-    },
-];
-
-/**
- * Common relation input fields for Lime CRM objects
- * These can be used to configure relation settings
- */
-export const relationInputFields: INodeProperties[] = [
-    {
-        displayName: 'Include Relations',
-        name: 'includeRelations',
-        type: 'boolean',
-        default: false,
-        description: 'Whether to include related objects',
-    },
-    {
-        displayName: 'Relation Configuration',
-        name: 'relationsConfig',
-        type: 'fixedCollection',
-        placeholder: 'Add Relation',
-        default: {},
-        typeOptions: {
-            multipleValues: true,
-        },
-        displayOptions: {
-            show: {
-                includeRelations: [true],
-            },
-        },
-        options: [
-            {
-                name: 'relations',
-                displayName: 'Relations',
-                values: [
-                    {
-                        displayName: 'Relation Name',
-                        name: 'relationName',
-                        type: 'options',
-                        typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeRelations',
-                            loadOptionsDependsOn: ['limeType'],
-                        },
-                        default: '',
-                        description: 'Name of the relation to include',
-                    },
-                    {
-                        displayName: 'Properties to Include',
-                        name: 'includeProperties',
-                        type: 'multiOptions',
-                        typeOptions: {
-                            loadOptionsMethod: 'getRelatedTypeProperties',
-                            loadOptionsDependsOn: ['limeType', 'relationName'],
-                        },
-                        default: [],
-                        description: 'Properties to include from related objects',
-                    },
-                ],
-            },
-        ],
-        description: 'Configure related objects to include',
-    },
-];
-
-/**
- * Common options fields for Lime CRM objects
- */
-export const commonOptionsFields: INodeProperties[] = [
-    {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        options: [
-            {
-                displayName: 'Raw Response',
-                name: 'rawResponse',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to return the raw API response instead of parsed data',
-            },
-            {
-                displayName: 'Additional Parameters',
-                name: 'additionalParameters',
-                type: 'json',
-                default: '{}',
-                description: 'Additional parameters to include in the request',
-                typeOptions: {
-                    alwaysOpenEditWindow: true,
-                },
-            },
-        ],
-    },
-];

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

@@ -1,64 +0,0 @@
-import { IExecuteFunctions, INodeProperties, NodePropertyTypes } from 'n8n-workflow';
-
-import * as create from './operations/create.operation';
-import * as get from './operations/get.operation';
-import * as update from './operations/update.operation';
-import * as delete_ from './operations/delete.operation';
-import * as search from './operations/search.operation';
-
-// Export fields for the node
-export const limeObjectFields: INodeProperties[] = [
-    // Operation selection for LimeObject
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-            },
-        },
-        options: [
-            create.description,
-            get.description,
-            update.description,
-            delete_.description,
-            search.description,
-        ],
-        default: 'search',
-    },
-
-    // Operation-specific fields
-    ...create.properties,
-    ...get.properties,
-    ...update.properties,
-    ...delete_.properties,
-    ...search.properties,
-];
-
-// Operations router
-export async function limeObjectOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number },
-) {
-    if (operation === 'create') {
-        return await create.execute.call(this, i);
-    }
-    if (operation === 'get') {
-        return await get.execute.call(this, i);
-    }
-    if (operation === 'update') {
-        return await update.execute.call(this, i);
-    }
-    if (operation === 'delete') {
-        return await delete_.execute.call(this, i);
-    }
-    if (operation === 'search') {
-        return await search.execute.call(this, i);
-    }
-
-    return null;
-}

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

@@ -1,35 +0,0 @@
-import { INodeProperties } from 'n8n-workflow';
-
-export const commonOperations: INodeProperties[] = [
-    // Options for all operations
-    {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-            },
-        },
-        options: [
-            {
-                displayName: 'Include Related Objects',
-                name: 'includeRelated',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to include data from related objects',
-            },
-            {
-                displayName: 'Raw Response',
-                name: 'rawResponse',
-                type: 'boolean',
-                default: false,
-                description: 'Whether to return the full API response instead of just the data',
-            },
-        ],
-    },
-];

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

@@ -1,234 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    IDataObject,
-    NodeOperationError,
-} from 'n8n-workflow';
-
-export const description = {
-    name: 'Create Object',
-    value: 'create',
-    description: 'Create a new object',
-    action: 'Create an object',
-};
-
-export const properties: INodeProperties[] = [
-    // Limetype selection
-    {
-        displayName: 'LimeType',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to create',
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                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',
-                ],
-                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',
-                ],
-                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',
-                ],
-                operation: [
-                    'create',
-                ],
-                inputMethod: [
-                    'json',
-                ],
-            },
-        },
-        typeOptions: {
-            alwaysOpenEditWindow: true,
-        },
-    },
-
-    // Additional options
-    {
-        displayName: 'Options',
-        name: 'options',
-        type: 'collection',
-        placeholder: 'Add Option',
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [
-                    'limeObject',
-                ],
-                operation: [
-                    'create',
-                ],
-            },
-        },
-        options: [
-            {
-                displayName: 'Return Created Object',
-                name: 'returnObject',
-                type: 'boolean',
-                default: true,
-                description: 'Whether to return the created object data',
-            },
-        ],
-    },
-];
-
-export async function execute(
-    this: IExecuteFunctions,
-    i: number,
-) {
-    const { apiRequest } = await import('../../../transport');
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const inputMethod = this.getNodeParameter('inputMethod', i) as string;
-    const options = this.getNodeParameter('options', i, {}) as IDataObject;
-
-    if (!limeType) {
-        throw new NodeOperationError(this.getNode(), 'Lime type must be provided');
-    }
-
-    let objectData: IDataObject;
-
-    // Get object data based on input method
-    if (inputMethod === 'json') {
-        try {
-            const jsonInput = this.getNodeParameter('objectJson', i) as string;
-            objectData = typeof jsonInput === 'string' ? JSON.parse(jsonInput) : jsonInput;
-        } catch (error) {
-            throw new NodeOperationError(this.getNode(), 'Invalid JSON input: ' + error.message);
-        }
-    } else {
-        // Form fields input
-        objectData = {};
-        const propertiesInput = this.getNodeParameter('properties.property', i, []) as IDataObject[];
-
-        if (propertiesInput && propertiesInput.length > 0) {
-            propertiesInput.forEach((prop) => {
-                if (prop.name && prop.value !== undefined) {
-                    objectData[prop.name as string] = prop.value;
-                }
-            });
-        }
-    }
-
-    const endpoint = `/api/v1/limeobject/${encodeURIComponent(limeType)}/`;
-
-    try {
-        const response = await apiRequest.call(this, {
-            method: 'POST',
-            endpoint,
-            body: objectData,
-        });
-
-        // If user wants the created object returned, make another request to get it
-        if (options.returnObject === true && response && response._id) {
-            return await apiRequest.call(this, {
-                method: 'GET',
-                endpoint: `${endpoint}/${response._id}`,
-            });
-        }
-
-        return response;
-    } catch (error) {
-        throw new NodeOperationError(this.getNode(), `Failed to create ${limeType} object: ${error.message}`);
-    }
-}