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

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);
     }
 }

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

@@ -1,13 +1,12 @@
 import { callLimeApi, getLimeobject } from '.';
+import { IExecuteFunctions, IBinaryData, BINARY_ENCODING } from 'n8n-workflow';
+import { prepareResponseWithoutKeys } from './commons';
 import {
-    IExecuteFunctions,
-    IBinaryData,
-    BINARY_ENCODING,
-    NodeOperationError,
-} from 'n8n-workflow';
-import { removeKeys } from './commons';
-import { getFilenameFromHeader, setFilename } from '../utils';
-
+    getFilenameFromHeader,
+    handleWorkflowError,
+    setFilename,
+} from '../utils';
+import { APIResponse } from '../../response';
 /**
  * Endpoint path for Lime CRM file API.
  *
@@ -71,13 +70,16 @@ export type FileMetadata = {
 export async function getFileMetadata(
     nodeContext: IExecuteFunctions,
     id: string | number
-): Promise<FileMetadata> {
+): Promise<APIResponse<FileMetadata>> {
     const url = `${LIME_FILE_URL}${id}/`;
-    const fileMetadata = await callLimeApi<FileMetadata>(nodeContext, {
+    const fileMetadataResponse = await callLimeApi<FileMetadata>(nodeContext, {
         method: 'GET',
         url: url,
     });
-    return removeKeys(fileMetadata, ['_links']);
+
+    if (!fileMetadataResponse.success) return fileMetadataResponse;
+
+    return prepareResponseWithoutKeys(fileMetadataResponse, ['_links']);
 }
 
 /**
@@ -97,19 +99,27 @@ export async function getFileMetadataByLimeobject(
     limetype: string,
     id: string,
     fileTypeProperty: string
-): Promise<FileMetadata> {
+): Promise<APIResponse<FileMetadata>> {
     const objectResponse = await getLimeobject(nodeContext, limetype, id);
-    const fileId = objectResponse[fileTypeProperty] as string | undefined;
+    if (!objectResponse.success) return objectResponse;
+
+    const fileId = objectResponse.data[fileTypeProperty] as string | undefined;
 
     if (!fileId) {
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            'The specified Limeobject does not have an associated file.'
+        return handleWorkflowError(
+            nodeContext,
+            {
+                message:
+                    'The specified Limeobject does not have an associated file',
+            },
+            true
         );
     }
 
-    const fileMetadata = await getFileMetadata(nodeContext, fileId);
-    return removeKeys(fileMetadata, ['_links']);
+    const fileMetadataResponse = await getFileMetadata(nodeContext, fileId);
+    if (!fileMetadataResponse.success) return fileMetadataResponse;
+
+    return prepareResponseWithoutKeys(fileMetadataResponse, ['_links']);
 }
 
 /**
@@ -125,7 +135,7 @@ export async function getFileMetadataByLimeobject(
 export async function getFileContent(
     nodeContext: IExecuteFunctions,
     id: string | number
-): Promise<IBinaryData> {
+): Promise<APIResponse<IBinaryData>> {
     const url = `${LIME_FILE_URL}${id}/contents/`;
 
     const response = await callLimeApi<FileApiResponse>(nodeContext, {
@@ -139,13 +149,19 @@ export async function getFileContent(
         json: false,
     });
 
-    const fileName = getFilenameFromHeader(response.headers) || `file_${id}`;
+    if (!response.success) return response;
+
+    const fileName =
+        getFilenameFromHeader(response.data.headers) || `file_${id}`;
     const binaryData = await nodeContext.helpers.prepareBinaryData(
-        response.body
+        response.data.body
     );
     binaryData.fileName = setFilename(binaryData, fileName);
 
-    return binaryData;
+    return {
+        success: true,
+        data: binaryData,
+    };
 }
 
 /**
@@ -165,14 +181,22 @@ export async function getFileContentByLimetype(
     limetype: string,
     id: string,
     fileTypeProperty: string
-): Promise<IBinaryData> {
+): Promise<APIResponse<IBinaryData>> {
     const limeObjectResponse = await getLimeobject(nodeContext, limetype, id);
-    const fileId = limeObjectResponse[fileTypeProperty] as string | undefined;
+    if (!limeObjectResponse.success) return limeObjectResponse;
+
+    const fileId = limeObjectResponse.data[fileTypeProperty] as
+        | string
+        | undefined;
 
     if (!fileId) {
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            'The specified Limeobject does not have an associated file.'
+        return handleWorkflowError(
+            nodeContext,
+            {
+                message:
+                    'The specified Limeobject does not have an associated file.',
+            },
+            true
         );
     }
 
@@ -194,27 +218,28 @@ export async function createFile(
     nodeContext: IExecuteFunctions,
     binary: IBinaryData,
     fallbackFileName: string
-): Promise<FileMetadata> {
-    let response: FileMetadata;
-    try {
-        response = await callLimeApi<FileMetadata>(nodeContext, {
-            method: 'POST',
-            url: LIME_FILE_URL,
-            requestOptions: {
-                body: Buffer.from(binary.data, BINARY_ENCODING),
-                headers: {
-                    'Content-Disposition': `;filename*="UTF-8''${encodeURIComponent(binary.fileName || fallbackFileName)}"`,
-                    'Content-Type': binary.mimeType,
+): Promise<APIResponse<FileMetadata>> {
+    const response = await callLimeApi<FileMetadata>(nodeContext, {
+        method: 'POST',
+        url: LIME_FILE_URL,
+        requestOptions: {
+            body: Buffer.from(binary.data, BINARY_ENCODING),
+            headers: {
+                'Content-Disposition': `;filename*="UTF-8''${encodeURIComponent(binary.fileName || fallbackFileName)}"`,
+                'Content-Type': binary.mimeType,
+            },
+        },
+    });
+    if (!response.success)
+        return {
+            success: false,
+            data: {
+                error: {
+                    message: response.data.error.message,
+                    status: response.data.error.status,
                 },
             },
-        });
-    } catch (error) {
-        // Remove metadata from the response to reduce its overall size
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            JSON.parse(error).error
-        );
-    }
+        };
 
-    return removeKeys(response, ['_links']);
+    return prepareResponseWithoutKeys(response, ['_links']);
 }

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

@@ -1,7 +1,7 @@
 import { IAllExecuteFunctions } from 'n8n-workflow';
 import { callLimeApi } from './commons';
 import { APIResponsePrimitiveValue } from '../models';
-
+import { APIResponse } from '../../response';
 /**
  * Endpoint path for Lime CRM Lime Query API.
  *
@@ -47,7 +47,7 @@ export interface QueryResponse {
 export async function queryLimeobjects(
     nodeContext: IAllExecuteFunctions,
     q: string
-): Promise<QueryResponse> {
+): Promise<APIResponse<QueryResponse>> {
     const queryParameters = {
         q: q,
     };

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

@@ -1,7 +1,7 @@
-import { callLimeApi, removeKeys } from './commons';
+import { callLimeApi, prepareResponseWithoutKeys } from './commons';
 import { IAllExecuteFunctions } from 'n8n-workflow';
 import { Limeobject } from '../models';
-
+import { APIResponse } from '../../response';
 /**
  * Endpoint path for Lime CRM Limeobject API.
  *
@@ -51,7 +51,7 @@ export async function createLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     data: object
-): Promise<Limeobject> {
+): Promise<APIResponse<Limeobject>> {
     const url = `${LIMEOBJECT_URL}${limetype}/`;
     const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
         method: 'POST',
@@ -63,7 +63,11 @@ export async function createLimeobject(
             limetype: limetype,
         },
     });
-    return removeKeys(response, ['_links']);
+    if (response.success) {
+        return prepareResponseWithoutKeys(response, ['_links']);
+    } else {
+        return response;
+    }
 }
 
 /**
@@ -81,9 +85,9 @@ export async function deleteLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     id: string
-): Promise<void> {
+): Promise<APIResponse<Record<string, never>>> {
     const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    return await callLimeApi(nodeContext, {
+    return await callLimeApi<Record<string, never>>(nodeContext, {
         method: 'DELETE',
         url: url,
         errorMetadata: {
@@ -108,7 +112,7 @@ export async function getLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     id: string
-): Promise<Limeobject> {
+): Promise<APIResponse<Limeobject>> {
     const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
     const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
         method: 'GET',
@@ -118,7 +122,11 @@ export async function getLimeobject(
             id: id,
         },
     });
-    return removeKeys(response, ['_links']);
+    if (response.success) {
+        return prepareResponseWithoutKeys(response, ['_links']);
+    } else {
+        return response;
+    }
 }
 
 /**
@@ -138,7 +146,7 @@ export async function updateLimeobject(
     limetype: string,
     id: string,
     data: object
-): Promise<Limeobject> {
+): Promise<APIResponse<Limeobject>> {
     const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
     const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
         method: 'PUT',
@@ -151,5 +159,9 @@ export async function updateLimeobject(
             id: id,
         },
     });
-    return removeKeys(response, ['_links']);
+    if (response.success) {
+        return prepareResponseWithoutKeys(response, ['_links']);
+    } else {
+        return response;
+    }
 }