@limetech/n8n-nodes-lime 0.3.2 → 0.3.4

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.2",
+  "version": "0.3.4",
   "description": "n8n node to connect to Lime CRM",
   "license": "MIT",
   "main": "index.js",

package/dist/credentials/LimeGoApi.credentials.d.ts

@@ -1,15 +0,0 @@
-import { ICredentialType, INodeProperties } from 'n8n-workflow';
-export declare class LimeGoApi implements ICredentialType {
-    name: string;
-    displayName: string;
-    documentationUrl: string;
-    properties: INodeProperties[];
-    authenticate: {
-        type: "generic";
-        properties: {
-            headers: {
-                Authorization: string;
-            };
-        };
-    };
-}

package/dist/credentials/LimeGoApi.credentials.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LimeGoApi = void 0;
-class LimeGoApi {
-    constructor() {
-        this.name = 'limeGoApi';
-        this.displayName = 'Lime Go API';
-        this.documentationUrl = 'https://api.lime-go.com/docs';
-        this.properties = [
-            {
-                displayName: 'API Key',
-                name: 'apiKey',
-                type: 'string',
-                typeOptions: {
-                    password: true,
-                },
-                default: '',
-                required: true,
-            },
-        ];
-        this.authenticate = {
-            type: 'generic',
-            properties: {
-                headers: {
-                    Authorization: '=go-api:{{$credentials.apiKey}}',
-                },
-            },
-        };
-    }
-}
-exports.LimeGoApi = LimeGoApi;
-//# sourceMappingURL=LimeGoApi.credentials.js.map

package/dist/credentials/LimeGoApi.credentials.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LimeGoApi.credentials.js","sourceRoot":"","sources":["../../credentials/LimeGoApi.credentials.ts"],"names":[],"mappings":";;;AAKA,MAAa,SAAS;IAAtB;QACI,SAAI,GAAG,WAAW,CAAC;QACnB,gBAAW,GAAG,aAAa,CAAC;QAC5B,qBAAgB,GAAG,8BAA8B,CAAC;QAClD,eAAU,GAAsB;YAC5B;gBACI,WAAW,EAAE,SAAS;gBACtB,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE;oBACT,QAAQ,EAAE,IAAI;iBACjB;gBACD,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;aACjB;SACJ,CAAC;QAEF,iBAAY,GAAG;YACX,IAAI,EAAE,SAAsB;YAC5B,UAAU,EAAE;gBACR,OAAO,EAAE;oBACL,aAAa,EAAE,iCAAiC;iBACnD;aACJ;SACJ,CAAC;IACN,CAAC;CAAA;AAzBD,8BAyBC"}

package/dist/nodes/LimeCrm/GenericTypes.d.ts

@@ -1,80 +0,0 @@
-import { IDataObject } from 'n8n-workflow';
-export interface IOperationParams {
-    operation: string;
-    i: number;
-}
-export interface ILimeCrmResponse {
-    [key: string]: any;
-}
-export interface ILimeTypeObject {
-    id?: number | string;
-    [key: string]: any;
-}
-export interface IWebhookObject {
-    name: string;
-    events: string[];
-    target_url: string;
-    enabled: boolean;
-    headers?: Array<{
-        name: string;
-        value: string;
-        secret_value?: string;
-        type: string;
-    }>;
-    secret?: string;
-}
-export interface IWebhookEventData {
-    event: string;
-    body: {
-        id: string;
-        values: IDataObject;
-        [key: string]: any;
-    };
-    [key: string]: any;
-}
-export interface ILimeTypeResponse {
-    _embedded?: {
-        properties?: ILimeTypeProperty[];
-    };
-    _links?: {
-        limetypes?: ILimeTypeLink[];
-    };
-}
-export interface ILimeTypeLink {
-    name: string;
-    href: string;
-}
-export interface ILimeTypeProperty {
-    id: string;
-    name: string;
-    localizedname: string;
-    propertytype: string;
-    readonly: boolean;
-    required: boolean;
-    [key: string]: any;
-}
-export interface ILimeObjectResponse {
-    _embedded?: {
-        limeobjects?: ILimeObject[];
-    };
-    _links?: {
-        next?: {
-            href: string;
-        };
-        self?: {
-            href: string;
-        };
-    };
-}
-export interface ILimeObject {
-    id: string;
-    [key: string]: any;
-}
-export interface IQueryParams {
-    _limit?: number;
-    _offset?: number;
-    _sort?: string;
-    [key: string]: any;
-}
-export declare class GenericTypes {
-}

package/dist/nodes/LimeCrm/GenericTypes.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GenericTypes = void 0;
-class GenericTypes {
-}
-exports.GenericTypes = GenericTypes;
-//# sourceMappingURL=GenericTypes.js.map

package/dist/nodes/LimeCrm/GenericTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GenericTypes.js","sourceRoot":"","sources":["../../../nodes/LimeCrm/GenericTypes.ts"],"names":[],"mappings":";;;AAiHA,MAAa,YAAY;CAAI;AAA7B,oCAA6B"}

package/dist/nodes/LimeCrm/LimeCrmNode.node.d.ts

@@ -1,17 +0,0 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
-import { getLimeTypes, getLimeTypeProperties, getLimeTypeRelations, getRelatedTypeProperties, getAllSortableFields } from './methods';
-import { LimeCrmTrigger } from './LimeCrmTrigger/LimeCrmTrigger.node';
-export declare class LimeCrmNode implements INodeType {
-    description: INodeTypeDescription;
-    methods: {
-        loadOptions: {
-            getLimeTypes: typeof getLimeTypes;
-            getLimeTypeProperties: typeof getLimeTypeProperties;
-            getLimeTypeRelations: typeof getLimeTypeRelations;
-            getRelatedTypeProperties: typeof getRelatedTypeProperties;
-            getAllSortableFields: typeof getAllSortableFields;
-        };
-    };
-    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
-}
-export { LimeCrmTrigger };