@limetech/n8n-nodes-lime 2.3.1-dev.1 → 2.5.0-dev.1

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

@@ -1,15 +1,15 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { createLimeobject, getProperties } from '../../../transport';
-import { DATA_RESOURCE, LimetypeProperty } from '../../../models';
+import { DATA_RESOURCE } from '../../../models';
 import {
-    adaptProperty,
     getFilePropertiesNames,
-    getPropertyType,
     processFileResponse,
     setFileProperties,
 } from '../../../utils';
 
+import { parseResourceMapperFields } from '../../../methods';
+
 /**
  * Description and metadata for the "Create Single Object" operation in Lime CRM.
  *
@@ -76,12 +76,20 @@ export const properties: INodeProperties[] = [
     {
         displayName: 'Properties',
         name: 'properties',
-        type: 'fixedCollection',
+        type: 'resourceMapper',
         placeholder: 'Add Property',
         typeOptions: {
-            multipleValues: true,
+            resourceMapper: {
+                resourceMapperMethod: 'getCreateMappingColumns',
+                mode: 'add',
+                addAllFields: false,
+                supportAutoMap: false,
+            },
+            loadOptionsDependsOn: ['limetype'],
+        },
+        default: {
+            value: null,
         },
-        default: {},
         displayOptions: {
             show: {
                 resource: [DATA_RESOURCE],
@@ -89,33 +97,6 @@ export const properties: INodeProperties[] = [
                 inputMethod: ['fields'],
             },
         },
-        options: [
-            {
-                displayName: 'Property',
-                name: 'property',
-                values: [
-                    {
-                        displayName: 'Property Name',
-                        name: 'name',
-                        type: 'options',
-                        typeOptions: {
-                            sortable: true,
-                            loadOptionsMethod: 'getNoHasManyProperties',
-                            loadOptionsDependsOn: ['limetype'],
-                        },
-                        default: '',
-                        description: 'Name of the property',
-                    },
-                    {
-                        displayName: 'Property Value',
-                        name: 'value',
-                        type: 'string',
-                        default: '',
-                        description: 'Value of the property',
-                    },
-                ],
-            },
-        ],
     },
     {
         displayName: 'Object (JSON)',
@@ -136,39 +117,6 @@ export const properties: INodeProperties[] = [
     },
 ];
 
-/**
- *
- * @param context - Node execution context
- * @param i - The index of the current item in the workflow execution
- * @param properties - List of {@link LimeTypeProperty} fetched from Lime CRM
- * @returns IDataObject - parsed data from Simple Fields mode
- */
-function parseSimpleFieldsData(
-    context: IExecuteFunctions,
-    i: number,
-    properties: LimetypeProperty[]
-): IDataObject {
-    const objectData: IDataObject = {};
-    const propertiesInput = context.getNodeParameter(
-        'properties.property',
-        i,
-        []
-    ) as IDataObject[];
-
-    if (propertiesInput && propertiesInput.length > 0) {
-        for (const prop of propertiesInput) {
-            if (prop.name && prop.value !== undefined) {
-                const propertyName = prop.name as string;
-                objectData[propertyName] = adaptProperty(
-                    prop.value as string,
-                    getPropertyType(propertyName, properties)
-                );
-            }
-        }
-    }
-    return objectData;
-}
-
 /**
  * Execute the "Create Single Object" operation for Lime CRM.
  *
@@ -195,13 +143,16 @@ export async function execute(this: IExecuteFunctions, i: number) {
 
     let objectData: IDataObject;
 
-    const properties = await getProperties(this, limetype);
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) return propertiesResponse.data;
+
+    const properties = propertiesResponse.data;
 
     if (inputMethod === 'json') {
         const jsonInput = this.getNodeParameter('objectJson', i) as string;
         objectData = JSON.parse(jsonInput);
     } else {
-        objectData = parseSimpleFieldsData(this, i, properties);
+        objectData = parseResourceMapperFields(this, i, 'properties');
     }
 
     const fileProperties = getFilePropertiesNames(
@@ -215,17 +166,20 @@ export async function execute(this: IExecuteFunctions, i: number) {
         fileProperties,
         objectData
     );
+    if (!setFilePropertiesResponse.success)
+        return setFilePropertiesResponse.data;
 
     const createLimeobjectResponse = await createLimeobject(
         this,
         limetype,
-        setFilePropertiesResponse
+        setFilePropertiesResponse.data
     );
+    if (!createLimeobjectResponse.success) return createLimeobjectResponse.data;
 
     const response = await processFileResponse(
         this,
         fileProperties,
-        createLimeobjectResponse
+        createLimeobjectResponse.data
     );
-    return response.json;
+    return response.json.data;
 }

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

@@ -2,6 +2,7 @@ import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { deleteLimeobject } from '../../../transport';
 import { DATA_RESOURCE } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
 /**
  * Description and metadata for the "Delete Single Object" operation in Lime CRM.
@@ -75,9 +76,13 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowResponse<Record<string, never>>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const objectId = this.getNodeParameter('objectId', i) as string;
 
-    return await deleteLimeobject(this, limetype, objectId);
+    const response = await deleteLimeobject(this, limetype, objectId);
+    return response.data;
 }

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

@@ -2,6 +2,7 @@ import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { IncludedProperties, queryLimeobjects } from '../../../transport';
 import { DATA_RESOURCE, DEFAULT_API_OBJECT_LIMIT } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
 /**
  * Description and metadata for the "Get Many Objects" operation in Lime CRM.
@@ -389,7 +390,7 @@ async function fetchLimeObjects(
     filter: string,
     limit: number | null,
     orderBy: Record<string, 'ASC' | 'DESC'>[]
-): Promise<IncludedProperties[]> {
+): Promise<WorkflowResponse<IncludedProperties[]>> {
     const allResults: IncludedProperties[] = [];
     const parsedFilter = JSON.parse(filter);
     const unlimited = limit === null || limit === 0;
@@ -413,7 +414,10 @@ async function fetchLimeObjects(
             orderBy: orderBy,
         });
 
-        const batch = await queryLimeobjects(this, q);
+        const batchResponse = await queryLimeobjects(this, q);
+        if (!batchResponse.success) return batchResponse.data;
+
+        const batch = batchResponse.data;
 
         const collected = batch.objects.length;
         if (collected === 0) break;

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

@@ -1,5 +1,6 @@
 import {
     IExecuteFunctions,
+    INodeExecutionData,
     INodeProperties,
     NodeOperationError,
 } from 'n8n-workflow';
@@ -125,15 +126,22 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<INodeExecutionData> {
     const source = this.getNodeParameter('source', i) as string;
     const id = this.getNodeParameter('identifier', i) as string;
 
     if (source == 'byFile') {
         const fileResponse = await getFileContent(this, id);
+        if (!fileResponse.success)
+            return {
+                json: fileResponse.data,
+            };
         return {
             json: {},
-            binary: { data: fileResponse },
+            binary: { data: fileResponse.data },
         };
     }
     if (source == 'byLimeobject') {
@@ -146,11 +154,15 @@ export async function execute(this: IExecuteFunctions, i: number) {
             id,
             property
         );
+        if (!fileResponse.success)
+            return {
+                json: fileResponse.data,
+            };
 
         return {
             json: {},
             binary: {
-                data: fileResponse,
+                data: fileResponse.data,
             },
         };
     }

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

@@ -1,9 +1,9 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { getLimeobject, getProperties } from '../../../transport';
-import { DATA_RESOURCE } from '../../../models';
+import { DATA_RESOURCE, Limeobject } from '../../../models';
 import { getFilePropertiesNames, processFileResponse } from '../../../utils';
-
+import { WorkflowFileResponse } from '../../../../response';
 /**
  * Description and metadata for the "Get Single Object" operation in Lime CRM.
  *
@@ -94,7 +94,10 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowFileResponse<Limeobject>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const objectId = this.getNodeParameter('objectId', i) as string;
     const includeFileContent = this.getNodeParameter(
@@ -103,14 +106,20 @@ export async function execute(this: IExecuteFunctions, i: number) {
     ) as boolean;
 
     const limeObjectResponse = await getLimeobject(this, limetype, objectId);
+    if (!limeObjectResponse.success) return { json: limeObjectResponse.data };
 
     const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) return { json: propertiesResponse.data };
 
-    const fileProperties = getFilePropertiesNames(propertiesResponse);
-    return processFileResponse(
+    const fileProperties = getFilePropertiesNames(propertiesResponse.data);
+    const fileResponse = await processFileResponse<Limeobject>(
         this,
         fileProperties,
-        limeObjectResponse,
+        limeObjectResponse.data,
         includeFileContent
     );
+    return {
+        json: fileResponse.json.data,
+        binary: fileResponse.binary,
+    };
 }

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

@@ -1,13 +1,13 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { getProperties, updateLimeobject } from '../../../transport';
-import { DATA_RESOURCE } from '../../../models';
+import { DATA_RESOURCE, Limeobject } from '../../../models';
 import {
-    adaptProperty,
     getFilePropertiesNames,
-    getPropertyType,
     processFileResponse,
     setFileProperties,
 } from '../../../utils';
+import { WorkflowFileResponse } from '../../../../response';
+import { parseResourceMapperFields } from '../../../methods';
 
 /**
  * Description and metadata for the "Update Single Object" operation in Lime CRM.
@@ -71,7 +71,7 @@ export const properties: INodeProperties[] = [
         options: [
             {
                 name: 'Simple Fields',
-                value: 'simple',
+                value: 'fields',
                 description: 'Define fields using the UI',
             },
             {
@@ -80,7 +80,7 @@ export const properties: INodeProperties[] = [
                 description: 'Define fields using JSON',
             },
         ],
-        default: 'simple',
+        default: 'fields',
         description: 'How to input the data',
         displayOptions: {
             show: {
@@ -109,48 +109,29 @@ export const properties: INodeProperties[] = [
         },
     },
     {
-        displayName: 'Fields',
-        name: 'simpleFields',
-        placeholder: 'Add Field',
-        type: 'fixedCollection',
+        displayName: 'Properties',
+        name: 'properties',
+        type: 'resourceMapper',
+        placeholder: 'Add Property',
         typeOptions: {
-            multipleValues: true,
-            sortable: true,
+            resourceMapper: {
+                resourceMapperMethod: 'getUpdateMappingColumns',
+                mode: 'add',
+                addAllFields: false,
+                supportAutoMap: false,
+            },
+            loadOptionsDependsOn: ['limetype'],
+        },
+        default: {
+            value: null,
         },
-        default: {},
         displayOptions: {
             show: {
                 resource: [DATA_RESOURCE],
                 operation: ['updateSingleObject'],
-                inputType: ['simple'],
+                inputType: ['fields'],
             },
         },
-        options: [
-            {
-                name: 'field',
-                displayName: 'Field',
-                values: [
-                    {
-                        displayName: 'Field Name',
-                        name: 'fieldName',
-                        type: 'options',
-                        typeOptions: {
-                            loadOptionsMethod: 'getNoHasManyProperties',
-                            loadOptionsDependsOn: ['limetype'],
-                        },
-                        default: '',
-                        description: 'The name of the field',
-                    },
-                    {
-                        displayName: 'Field Value',
-                        name: 'fieldValue',
-                        type: 'string',
-                        default: '',
-                        description: 'The value of the field',
-                    },
-                ],
-            },
-        ],
     },
 ];
 
@@ -175,32 +156,28 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowFileResponse<Limeobject>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const id = this.getNodeParameter('id', i) as string;
     const inputType = this.getNodeParameter('inputType', i) as string;
 
     let body: IDataObject = {};
 
-    const properties = await getProperties(this, limetype);
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success)
+        return {
+            json: propertiesResponse.data,
+        };
+    const properties = propertiesResponse.data;
 
     if (inputType === 'json') {
         const jsonData = this.getNodeParameter('jsonData', i) as string;
         body = JSON.parse(jsonData);
     } else {
-        const simpleFields = this.getNodeParameter(
-            'simpleFields.field',
-            i,
-            []
-        ) as IDataObject[];
-        for (const field of simpleFields) {
-            const fieldName = field.fieldName as string;
-            const fieldValue = field.fieldValue as string;
-            body[fieldName] = adaptProperty(
-                fieldValue,
-                getPropertyType(fieldName, properties)
-            );
-        }
+        body = parseResourceMapperFields(this, i, 'properties');
     }
 
     const fileProperties = getFilePropertiesNames(properties);
@@ -213,11 +190,18 @@ export async function execute(this: IExecuteFunctions, i: number) {
         id,
         body
     );
+    if (!updateLimeobjectResponse.success)
+        return {
+            json: updateLimeobjectResponse.data,
+        };
 
-    const response = await processFileResponse(
+    const response = await processFileResponse<Limeobject>(
         this,
         fileProperties,
-        updateLimeobjectResponse
+        updateLimeobjectResponse.data
     );
-    return response.json;
+    return {
+        json: response.json.data,
+        binary: response.binary,
+    };
 }

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

@@ -69,9 +69,13 @@ export async function metadataOperations(
     switch (operation) {
         case 'getAllLimetypes': {
             const results = await operations.getAllLimetypes.execute.call(this);
-            return results.map((limetype) => ({
-                json: limetype,
-            }));
+            if (Array.isArray(results)) {
+                return results.map((limetype) => ({
+                    json: limetype,
+                }));
+            } else {
+                return { json: results };
+            }
         }
         case 'getSingleLimetype': {
             return {

package/nodes/lime-crm/resources/metadata/operations/getAllLimetypes.operation.ts

@@ -2,6 +2,7 @@ import { IExecuteFunctions } from 'n8n-workflow';
 
 import { getLimetypesFromApi } from '../../../transport';
 import { Limetype } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
 /**
  * Description and metadata for the "Get All Limetypes" operation in Lime CRM.
@@ -23,6 +24,9 @@ export const description = {
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions): Promise<Limetype[]> {
-    return await getLimetypesFromApi(this);
+export async function execute(
+    this: IExecuteFunctions
+): Promise<WorkflowResponse<Limetype[]>> {
+    const response = await getLimetypesFromApi(this);
+    return response.data;
 }

package/nodes/lime-crm/resources/metadata/operations/getSingleFileMetadata.operation.ts

@@ -1,14 +1,12 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodeOperationError,
-} from 'n8n-workflow';
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import {
     FileMetadata,
     getFileMetadata,
     getFileMetadataByLimeobject,
 } from '../../../transport';
 import { METADATA_RESOURCE } from '../../../models';
+import { APIResponse, WorkflowResponse } from '../../../../response';
+import { handleWorkflowError } from '../../../../errorHandling';
 
 /**
  * Description and metadata for the "Get Single File Metadata" operation in Lime CRM.
@@ -127,21 +125,26 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<FileMetadata> {
+): Promise<WorkflowResponse<FileMetadata>> {
     const source = this.getNodeParameter('source', i) as string;
     const id = this.getNodeParameter('identifier', i) as string;
+    let response: APIResponse<FileMetadata>;
 
     if (source == 'byFile') {
-        return await getFileMetadata(this, id);
-    }
-    if (source == 'byLimeobject') {
+        response = await getFileMetadata(this, id);
+    } else if (source == 'byLimeobject') {
         const limetype = this.getNodeParameter('limetype', i) as string;
         const property = this.getNodeParameter('property', i) as string;
-        return await getFileMetadataByLimeobject(this, limetype, id, property);
+        response = await getFileMetadataByLimeobject(
+            this,
+            limetype,
+            id,
+            property
+        );
+    } else {
+        response = handleWorkflowError(this, {
+            message: `The source "${source} is not supported`,
+        });
     }
-
-    throw new NodeOperationError(
-        this.getNode(),
-        `The source "${source}" is not supported!`
-    );
+    return response.data;
 }

package/nodes/lime-crm/resources/metadata/operations/getSingleLimetype.operation.ts

@@ -1,6 +1,7 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { getLimetype } from '../../../transport/limetypes';
-import { METADATA_RESOURCE } from '../../../models';
+import { Limetype, METADATA_RESOURCE } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
 /**
  * Description and metadata for the "Get Single Limetype" operation in Lime CRM.
@@ -51,8 +52,12 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowResponse<Limetype>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
 
-    return getLimetype(this, limetype);
+    const response = await getLimetype(this, limetype);
+    return response.data;
 }

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

@@ -1,5 +1,7 @@
 import { LIME_CRM_API_CREDENTIAL_KEY } from '../models';
-import { IAllExecuteFunctions, NodeOperationError } from 'n8n-workflow';
+import { IAllExecuteFunctions, JsonObject } from 'n8n-workflow';
+import { WorkflowErrorContext, handleWorkflowError } from '../utils';
+import { APIResponse, SuccessResponse } from '../../response';
 
 /**
  * HTTP methods supported by the Lime CRM API.
@@ -31,6 +33,16 @@ export function removeKeys<T extends object, K extends keyof T>(
     return obj;
 }
 
+export function prepareResponseWithoutKeys<T extends object, K extends keyof T>(
+    response: SuccessResponse<T>,
+    keys: K[]
+): SuccessResponse<Omit<T, K>> {
+    return {
+        success: true,
+        data: removeKeys(response.data, keys),
+    };
+}
+
 /**
  * Retrieve the base URL for the Lime CRM API from stored credentials.
  *
@@ -85,31 +97,33 @@ interface LimeAPIArguments {
 export async function callLimeApi<T>(
     nodeContext: IAllExecuteFunctions,
     options: LimeAPIArguments
-): Promise<T> {
+): Promise<APIResponse<T>> {
     try {
-        return await nodeContext.helpers.requestWithAuthentication.call(
-            nodeContext,
-            LIME_CRM_API_CREDENTIAL_KEY,
-            {
-                method: options.method,
-                url: options.url,
-                json: options.json || true,
-                baseURL: await getLimeUrl(nodeContext),
-                ...options.requestOptions,
-            }
-        );
+        const response =
+            await nodeContext.helpers.requestWithAuthentication.call(
+                nodeContext,
+                LIME_CRM_API_CREDENTIAL_KEY,
+                {
+                    method: options.method,
+                    url: options.url,
+                    json: options.json || true,
+                    baseURL: await getLimeUrl(nodeContext),
+                    ...options.requestOptions,
+                }
+            );
+        return {
+            success: true,
+            data: response,
+        };
     } catch (error) {
-        const errorContext = {
-            error: error instanceof Error ? error.message : String(error),
+        const errorContext: WorkflowErrorContext = {
+            message: error instanceof Error ? error.message : String(error),
             status: error?.cause?.status,
             metadata: {
                 ...options.requestOptions,
                 ...options.errorMetadata,
-            },
+            } as JsonObject,
         };
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            JSON.stringify(errorContext)
-        );
+        return handleWorkflowError(nodeContext, errorContext, true);
     }
 }