@limetech/n8n-nodes-lime 0.3.3 → 0.3.5

package/nodes/fortnox/resources/customers/operations/delete.operation.ts

@@ -37,8 +37,18 @@ export async function execute(
     ) as string;
 
     const endpoint = `/customers/${encodeURIComponent(customerNumber)}`;
-    return await apiRequest<null>(this, {
+    const response = await apiRequest<null>(this, {
         method: 'DELETE',
         endpoint,
     });
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            id: customerNumber,
+        },
+    };
 }

package/nodes/fortnox/resources/customers/operations/get.operation.ts

@@ -38,8 +38,18 @@ export async function execute(
     ) as string;
 
     const endpoint = `/customers/${encodeURIComponent(customerNumber)}`;
-    return await apiRequest<CustomerResponse>(this, {
+    const response = await apiRequest<CustomerResponse>(this, {
         method: 'GET',
         endpoint,
     });
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            id: customerNumber,
+        },
+    };
 }

package/nodes/fortnox/resources/customers/operations/getAll.operation.ts

@@ -75,6 +75,6 @@ export async function execute(
     return await apiRequest<CustomersResponse>(this, {
         method: 'GET',
         endpoint: endpoint,
-        qs,
+        qs: qs,
     });
 }

package/nodes/fortnox/resources/customers/operations/update.operation.ts

@@ -270,9 +270,19 @@ export async function execute(
 
     const endpoint = `/customers/${encodeURIComponent(customerNumber)}`;
 
-    return await apiRequest<CustomerResponse>(this, {
+    const response = await apiRequest<CustomerResponse>(this, {
         method: 'PUT',
         endpoint: endpoint,
         body: body,
     });
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            id: customerNumber,
+        },
+    };
 }

package/nodes/fortnox/resources/invoice/operations/get.operation.ts

@@ -38,8 +38,18 @@ export async function execute(
 
     const endpoint = `invoices/${encodeURIComponent(documentNumber)}`;
 
-    return await apiRequest<GetInvoiceResponse>(this, {
+    const response = await apiRequest<GetInvoiceResponse>(this, {
         method: 'GET',
         endpoint: endpoint,
     });
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            id: documentNumber,
+        },
+    };
 }

package/nodes/fortnox/resources/invoice/operations/getAll.operation.ts

@@ -96,6 +96,6 @@ export async function execute(
     return await apiRequest<GetAllInvoicesResponse>(this, {
         method: 'GET',
         endpoint: endpoint,
-        qs,
+        qs: qs,
     });
 }

package/nodes/fortnox/resources/invoice/operations/update.operation.ts

@@ -66,9 +66,19 @@ export async function execute(
 
     const endpoint = `invoices/${encodeURIComponent(documentNumber)}`;
 
-    return await apiRequest<CreateInvoiceResponse>(this, {
+    const response = await apiRequest<CreateInvoiceResponse>(this, {
         method: 'PUT',
         endpoint: endpoint,
         body: body,
     });
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            id: documentNumber,
+        },
+    };
 }

package/nodes/fortnox/transport/index.ts

@@ -93,6 +93,11 @@ export async function apiRequest<T>(
             success: false,
             error: message,
             status: error?.cause?.status,
+            metadata: {
+                qs: options?.qs,
+                body: options?.body,
+                timeout: options?.timeout,
+            },
         };
     }
 }

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

@@ -14,6 +14,7 @@ export interface Webhook {
     events: string[];
     url?: string;
     context: WebhookContext;
+    name: string;
 }
 
 function _getEvents(hookData: WebhookFunctions): string[] {
@@ -46,5 +47,6 @@ export function getWebhook(hookData: WebhookFunctions): Webhook {
         events: _getEvents(hookData),
         url: hookData.getNodeWebhookUrl('default'),
         context: context,
+        name: hookData.getNodeParameter('name') as string,
     };
 }

package/nodes/lime-crm/resources/limeObject/operations/search.operation.ts

@@ -27,8 +27,6 @@ export const properties: INodeProperties[] = [
             },
         },
     },
-
-    // Search parameters
     {
         displayName: 'Search Term',
         name: 'searchTerm',
@@ -42,8 +40,6 @@ export const properties: INodeProperties[] = [
             },
         },
     },
-
-    // Search fields
     {
         displayName: 'Search Fields',
         name: 'searchField',
@@ -62,7 +58,6 @@ export const properties: INodeProperties[] = [
             },
         },
     },
-
     {
         displayName: 'Limit',
         name: 'limit',
@@ -79,6 +74,22 @@ export const properties: INodeProperties[] = [
             },
         },
     },
+    {
+        displayName: 'Offset',
+        name: 'offset',
+        type: 'number',
+        default: 0,
+        description: 'Offset to first object to return',
+        typeOptions: {
+            minValue: 0,
+        },
+        displayOptions: {
+            show: {
+                resource: [LIMEOBJECT_RESOURCE],
+                operation: ['search'],
+            },
+        },
+    },
 ];
 
 export async function execute(this: IExecuteFunctions, i: number) {
@@ -86,6 +97,7 @@ export async function execute(this: IExecuteFunctions, i: number) {
     const searchTerm = this.getNodeParameter('searchTerm', i, '') as string;
     const searchField = this.getNodeParameter('searchField', i) as string;
     const limit = this.getNodeParameter('limit', i, 50);
+    const offset = this.getNodeParameter('offset', i, 0) as number;
     const options = this.getNodeParameter('options', i, {});
 
     return await searchLimeObject(
@@ -93,7 +105,8 @@ export async function execute(this: IExecuteFunctions, i: number) {
         limeType,
         searchField,
         searchTerm,
-        limit || null,
+        limit,
+        offset,
         (options.sortField as string) || null
     );
 }

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

@@ -15,7 +15,7 @@ export async function callLimeApi<T>(
     nodeContext: IAllExecuteFunctions,
     method: HTTPMethod,
     url: string,
-    options?: object
+    options?: Record<string, unknown>
 ): Promise<NodeResponse<T>> {
     try {
         const response: T =
@@ -39,6 +39,7 @@ export async function callLimeApi<T>(
             success: false,
             error: error instanceof Error ? error.message : String(error),
             status: error?.cause?.status,
+            metadata: options,
         };
     }
 }

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

@@ -1,5 +1,5 @@
 import { callLimeApi } from './commons';
-import { IAllExecuteFunctions } from 'n8n-workflow';
+import { IAllExecuteFunctions, IDataObject } from 'n8n-workflow';
 import { NodeResponse } from '../../nodeResponse';
 
 const LIMEOBJECT_URL = '/api/v1/limeobject/';
@@ -12,66 +12,172 @@ interface SearchLimeobjectApiResponse {
 
 export async function createLimeObject(
     nodeContext: IAllExecuteFunctions,
-    limetype: string,
+    limeType: string,
     data: object
 ): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limetype}/`;
-    return await callLimeApi(nodeContext, 'POST', url, {
+    const url = `${LIMEOBJECT_URL}${limeType}/`;
+    const response = await callLimeApi(nodeContext, 'POST', url, {
         body: data,
     });
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limeType: limeType,
+        },
+    };
 }
 
 export async function deleteLimeObject(
     nodeContext: IAllExecuteFunctions,
-    limetype: string,
+    limeType: string,
     id: string
 ): Promise<NodeResponse<void>> {
-    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    return await callLimeApi(nodeContext, 'DELETE', url);
+    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
+    const response: NodeResponse<void> = await callLimeApi(
+        nodeContext,
+        'DELETE',
+        url
+    );
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limeType: limeType,
+            id: id,
+        },
+    };
 }
 
 export async function getLimeObject(
     nodeContext: IAllExecuteFunctions,
-    limetype: string,
+    limeType: string,
     id: string
 ): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    return await callLimeApi(nodeContext, 'GET', url);
+    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
+    const response = await callLimeApi(nodeContext, 'GET', url);
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limeType: limeType,
+            id: id,
+        },
+    };
 }
 
 export async function updateLimeObject(
     nodeContext: IAllExecuteFunctions,
-    limetype: string,
+    limeType: string,
     id: string,
     data: object
 ): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    return await callLimeApi(nodeContext, 'PUT', url, {
+    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
+    const response = await callLimeApi(nodeContext, 'PUT', url, {
         body: data,
     });
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limeType: limeType,
+            id: id,
+        },
+    };
+}
+
+async function _searchLimeObjectWithLimit(
+    nodeContext: IAllExecuteFunctions,
+    url: string,
+    limit: number,
+    offset: number,
+    qs: IDataObject
+): Promise<NodeResponse<SearchLimeobjectApiResponse>> {
+    const returnData = [];
+    let hasMoreData = true;
+    let currentOffset = Math.max(0, offset);
+    const pageLimit = 50;
+
+    while (hasMoreData) {
+        qs._limit = Math.min(limit, pageLimit);
+        qs._offset = currentOffset;
+
+        const response = await callLimeApi<SearchLimeobjectApiResponse>(
+            nodeContext,
+            'GET',
+            url,
+            {
+                qs: qs,
+            }
+        );
+        if (!response.success) return response;
+
+        const items = response.data._embedded?.limeobjects || [];
+
+        if (items.length === 0) {
+            hasMoreData = false;
+        } else {
+            returnData.push(...items);
+            currentOffset += items.length;
+            limit -= items.length;
+
+            if (limit <= 0) {
+                hasMoreData = false;
+            }
+        }
+    }
+    return {
+        success: true,
+        data: { _embedded: { limeobjects: returnData } },
+    };
 }
 
 export async function searchLimeObject(
     nodeContext: IAllExecuteFunctions,
-    limetype: string,
+    limeType: string,
     searchField: string,
     searchTerm: string,
-    limit: number | null,
+    limit: number,
+    offset: number,
     sortField: string | null
 ): Promise<NodeResponse<Array<object>>> {
-    const url = `${LIMEOBJECT_URL}${limetype}/`;
-    const response = await callLimeApi<SearchLimeobjectApiResponse>(
-        nodeContext,
-        'GET',
-        url,
-        {
-            qs: {
-                ...(searchField && searchTerm && { [searchField]: searchTerm }),
-                ...(limit != null && limit > 0 && { _limit: limit }),
-                ...(sortField != null && { _sort: sortField }),
-            },
-        }
-    );
+    const url = `${LIMEOBJECT_URL}${limeType}/`;
+    const qs: IDataObject = {
+        ...(searchField && searchTerm && { [searchField]: searchTerm }),
+        ...(offset != null && offset > 0 && { _offset: offset }),
+        ...(sortField != null && { _sort: sortField }),
+    };
+
+    let response;
+    if (limit) {
+        response = await _searchLimeObjectWithLimit(
+            nodeContext,
+            url,
+            limit,
+            offset,
+            qs
+        );
+    } else {
+        response = await callLimeApi<SearchLimeobjectApiResponse>(
+            nodeContext,
+            'GET',
+            url,
+            {
+                qs: qs,
+            }
+        );
+    }
 
     if (response.success) {
         return {
@@ -79,5 +185,11 @@ export async function searchLimeObject(
             data: response.data?._embedded.limeobjects ?? [],
         };
     }
-    return response;
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limeType: limeType,
+        },
+    };
 }

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

@@ -39,7 +39,17 @@ export async function getLimeType(
     limeType: string
 ): Promise<NodeResponse<LimeType>> {
     const url = `${LIMETYPE_URL}${limeType}/`;
-    return await callLimeApi<LimeType>(nodeContext, 'GET', url);
+    const response = await callLimeApi<LimeType>(nodeContext, 'GET', url);
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limetype: limeType,
+        },
+    };
 }
 
 export async function getProperties(
@@ -64,5 +74,12 @@ export async function getProperties(
             data: response.data?._embedded.properties ?? [],
         };
     }
-    return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            limetype: limeType,
+        },
+    };
 }

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

@@ -45,6 +45,7 @@ export async function createSubscription(
         body: {
             events: webhook.events,
             target_url: webhook.url,
+            name: webhook.name,
         },
     });
 }
@@ -53,9 +54,19 @@ export async function deleteSubscription(
     nodeContext: IAllExecuteFunctions,
     webhook: Webhook
 ): Promise<NodeResponse<void>> {
-    return await callLimeApi(
+    const response: NodeResponse<void> = await callLimeApi(
         nodeContext,
         'DELETE',
         `${SUBSCRIPTION_URL}${webhook.data.webhookId}/`
     );
+
+    if (response.success) return response;
+
+    return {
+        ...response,
+        metadata: {
+            ...response.metadata,
+            id: webhook.data.webhookId,
+        },
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "n8n node to connect to Lime CRM",
   "license": "MIT",
   "main": "index.js",
@@ -29,7 +29,7 @@
       "dist/credentials/FortnoxApi.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/lime-crm/LimeCrm.node.js",
+      "dist/nodes/lime-crm/LimeCrmNode.node.js",
       "dist/nodes/fortnox/Fortnox.node.js",
       "dist/nodes/fortnox/FortnoxTrigger.node.js"
     ]