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

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

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

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

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