@limetech/n8n-nodes-lime 2.6.1 → 2.7.0-dev.1

package/nodes/lime-crm/LimeCrmNode.node.ts

@@ -24,8 +24,11 @@ import {
     getLimetypeProperties,
     getLimetypes,
     getNoHasManyProperties,
+    getRelationProperties,
     getCreateMappingColumns,
     getUpdateMappingColumns,
+    getRelationLookupMappingColumns,
+    getRelationPropertiesWithLookupField,
 } from './methods';
 
 /**
@@ -148,10 +151,13 @@ export class LimeCrmNode implements INodeType {
             getLimetypeProperties,
             getFileProperties,
             getNoHasManyProperties,
+            getRelationProperties,
+            getRelationPropertiesWithLookupField,
         },
         resourceMapping: {
             getUpdateMappingColumns,
             getCreateMappingColumns,
+            getRelationLookupMappingColumns,
         },
     };
 

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

@@ -110,3 +110,87 @@ export async function getNoHasManyProperties(
 ): Promise<INodePropertyOptions[]> {
     return getFilteredLimetypeProperties(this, undefined, new Set(['hasmany']));
 }
+
+/**
+ * Get only relation properties (belongsto/hasone) for the current Limetype.
+ *
+ * @returns Array of relation property options
+ *
+ * @public
+ * @group Load Options Methods
+ */
+export async function getRelationProperties(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    return getFilteredLimetypeProperties(
+        this,
+        new Set(['belongsto', 'hasone'])
+    );
+}
+
+/**
+ * Get properties from ALL related limetypes for relation fields.
+ *
+ * This method finds all relation properties (belongsto/hasone) on the current limetype,
+ * fetches properties from each related limetype, and returns them grouped by limetype.
+ * Each option is prefixed with the relation field name for clarity.
+ *
+ * @returns Array of property options from all related limetypes, grouped by relation
+ *
+ * @public
+ * @group Load Options Methods
+ */
+export async function getRelationPropertiesWithLookupField(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    const limetype = this.getNodeParameter('limetype', '') as string;
+
+    if (!limetype) return [];
+
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) return [];
+
+    const relationProperties = propertiesResponse.data.filter(
+        (p) => p.type === 'belongsto' || p.type === 'hasone'
+    );
+
+    const allOptions: INodePropertyOptions[] = [];
+    for (const relationProp of relationProperties) {
+        const relatedLimetype = relationProp.relatedLimetype as string;
+
+        if (!relatedLimetype) {
+            Logger.warn(`No relatedLimetype found for ${relationProp.name}`);
+            continue;
+        }
+
+        const relatedPropertiesResponse = await getProperties(
+            this,
+            relatedLimetype
+        );
+        if (!relatedPropertiesResponse.success) continue;
+
+        const relationDisplayName =
+            (relationProp.localname as string) || (relationProp.name as string);
+
+        const options = relatedPropertiesResponse.data
+            .filter((p) => p.type !== 'hasmany')
+            .map((p) => ({
+                name: `${relationDisplayName} → ${(p.localname as string) || (p.name as string)}`,
+                value: `${relationProp.name}.${p.name}`,
+                description: `Lookup ${relationDisplayName} by ${p.name} (${p.type})`,
+            }));
+
+        allOptions.push(...options);
+    }
+
+    const emptyOption: INodePropertyOptions = {
+        name: '(None - not a relation field)',
+        value: '',
+        description: 'Leave empty if this field is not a relation',
+    };
+
+    return [
+        emptyOption,
+        ...allOptions.sort((a, b) => a.name.localeCompare(b.name)),
+    ];
+}

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

@@ -4,9 +4,12 @@ export {
     getFilteredLimetypeProperties,
     getLimetypeProperties,
     getNoHasManyProperties,
+    getRelationProperties,
+    getRelationPropertiesWithLookupField,
 } from './getLimetypeProperties';
 export {
     getCreateMappingColumns,
     getUpdateMappingColumns,
+    getRelationLookupMappingColumns,
     parseResourceMapperFields,
 } from './resourceMapping';

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

@@ -139,3 +139,79 @@ export async function getUpdateMappingColumns(
     const limetype = this.getNodeParameter('limetype') as string;
     return getMappingColumns(this, 'update', limetype);
 }
+
+/**
+ * Method for getting relation lookup fields as a resource mapper.
+ * Shows one picker per relation (belongsto/hasone) with the related object's properties.
+ */
+export async function getRelationLookupMappingColumns(
+    this: ILoadOptionsFunctions
+): Promise<ResourceMapperFields> {
+    const limetype = this.getNodeParameter('limetype') as string;
+    if (!limetype) {
+        return { fields: [] };
+    }
+
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) {
+        Logger.error(
+            `There was an error with fetching properties: ${JSON.stringify(propertiesResponse.data)}`
+        );
+        return { fields: [] };
+    }
+
+    // Find all relation properties (belongsto/hasone)
+    const relationProperties = propertiesResponse.data.filter(
+        (property) =>
+            property.type === 'belongsto' || property.type === 'hasone'
+    );
+
+    const fields = await Promise.all(
+        relationProperties.map(async (relationProp) => {
+            const relatedLimetype = relationProp.relatedLimetype as string;
+            const relationDisplayName =
+                relationProp.localname || relationProp.name;
+
+            if (!relatedLimetype) {
+                Logger.warn(
+                    `No relatedLimetype found for ${relationProp.name}`
+                );
+                return null;
+            }
+
+            // Fetch properties from the related limetype
+            const relatedPropertiesResponse = await getProperties(
+                this,
+                relatedLimetype
+            );
+            if (!relatedPropertiesResponse.success) {
+                return null;
+            }
+
+            // Get available lookup properties (exclude hasmany relations)
+            const lookupOptions = relatedPropertiesResponse.data
+                .filter((p) => p.type !== 'hasmany')
+                .map((p) => ({
+                    value: p.name,
+                    name: `${p.localname || p.name} [${p.type}]`,
+                }))
+                .sort((a, b) => a.name.localeCompare(b.name));
+
+            return {
+                id: relationProp.name,
+                displayName: `${relationDisplayName}`,
+                required: false,
+                defaultMatch: false,
+                display: true,
+                type: 'options' as FieldType,
+                options: lookupOptions,
+            };
+        })
+    );
+
+    return {
+        fields: fields
+            .filter((f): f is NonNullable<typeof f> => f !== null)
+            .sort((a, b) => a.displayName.localeCompare(b.displayName)),
+    };
+}

package/nodes/lime-crm/models/limetype.ts

@@ -32,6 +32,7 @@ export type LimetypeProperty = {
     required: boolean;
     length?: number;
     options?: LimetypePropertyOption[];
+    relatedLimetype?: string;
 } & Record<string, APIResponseValue>;
 
 /**

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

@@ -21,6 +21,10 @@ const moduleHandler = new N8NOperationModuleHandler([
     operations.deleteSingleObject,
     operations.getManyObjects,
     operations.getSingleFile,
+    operations.createManyObjects,
+    operations.updateManyObjects,
+    operations.createOrUpdateManyObjects,
+    operations.startBulkImport,
 ]);
 
 /**
@@ -75,7 +79,7 @@ export const dataFields: INodeProperties[] = [
 export async function dataOperations(
     this: IExecuteFunctions,
     { operation, i }: { operation: string; i: number }
-): Promise<INodeExecutionData | INodeExecutionData[]> {
+): Promise<INodeExecutionData | INodeExecutionData[] | undefined> {
     switch (operation) {
         case 'createSingleObject': {
             return {
@@ -115,6 +119,35 @@ export async function dataOperations(
         case 'getSingleFile': {
             return await operations.getSingleFile.execute.call(this, i);
         }
+        case 'createManyObjects': {
+            const result = await operations.createManyObjects.execute.call(
+                this,
+                i
+            );
+            return result && { json: result };
+        }
+        case 'updateManyObjects': {
+            const result = await operations.updateManyObjects.execute.call(
+                this,
+                i
+            );
+            return result && { json: result };
+        }
+        case 'createOrUpdateManyObjects': {
+            const result =
+                await operations.createOrUpdateManyObjects.execute.call(
+                    this,
+                    i
+                );
+            return result && { json: result };
+        }
+        case 'startBulkImport': {
+            const result = await operations.startBulkImport.execute.call(
+                this,
+                i
+            );
+            return result && { json: result };
+        }
     }
 
     throw new NodeOperationError(

package/nodes/lime-crm/resources/data/operations/bulkImportCommons.ts

@@ -0,0 +1,323 @@
+import {
+    IDataObject,
+    IExecuteFunctions,
+    INodeProperties,
+    LoggerProxy as Logger,
+    NodeOperationError,
+} from 'n8n-workflow';
+import { DATA_RESOURCE } from '../../../models';
+import {
+    BulkImportJobPayload,
+    BulkImportMode,
+    BulkImportPayloadObject,
+    createBulkImportJob,
+    uploadBulkImportData,
+    waitForBulkImportJob,
+} from '../../../transport/bulkimport';
+import { parseResourceMapperFields } from '../../../methods';
+
+export type BulkImportOperationName =
+    | 'createManyObjects'
+    | 'createOrUpdateManyObjects'
+    | 'updateManyObjects';
+
+/**
+ * Generate common properties for bulk import operations.
+ * @param operationName - The operation value to show these properties for
+ * @param matchingPropertyRequired - Whether the matching property field is required (true for update/create_or_update, false for create)
+ */
+export function getBulkImportProperties(
+    operationName: BulkImportOperationName,
+    matchingPropertyRequired: boolean
+): INodeProperties[] {
+    return [
+        {
+            displayName:
+                '<h1>Alpha</h1>' +
+                'This feature is in alpha and will eventually change and require manual fixes to this node.<br>' +
+                '<br>' +
+                'The package <b>limepkg-mbeku-bulk-import >=1.4.1,<2.0.</b> must be installed in the solution.<br>' +
+                '<br>' +
+                '⚠️ Skips business logic such as automations, custom lime objects, webhooks and sql-on-update.',
+            name: 'alphaNotice',
+            type: 'notice',
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                },
+            },
+            default: '',
+        },
+        {
+            displayName: 'Limetype',
+            name: 'limetype',
+            type: 'options',
+            typeOptions: {
+                loadOptionsMethod: 'getLimetypes',
+            },
+            required: true,
+            default: '',
+            description: 'The type of object to import',
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                },
+            },
+        },
+        {
+            displayName: 'Matching Property',
+            name: 'matchingProperty',
+            type: 'options',
+            typeOptions: {
+                loadOptionsMethod: 'getNoHasManyProperties',
+                loadOptionsDependsOn: ['limetype'],
+            },
+            required: matchingPropertyRequired,
+            default: '',
+            description: matchingPropertyRequired
+                ? 'The property to use to match existing objects. Must be a unique property.'
+                : 'Optional: The property to use to match existing objects. If set, objects matching an existing record will be skipped.',
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                },
+            },
+        },
+        {
+            displayName: 'Input Method',
+            name: 'inputMethod',
+            type: 'options',
+            options: [
+                {
+                    name: 'Form Fields',
+                    value: 'fields',
+                    description: 'Define fields using the UI',
+                },
+                {
+                    name: 'JSON',
+                    value: 'json',
+                    description: 'Define fields using JSON',
+                },
+            ],
+            default: 'fields',
+            description: 'How to input the data',
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                },
+            },
+        },
+        {
+            displayName: 'Object (JSON)',
+            name: 'objectJson',
+            type: 'json',
+            default: '{\n  "name": "Company Name",\n  "phone": "+987654321"\n}',
+            description:
+                'Object data in JSON format. Property names must match the Lime CRM field names.',
+            typeOptions: {
+                alwaysOpenEditWindow: true,
+            },
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                    inputMethod: ['json'],
+                },
+            },
+        },
+        {
+            displayName: 'Properties',
+            name: 'properties',
+            type: 'resourceMapper',
+            placeholder: 'Add Property',
+            typeOptions: {
+                resourceMapper: {
+                    resourceMapperMethod: 'getCreateMappingColumns',
+                    mode: 'add',
+                    addAllFields: false,
+                    supportAutoMap: false,
+                },
+                loadOptionsDependsOn: ['limetype'],
+            },
+            default: {
+                value: null,
+            },
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                    inputMethod: ['fields'],
+                },
+            },
+        },
+        {
+            displayName: 'Relation Lookups',
+            name: 'relationLookups',
+            type: 'resourceMapper',
+            placeholder: 'Add Relation Lookup',
+            description:
+                'For relation fields (belongsto/hasone), specify which property on the related object to use for matching.',
+            typeOptions: {
+                resourceMapper: {
+                    resourceMapperMethod: 'getRelationLookupMappingColumns',
+                    mode: 'add',
+                    addAllFields: true,
+                    supportAutoMap: false,
+                    valuesLabel: 'Relation Lookups',
+                },
+                loadOptionsDependsOn: ['limetype'],
+            },
+            default: {
+                value: null,
+            },
+            displayOptions: {
+                show: {
+                    resource: [DATA_RESOURCE],
+                    operation: [operationName],
+                    inputMethod: ['fields'],
+                },
+            },
+        },
+    ];
+}
+
+/**
+ * Extract properties to import from JSON input.
+ * @param jsonData
+ */
+function getPropertiesFromJson(jsonData: string): string[] {
+    const parsed = JSON.parse(jsonData);
+    return Object.keys(parsed);
+}
+
+/**
+ * Execute a bulk import operation for Lime CRM.
+ *
+ * @param context - The n8n execution context
+ * @param i - The index of the current item in the workflow execution
+ * @param mode - The bulk import mode: 'create', 'update', or 'create_or_update'
+ *
+ * @returns The bulk import job status and summary
+ */
+export async function executeBulkImport(
+    context: IExecuteFunctions,
+    i: number,
+    mode: BulkImportMode
+): Promise<IDataObject | undefined> {
+    if (i > 0) {
+        return undefined;
+    }
+
+    const limetype = context.getNodeParameter('limetype', i) as string;
+    const inputMethod = context.getNodeParameter('inputMethod', i) as string;
+    const items = context.getInputData();
+
+    // Matching property is always available but optional for create mode
+    const matchingProperty = context.getNodeParameter(
+        'matchingProperty',
+        i,
+        ''
+    ) as string;
+
+    Logger.info(
+        `Preparing bulk import (${mode}) of ${items.length} objects for limetype: ${limetype}`
+    );
+
+    // Step 1: Compute the properties to import based on the first item
+    let propertiesToImport: string[];
+    if (inputMethod === 'json') {
+        propertiesToImport = getPropertiesFromJson(
+            context.getNodeParameter('objectJson', 0) as string
+        );
+    } else {
+        const firstItemData = parseResourceMapperFields(
+            context,
+            0,
+            'properties'
+        );
+        propertiesToImport = Object.keys(firstItemData);
+
+        // Apply relation lookups: replace property names with lookup paths (e.g., 'coworker' -> 'coworker.email')
+        // The relationLookups is a resource mapper where keys are relation property names
+        // and values are the lookup property names on the related limetype
+        const relationLookupsData = parseResourceMapperFields(
+            context,
+            0,
+            'relationLookups'
+        );
+
+        const lookupMap = new Map<string, string>();
+        for (const [relationProp, lookupProp] of Object.entries(
+            relationLookupsData
+        )) {
+            if (lookupProp && typeof lookupProp === 'string') {
+                lookupMap.set(relationProp, `${relationProp}.${lookupProp}`);
+            }
+        }
+
+        propertiesToImport = propertiesToImport.map(
+            (prop) => lookupMap.get(prop) || prop
+        );
+    }
+
+    Logger.info(`Properties to import: ${propertiesToImport.join(', ')}`);
+
+    // Step 2: Prepare the body for all items
+    const body: BulkImportPayloadObject[] = items.map((_, idx) => {
+        if (inputMethod === 'json') {
+            return JSON.parse(
+                context.getNodeParameter('objectJson', idx) as string
+            );
+        }
+        const data = parseResourceMapperFields(context, idx, 'properties');
+        return { values: data };
+    });
+
+    // Step 3: Create the bulk import job
+    const jobPayload: BulkImportJobPayload = {
+        mode,
+        limetype,
+        ...(matchingProperty && { matchingProperty }),
+        properties: propertiesToImport,
+    };
+
+    const jobResponse = await createBulkImportJob(context, jobPayload);
+    const jobId = jobResponse.id;
+
+    // Step 4: Upload the data file
+    await uploadBulkImportData(context, jobId, body);
+
+    // Step 5: Poll for completion
+    const finalStatus = await waitForBulkImportJob(context, jobId, 2500);
+
+    if (finalStatus.status === 'failed') {
+        throw new NodeOperationError(
+            context.getNode(),
+            'The bulk import job failed',
+            {
+                message: 'The bulk import job failed due to a server error.',
+                description: `Bulk import job with ID ${jobId} has failed. Check the Lime CRM server for more details.`,
+            }
+        );
+    }
+
+    // Step 6: Return the results summary
+    return {
+        jobId,
+        status: finalStatus.status,
+        startedAt: finalStatus.startedAt,
+        finishedAt: finalStatus.endedAt,
+        summary: finalStatus.result || {
+            total: 0,
+            created: 0,
+            updated: 0,
+            skipped: 0,
+            failed: 0,
+        },
+        taskId: finalStatus.extras?.task_id || finalStatus.extras?.taskId,
+    };
+}

package/nodes/lime-crm/resources/data/operations/createManyObjects.operation.ts

@@ -0,0 +1,44 @@
+import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import {
+    getBulkImportProperties,
+    executeBulkImport,
+} from './bulkImportCommons';
+
+/**
+ * Description and metadata for the "Create many objects" operation in Lime CRM.
+ *
+ * @public
+ */
+export const description = {
+    name: 'Create Many Objects (Alpha)',
+    value: 'createManyObjects',
+    description:
+        'Create multiple objects via bulk import. Skips business logic.',
+    action: 'Create many objects (alpha)',
+};
+
+/**
+ * Node properties for the "Create many objects" operation.
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = getBulkImportProperties(
+    'createManyObjects',
+    false // Matching property is optional for create (can be used to skip duplicates)
+);
+
+/**
+ * Execute the "Create many objects" operation for Lime CRM.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The bulk import job status and summary
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<IDataObject | undefined> {
+    return executeBulkImport(this, i, 'create');
+}

package/nodes/lime-crm/resources/data/operations/createOrUpdateManyObjects.operation.ts

@@ -0,0 +1,44 @@
+import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import {
+    getBulkImportProperties,
+    executeBulkImport,
+} from './bulkImportCommons';
+
+/**
+ * Description and metadata for the "Create or update many objects" operation in Lime CRM.
+ *
+ * @public
+ */
+export const description = {
+    name: 'Create or Update Many Objects (Alpha)',
+    value: 'createOrUpdateManyObjects',
+    description:
+        'Create or update multiple objects via bulk import. Skips business logic.',
+    action: 'Create or update many objects (alpha)',
+};
+
+/**
+ * Node properties for the "Create or update many objects" operation.
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = getBulkImportProperties(
+    'createOrUpdateManyObjects',
+    true // Matching property needed for create_or_update
+);
+
+/**
+ * Execute the "Create or update many objects" operation for Lime CRM.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The bulk import job status and summary
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<IDataObject | undefined> {
+    return executeBulkImport(this, i, 'create_or_update');
+}