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

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

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

@@ -2,6 +2,7 @@ import { callLimeApi } from '.';
 import { IAllExecuteFunctions } from 'n8n-workflow';
 import { removeKeys } from './commons';
 import { Limetype, LimetypeProperty } from '../models';
+import { APIResponse } from '../../response';
 
 /**
  * Endpoint path for Lime CRM Limetype API.
@@ -113,7 +114,7 @@ function deserializeLimetype(limetype: LimetypeCrmApiResponse): Limetype {
  */
 export async function getLimetypesFromApi(
     nodeContext: IAllExecuteFunctions
-): Promise<Limetype[]> {
+): Promise<APIResponse<Limetype[]>> {
     const response = await callLimeApi<LimetypesCrmApiResponse>(nodeContext, {
         method: 'GET',
         url: LIMETYPE_URL,
@@ -123,7 +124,16 @@ export async function getLimetypesFromApi(
             },
         },
     });
-    return response._embedded?.limetypes.map(deserializeLimetype) || [];
+    if (response.success) {
+        return {
+            success: true,
+            data:
+                response.data._embedded?.limetypes.map(deserializeLimetype) ||
+                [],
+        };
+    } else {
+        return response;
+    }
 }
 
 /**
@@ -139,7 +149,7 @@ export async function getLimetypesFromApi(
 export async function getLimetype(
     nodeContext: IAllExecuteFunctions,
     limetype: string
-): Promise<Limetype> {
+): Promise<APIResponse<Limetype>> {
     const url = `${LIMETYPE_URL}${limetype}/`;
     const response = await callLimeApi<LimetypeCrmApiResponse>(nodeContext, {
         method: 'GET',
@@ -150,8 +160,14 @@ export async function getLimetype(
             },
         },
     });
-
-    return deserializeLimetype(response);
+    if (response.success) {
+        return {
+            success: true,
+            data: deserializeLimetype(response.data),
+        };
+    } else {
+        return response;
+    }
 }
 
 /**
@@ -167,7 +183,7 @@ export async function getLimetype(
 export async function getProperties(
     nodeContext: IAllExecuteFunctions,
     limetype: string
-): Promise<LimetypeProperty[]> {
+): Promise<APIResponse<LimetypeProperty[]>> {
     const url = `${LIMETYPE_URL}${limetype}/`;
     const response = await callLimeApi<LimetypePropertiesApiResponse>(
         nodeContext,
@@ -184,14 +200,19 @@ export async function getProperties(
             },
         }
     );
-
-    return (
-        response._embedded.properties.map(
-            (property) =>
-                removeKeys(property, [
-                    '_links',
-                    '_embedded',
-                ]) as LimetypeProperty
-        ) || []
-    );
+    if (response.success) {
+        return {
+            success: true,
+            data:
+                response.data._embedded.properties.map(
+                    (property) =>
+                        removeKeys(property, [
+                            '_links',
+                            '_embedded',
+                        ]) as LimetypeProperty
+                ) || [],
+        };
+    } else {
+        return response;
+    }
 }

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

@@ -2,7 +2,7 @@ import { callLimeApi } from './commons';
 import {
     IAllExecuteFunctions,
     LoggerProxy as Logger,
-    NodeOperationError,
+    NodeApiError,
 } from 'n8n-workflow';
 import {
     User,
@@ -14,7 +14,8 @@ import {
 import { getLimetypesFromApi } from './limetypes';
 import { queryLimeobjects, QueryResponse } from './limeQuery';
 import { getLimeobject } from './limeobjects';
-
+import { APIResponse } from '../../response';
+import { handleWorkflowError } from '../../errorHandling';
 const USERS_URL = 'api/v1/admin/users/';
 
 type UserQueryParameters = {
@@ -49,21 +50,30 @@ function findCoworkerLimetype(limetypes: Limetype[]): Limetype | undefined {
  *
  * @param nodeContext - The n8n execution context
  * @returns The coworker limetype object
- * @throws NodeOperationError if no coworker limetype is found
+ * @throws NodeApiError if no coworker limetype is found
  * @internal
  */
 async function findCoworker(
     nodeContext: IAllExecuteFunctions
-): Promise<Limetype> {
+): Promise<APIResponse<Limetype>> {
     const response = await getLimetypesFromApi(nodeContext);
-    const coworker = findCoworkerLimetype(response);
+    if (!response.success) {
+        return response;
+    }
+    const coworker = findCoworkerLimetype(response.data);
     if (!coworker) {
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            `No limetype with 'user' property found to get coworker`
+        return handleWorkflowError(
+            nodeContext,
+            {
+                message: `No limetype with 'user' property found to get coworker`,
+            },
+            true
         );
     }
-    return coworker;
+    return {
+        success: true,
+        data: coworker,
+    };
 }
 
 /**
@@ -73,14 +83,14 @@ async function findCoworker(
  * @param coworker - The limetype definition for the coworker
  * @param userId - The ID of the user whose coworker data is to be fetched
  * @returns The coworker data response from the Lime Query API
- * @throws NodeOperationError if no 'user' property is found in the coworker limetype
+ * @throws NodeApiError' property is found in the coworker limetype
  * @internal
  */
 async function getCoworker(
     nodeContext: IAllExecuteFunctions,
     coworker: Limetype,
     userId: string | number
-): Promise<QueryResponse> {
+): Promise<APIResponse<QueryResponse>> {
     // 'hasmany' properties are not supported in the response format of Lime Query API
     const properties = Object.fromEntries(
         coworker.properties
@@ -92,10 +102,9 @@ async function getCoworker(
         (prop) => prop.type === 'user'
     );
     if (!userProperty) {
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            `No property of type 'user' found in ${coworker.name} limetype`
-        );
+        throw new NodeApiError(nodeContext.getNode(), {
+            message: `No property of type 'user' found in ${coworker.name} limetype`,
+        });
     }
 
     const responseFormat = {
@@ -135,7 +144,7 @@ export async function fetchManyUsers(
     userType: UserType | NullOptionType = '',
     limit: number = DEFAULT_API_OBJECT_LIMIT,
     withCoworker: boolean = false
-): Promise<User[]> {
+): Promise<APIResponse<User[]>> {
     const queryParams: UserQueryParameters = {
         _limit: limit,
     };
@@ -154,23 +163,31 @@ export async function fetchManyUsers(
         },
     });
 
-    if (!withCoworker) return response;
-    const coworker = await findCoworker(nodeContext);
+    if (!response.success || !withCoworker) return response;
+
+    const coworkerLimetypeResponse = await findCoworker(nodeContext);
+    if (!coworkerLimetypeResponse.success) return coworkerLimetypeResponse;
+
+    const coworkerLimetype = coworkerLimetypeResponse.data;
 
     const usersWithCoworkers: User[] = [];
-    for (const user of response) {
+    for (const user of response.data) {
         const coworkerResponse = await getCoworker(
             nodeContext,
-            coworker,
+            coworkerLimetype,
             user.id
         );
+        if (!coworkerResponse.success) return coworkerResponse;
         usersWithCoworkers.push({
             ...user,
-            [coworker.name]: coworkerResponse.objects[0] || null,
+            [coworkerLimetype.name]: coworkerResponse.data.objects[0] || null,
         });
     }
 
-    return usersWithCoworkers;
+    return {
+        success: true,
+        data: usersWithCoworkers,
+    };
 }
 
 /**
@@ -189,7 +206,7 @@ export async function fetchSingleUserById(
     nodeContext: IAllExecuteFunctions,
     id: string,
     withCoworker: boolean = false
-): Promise<User> {
+): Promise<APIResponse<User>> {
     const url = `${USERS_URL}${id}`;
     const userResponse = await callLimeApi<User>(nodeContext, {
         method: 'GET',
@@ -199,13 +216,21 @@ export async function fetchSingleUserById(
         },
     });
 
-    if (!withCoworker) return userResponse;
-    const coworker = await findCoworker(nodeContext);
-    const coworkerResponse = await getCoworker(nodeContext, coworker, id);
+    if (!userResponse.success || !withCoworker) return userResponse;
+    const coworkerLimetypeResponse = await findCoworker(nodeContext);
+    if (!coworkerLimetypeResponse.success) return coworkerLimetypeResponse;
+
+    const coworkerResponse = await getCoworker(
+        nodeContext,
+        coworkerLimetypeResponse.data,
+        id
+    );
+    if (!coworkerResponse.success) return coworkerResponse;
 
     return {
         ...userResponse,
-        [coworker.name]: coworkerResponse.objects[0] || null,
+        [coworkerLimetypeResponse.data.name]:
+            coworkerResponse.data.objects[0] || null,
     };
 }
 
@@ -228,25 +253,33 @@ export async function fetchSingleUserByLimeobjectId(
     nodeContext: IAllExecuteFunctions,
     id: string,
     withCoworker: boolean = false
-): Promise<User> {
-    const coworker = await findCoworker(nodeContext);
+): Promise<APIResponse<User>> {
+    const coworkerLimetypeResponse = await findCoworker(nodeContext);
+    if (!coworkerLimetypeResponse.success) return coworkerLimetypeResponse;
+
+    const coworkerLimetype = coworkerLimetypeResponse.data;
+
     const coworkerResponse = await getLimeobject(
         nodeContext,
-        coworker.name,
+        coworkerLimetype.name,
         id
     );
+    if (!coworkerResponse.success) return coworkerResponse;
 
-    const userProperty = coworker.properties.find(
+    const userProperty = coworkerLimetype.properties.find(
         (prop) => prop.type === 'user'
     );
     if (!userProperty) {
-        throw new NodeOperationError(
-            nodeContext.getNode(),
-            `No property of type 'user' found in ${coworker.name} limetype`
+        return handleWorkflowError(
+            nodeContext,
+            {
+                message: `No property of type 'user' found in ${coworkerLimetype.name} limetype`,
+            },
+            true
         );
     }
 
-    const url = `${USERS_URL}${coworkerResponse[userProperty.name]}`;
+    const url = `${USERS_URL}${coworkerResponse.data[userProperty.name]}`;
     const userResponse = await callLimeApi<User>(nodeContext, {
         method: 'GET',
         url: url,
@@ -255,10 +288,13 @@ export async function fetchSingleUserByLimeobjectId(
         },
     });
 
-    if (!withCoworker) return userResponse;
+    if (!userResponse.success || !withCoworker) return userResponse;
 
     return {
-        ...userResponse,
-        [coworker.name]: coworkerResponse || null,
+        success: true,
+        data: {
+            ...userResponse.data,
+            [coworkerLimetype.name]: coworkerResponse.data || null,
+        },
     };
 }

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

@@ -1,6 +1,7 @@
 import { callLimeApi } from '.';
 import { IAllExecuteFunctions } from 'n8n-workflow';
 import { CreateWebhook, Webhook } from '../models';
+import { APIResponse } from '../../response';
 
 /**
  * Endpoint path for Lime CRM Subscription API.
@@ -44,7 +45,7 @@ export interface ApiResponseWebhook {
 export async function getSubscription(
     nodeContext: IAllExecuteFunctions,
     webhook: Webhook
-): Promise<ApiResponseWebhook> {
+): Promise<APIResponse<ApiResponseWebhook>> {
     return await callLimeApi(nodeContext, {
         method: 'GET',
         url: `${SUBSCRIPTION_URL}${webhook.data.webhookId}`,
@@ -65,7 +66,7 @@ export async function getSubscription(
 export async function listSubscriptionsWithExistingData(
     nodeContext: IAllExecuteFunctions,
     webhook: Webhook
-): Promise<ApiResponseWebhook[]> {
+): Promise<APIResponse<ApiResponseWebhook[]>> {
     return await callLimeApi(nodeContext, {
         method: 'GET',
         url: SUBSCRIPTION_URL,
@@ -93,7 +94,7 @@ export async function listSubscriptionsWithExistingData(
 export async function createSubscription(
     nodeContext: IAllExecuteFunctions,
     webhook: CreateWebhook
-): Promise<ApiResponseWebhook> {
+): Promise<APIResponse<ApiResponseWebhook>> {
     return await callLimeApi(nodeContext, {
         method: 'POST',
         url: SUBSCRIPTION_URL,
@@ -122,7 +123,7 @@ export async function createSubscription(
 export async function deleteSubscription(
     nodeContext: IAllExecuteFunctions,
     webhook: Webhook
-): Promise<void> {
+): Promise<APIResponse<void>> {
     return await callLimeApi(nodeContext, {
         method: 'DELETE',
         url: `${SUBSCRIPTION_URL}${webhook.data.webhookId}/`,