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

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}/`,

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

@@ -5,7 +5,7 @@ import {
     LoggerProxy as Logger,
 } from 'n8n-workflow';
 import { createFile, getFileContent, getFileMetadata } from '../transport';
-import { FileResponse } from '../../response';
+import { APIResponse, FileAPIResponse } from '../../response';
 import { LimetypeProperty } from '../models';
 
 /**
@@ -121,7 +121,7 @@ export async function setFileProperties(
     i: number,
     fileProperties: Set<string>,
     definedProperties: IDataObject
-): Promise<IDataObject> {
+): Promise<APIResponse<IDataObject>> {
     for (const fileProperty of fileProperties) {
         if (!(fileProperty in definedProperties)) continue;
         let binaryData: IBinaryData;
@@ -146,9 +146,14 @@ export async function setFileProperties(
             definedProperties[fileProperty] as string
         );
 
-        definedProperties[fileProperty] = response.id;
+        if (response.success) {
+            definedProperties[fileProperty] = response.data.id;
+        } else return response;
     }
-    return definedProperties;
+    return {
+        success: true,
+        data: definedProperties,
+    };
 }
 
 /**
@@ -159,7 +164,7 @@ export async function setFileProperties(
  * @param data - The record data containing property values to process
  * @param includeFileContent - Whether to include the actual file content in the response. Defaults to `false`
  *
- * @returns A {@link FileResponse} object containing updated JSON data and, if requested, the associated binary files.
+ * @returns A {@link FileAPIResponse} object containing updated JSON data and, if requested, the associated binary files.
  *
  * @public
  * @group Utils
@@ -169,7 +174,7 @@ export async function processFileResponse<T extends Record<string, unknown>>(
     fileProperties: Set<string>,
     data: T,
     includeFileContent: boolean = false
-): Promise<FileResponse<T>> {
+): Promise<FileAPIResponse<T>> {
     let updatedData = { ...data };
     const binaryData: Record<string, IBinaryData> = {};
     for (const fileProperty of fileProperties) {
@@ -178,21 +183,33 @@ export async function processFileResponse<T extends Record<string, unknown>>(
             nodeContext,
             data[fileProperty] as string
         );
+        if (!fileMetadataResponse.success)
+            return {
+                json: fileMetadataResponse,
+            };
 
         updatedData = {
             ...updatedData,
-            [fileProperty]: fileMetadataResponse,
+            [fileProperty]: fileMetadataResponse.data,
         };
 
         if (includeFileContent) {
-            binaryData[fileProperty] = await getFileContent(
+            const fileContentResponse = await getFileContent(
                 nodeContext,
-                fileMetadataResponse.id
+                fileMetadataResponse.data.id
             );
+            if (fileContentResponse.success) {
+                binaryData[fileProperty] = fileContentResponse.data;
+            } else {
+                return { json: fileContentResponse };
+            }
         }
     }
     return {
-        json: updatedData,
+        json: {
+            success: true,
+            data: updatedData,
+        },
         binary: binaryData,
     };
 }

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

@@ -7,4 +7,4 @@ export {
 } from './files';
 export { verifyHmac } from './hmac';
 export { getWebhook } from './webhook';
-export { adaptProperty, getPropertyType } from './propertyAdapters';
+export { handleWorkflowError, WorkflowErrorContext } from '../../errorHandling';

package/nodes/response.ts

@@ -1,16 +1,54 @@
 import { IBinaryData } from 'n8n-workflow';
+import { ErrorResponse, WorkflowErrorContext } from './errorHandling';
+
+/**
+ * Wrapper for successful response
+ */
+export type SuccessResponse<T> = {
+    success: true;
+    data: T;
+};
+
+/**
+ * Generic wrapper used for describing the data we are returning from workflow
+ * execution for the user
+ */
+export type WorkflowResponse<T> = T | { error: WorkflowErrorContext };
+
+/**
+ * Generic wrapper used for describing the data we are getting from the
+ * external API layer
+ */
+export type APIResponse<T> = SuccessResponse<T> | ErrorResponse;
+
+/**
+ * Response object that includes both JSON data and optional binary file content.
+ * Works in communication layer
+ *
+ * @typeParam T - The shape of the JSON data returned in the response
+ * @property json -  The {@link APIResponse} object, containing structured JSON data.
+ * @property binary - An optional record of binary file data
+ *
+ * @public
+ * @group Response
+ */
+export type FileAPIResponse<T> = {
+    json: APIResponse<T>;
+    binary?: Record<string, IBinaryData>;
+};
 
 /**
  * Response object that includes both JSON data and optional binary file content.
+ * Works in user interface layer
  *
  * @typeParam T - The shape of the JSON data returned in the response
- * @property json -  The n8n node response, containing structured JSON data.
+ * @property json -  The {@link WorflowResponse} object, containing structured JSON data.
  * @property binary - An optional record of binary file data
  *
  * @public
  * @group Response
  */
-export type FileResponse<T> = {
-    json: T;
+export type WorkflowFileResponse<T> = {
+    json: WorkflowResponse<T>;
     binary?: Record<string, IBinaryData>;
 };

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "2.3.1-dev.1",
+  "version": "2.5.0-dev.2",
   "description": "n8n node to connect to Lime CRM",
-  "license": "MIT",
   "main": "nodes/index.ts",
   "scripts": {
     "build": "tsc && copyfiles \"nodes/**/*.svg\" dist",
@@ -63,5 +62,8 @@
   },
   "peerDependencies": {
     "n8n-workflow": "^1.109.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/tests/nodes/lime-crm/methods.spec.ts

@@ -0,0 +1,91 @@
+import {
+    getCreateMappingColumns,
+    getUpdateMappingColumns,
+    LimetypeProperty,
+    SuccessResponse,
+} from '../../../nodes';
+import { ILoadOptionsFunctions } from 'n8n-workflow';
+import * as transport from '../../../nodes/lime-crm/transport';
+
+const mockILoadOptionFunctions = {
+    getNodeParameter: jest.fn().mockReturnValue('company'),
+} as unknown as ILoadOptionsFunctions;
+
+const propertiesResponseMock = {
+    success: true,
+    data: [
+        { name: 'p1', localname: 'Property 1', type: 'yesno', required: true },
+        {
+            name: 'p2',
+            localname: 'Property 2',
+            type: 'string',
+            required: false,
+            length: 2137,
+        },
+        {
+            name: 'p3',
+            localname: 'Property 3',
+            type: 'option',
+            required: true,
+            options: [
+                { key: 'op1', text: 'Option 1', inactive: false },
+                { key: 'op2', text: 'Option 2', inactive: false },
+                { key: 'op3', text: 'Option 3', inactive: true },
+            ],
+        },
+    ],
+} as SuccessResponse<LimetypeProperty[]>;
+
+describe('resourceMapping', () => {
+    beforeEach(() => {
+        jest.spyOn(transport, 'getProperties').mockResolvedValue(
+            propertiesResponseMock
+        );
+    });
+    it('gets valid resource mapping for create', async () => {
+        const columns = await getCreateMappingColumns.call(
+            mockILoadOptionFunctions
+        );
+        const property1 = columns.fields.find((p) => p.id == 'p1')!;
+
+        expect(property1.displayName).toBe('Property 1 [yesno]');
+        expect(property1.required).toBe(true);
+        expect(property1.defaultMatch).toBe(false);
+        expect(property1.display).toBe(true);
+        expect(property1.type).toBe('boolean');
+        expect(property1.options).toBe(undefined);
+
+        const property2 = columns.fields.find((p) => p.id == 'p2')!;
+        expect(property2.displayName).toBe('Property 2 [string(2137)]');
+        expect(property2.required).toBe(false);
+        expect(property2.defaultMatch).toBe(false);
+        expect(property2.display).toBe(true);
+        expect(property2.type).toBe('string');
+        expect(property2.options).toBe(undefined);
+
+        const property3 = columns.fields.find((p) => p.id == 'p3')!;
+        expect(property3.displayName).toBe('Property 3 [option]');
+        expect(property3.required).toBe(true);
+        expect(property3.defaultMatch).toBe(false);
+        expect(property3.display).toBe(true);
+        expect(property3.type).toBe('options');
+
+        const options = property3.options!;
+        expect(options).toContainEqual({
+            value: 'op1',
+            name: 'Option 1',
+        });
+        expect(options).toContainEqual({
+            value: 'op2',
+            name: 'Option 2',
+        });
+        expect(options.length).toBe(2);
+    });
+    it('gets proper required values for update', async () => {
+        const columns = await getUpdateMappingColumns.call(
+            mockILoadOptionFunctions
+        );
+        const requiredValues = columns.fields.map((p) => p.required);
+        expect(requiredValues).toEqual([false, false, false]);
+    });
+});