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

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

@@ -3,7 +3,6 @@ import { apiRequest } from '../../../transport';
 import { filterParameters } from '../filterParameters';
 import { sortParameters } from '../sortParameters';
 import { CustomersResponse } from '../model';
-import { NodeResponse } from '../../../../nodeResponse';
 
 export const description = {
     name: 'Get All Customers',
@@ -46,7 +45,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<NodeResponse<CustomersResponse>> {
+): Promise<CustomersResponse> {
     const filterParameters = this.getNodeParameter('filterParameters', i, {});
     const sortParameters = this.getNodeParameter(
         'sortParameters',

package/nodes/fortnox/resources/customers/operations/index.ts

@@ -0,0 +1,5 @@
+export * as createSingleCustomer from './create.operation';
+export * as deleteSingleCustomer from './delete.operation';
+export * as getSingleCustomer from './get.operation';
+export * as getManyCustomers from './getAll.operation';
+export * as updateSingleCustomer from './update.operation';

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

@@ -1,8 +1,12 @@
-import { IExecuteFunctions, INodeProperties, IDataObject } from 'n8n-workflow';
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    IDataObject,
+    NodeOperationError,
+} from 'n8n-workflow';
 import { apiRequest } from '../../../transport';
 import { CustomerResponse } from '../model';
 import { code as currencyCode } from 'currency-codes';
-import { NodeResponse } from '../../../../nodeResponse';
 
 export const description = {
     name: 'Update Customer',
@@ -11,7 +15,7 @@ export const description = {
     action: 'Update a customer',
 };
 
-export const updateProperties: INodeProperties[] = [
+const updateProperties: INodeProperties[] = [
     {
         displayName: 'Name',
         name: 'Name',
@@ -234,31 +238,31 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<NodeResponse<CustomerResponse>> {
+): Promise<CustomerResponse> {
     const customerNumber = this.getNodeParameter('customerNumber', i) as string;
     const fields = this.getNodeParameter('fields', i, {}) as IDataObject;
 
     if (Object.keys(fields).length === 0) {
-        return {
-            success: false,
-            error: 'At least one field must be provided for update',
-        };
+        throw new NodeOperationError(
+            this.getNode(),
+            'At least one field must be provided for update'
+        );
     }
 
     if (fields.name && fields.name === '') {
-        return {
-            success: false,
-            error: 'Customer name cannot be empty',
-        };
+        throw new NodeOperationError(
+            this.getNode(),
+            'Customer name cannot be empty'
+        );
     }
 
     if (fields.Currency) {
         fields.Currency = String(fields.Currency).toUpperCase();
         if (currencyCode(fields.Currency) === undefined) {
-            return {
-                success: false,
-                error: `Invalid currency code: ${fields.Currency}. Use ISO 4217 currency code.`,
-            };
+            throw new NodeOperationError(
+                this.getNode(),
+                `Invalid currency code: ${fields.Currency}. Use ISO 4217 currency code.`
+            );
         }
     }
 
@@ -270,19 +274,15 @@ export async function execute(
 
     const endpoint = `/customers/${encodeURIComponent(customerNumber)}`;
 
-    const response = await apiRequest<CustomerResponse>(this, {
-        method: 'PUT',
-        endpoint: endpoint,
-        body: body,
-    });
-
-    if (response.success) return response;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            id: customerNumber,
+    return await apiRequest<CustomerResponse>(
+        this,
+        {
+            method: 'PUT',
+            endpoint: endpoint,
+            body: body,
         },
-    };
+        {
+            id: customerNumber,
+        }
+    );
 }

package/nodes/fortnox/resources/invoice/index.ts

@@ -4,10 +4,15 @@ import {
     NodePropertyTypes,
 } from 'n8n-workflow';
 
-import * as create from './operations/create.operation';
-import * as get from './operations/get.operation';
-import * as getAll from './operations/getAll.operation';
-import * as update from './operations/update.operation';
+import * as operations from './operations';
+import { N8NOperationModuleHandler } from '../../../modules';
+
+const moduleHandler = new N8NOperationModuleHandler([
+    operations.createSingleInvoice,
+    operations.getManyInvoices,
+    operations.getSingleInvoice,
+    operations.updateSingleInvoice,
+]);
 
 export const invoiceProperties: INodeProperties[] = [
     {
@@ -20,18 +25,10 @@ export const invoiceProperties: INodeProperties[] = [
                 resource: ['invoice'],
             },
         },
-        options: [
-            create.description,
-            get.description,
-            getAll.description,
-            update.description,
-        ],
+        options: moduleHandler.getDescriptions(),
         default: 'getAll',
     },
-    ...create.properties,
-    ...get.properties,
-    ...getAll.properties,
-    ...update.properties,
+    ...moduleHandler.getProperties(),
 ];
 
 export async function invoiceOperations(
@@ -39,13 +36,14 @@ export async function invoiceOperations(
     { operation, i }: { operation: string; i: number }
 ) {
     if (operation === 'create') {
-        return await create.execute.call(this, i);
+        return await operations.createSingleInvoice.execute.call(this, i);
     } else if (operation === 'get') {
-        return await get.execute.call(this, i);
+        return await operations.getSingleInvoice.execute.call(this, i);
     } else if (operation === 'getAll') {
-        return await getAll.execute.call(this, i);
+        return await operations.getManyInvoices.execute.call(this, i);
     } else if (operation === 'update') {
-        return await update.execute.call(this, i);
+        return await operations.updateSingleInvoice.execute.call(this, i);
     }
     return null;
 }
+export * from './operations';

package/nodes/fortnox/resources/invoice/model.ts

@@ -147,10 +147,6 @@ export interface CreateInvoiceResponse {
     Invoice: Invoice;
 }
 
-export interface UpdateInvoiceResponse {
-    Invoice: Invoice;
-}
-
 export interface GetInvoiceResponse extends ResponseModel {
     Invoice: InvoiceBase;
 }

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

@@ -2,7 +2,6 @@ import { IExecuteFunctions, INodeProperties, IDataObject } from 'n8n-workflow';
 import { apiRequest } from '../../../transport';
 import { CreateInvoiceResponse } from '../model';
 import { invoiceParameters } from '../invoiceParameters';
-import { NodeResponse } from '../../../../nodeResponse';
 
 export const description = {
     name: 'Create',
@@ -44,7 +43,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<NodeResponse<CreateInvoiceResponse>> {
+): Promise<CreateInvoiceResponse> {
     const customerNumber = this.getNodeParameter('customerNumber', i, {});
     const createParameters = this.getNodeParameter('createParameters', i, {});
 

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

@@ -1,7 +1,6 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { apiRequest } from '../../../transport';
 import { GetInvoiceResponse } from '../model';
-import { NodeResponse } from '../../../../nodeResponse';
 
 export const description = {
     name: 'Get',
@@ -29,7 +28,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<NodeResponse<GetInvoiceResponse>> {
+): Promise<GetInvoiceResponse> {
     const documentNumber = this.getNodeParameter(
         'documentNumber',
         i,
@@ -38,18 +37,14 @@ export async function execute(
 
     const endpoint = `invoices/${encodeURIComponent(documentNumber)}`;
 
-    const response = await apiRequest<GetInvoiceResponse>(this, {
-        method: 'GET',
-        endpoint: endpoint,
-    });
-
-    if (response.success) return response;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            id: documentNumber,
+    return await apiRequest<GetInvoiceResponse>(
+        this,
+        {
+            method: 'GET',
+            endpoint: endpoint,
         },
-    };
+        {
+            id: documentNumber,
+        }
+    );
 }

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

@@ -2,7 +2,6 @@ import { IExecuteFunctions, INodeProperties, IDataObject } from 'n8n-workflow';
 import { apiRequest } from '../../../transport';
 import { filterParameters } from '../filterParameters';
 import { GetAllInvoicesResponse } from '../model';
-import { NodeResponse } from '../../../../nodeResponse';
 
 export const description = {
     name: 'Get Many',
@@ -73,7 +72,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<NodeResponse<GetAllInvoicesResponse>> {
+): Promise<GetAllInvoicesResponse> {
     const filterParameters = this.getNodeParameter('filterParameters', i, {});
     const sortParameters = this.getNodeParameter('sortParameters', i, '');
 

package/nodes/fortnox/resources/invoice/operations/index.ts

@@ -0,0 +1,4 @@
+export * as createSingleInvoice from './create.operation';
+export * as getSingleInvoice from './get.operation';
+export * as getManyInvoices from './getAll.operation';
+export * as updateSingleInvoice from './update.operation';

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

@@ -2,7 +2,6 @@ import { IExecuteFunctions, INodeProperties, IDataObject } from 'n8n-workflow';
 import { apiRequest } from '../../../transport';
 import { CreateInvoiceResponse } from '../model';
 import { invoiceParameters } from '../invoiceParameters';
-import { NodeResponse } from '../../../../nodeResponse';
 
 export const description = {
     name: 'Update',
@@ -44,7 +43,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<NodeResponse<CreateInvoiceResponse>> {
+): Promise<CreateInvoiceResponse> {
     const documentNumber = this.getNodeParameter(
         'documentNumber',
         i,
@@ -66,19 +65,15 @@ export async function execute(
 
     const endpoint = `invoices/${encodeURIComponent(documentNumber)}`;
 
-    const response = await apiRequest<CreateInvoiceResponse>(this, {
-        method: 'PUT',
-        endpoint: endpoint,
-        body: body,
-    });
-
-    if (response.success) return response;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            id: documentNumber,
+    return await apiRequest<CreateInvoiceResponse>(
+        this,
+        {
+            method: 'PUT',
+            endpoint: endpoint,
+            body: body,
         },
-    };
+        {
+            id: documentNumber,
+        }
+    );
 }

package/nodes/fortnox/transport/index.ts

@@ -5,18 +5,19 @@ import {
     IRequestOptions,
     LoggerProxy as Logger,
     IHttpRequestMethods,
+    NodeOperationError,
 } from 'n8n-workflow';
 import { translateErrorCode } from './errorCodes';
 import { ErrorResponseModel } from '../model';
 import { FORTNOX_API_CREDENTIAL_KEY } from '../commons';
-import { NodeResponse } from '../../nodeResponse';
 
 export const FORTNOX_BASE_URL = 'https://api.fortnox.se/3/';
 
 export async function apiRequest<T>(
     nodeContext: IExecuteFunctions | ILoadOptionsFunctions,
-    options: IDataObject
-): Promise<NodeResponse<T>> {
+    options: IDataObject,
+    errorMetadata?: Record<string, unknown>
+): Promise<T> {
     const endpoint = options.endpoint;
     const method = options.method as IHttpRequestMethods;
     const credentials = await nodeContext.getCredentials(
@@ -52,17 +53,15 @@ export async function apiRequest<T>(
         // use request instead of requestWithAuthentication cause in the requestWithAuthentication
         // error.error is not set, so we cannot access error.error.ErrorInformation
         // and we cannot translate the error code
-        const response = await nodeContext.helpers.request.call(
+        return await nodeContext.helpers.request.call(
             nodeContext,
             FORTNOX_API_CREDENTIAL_KEY,
             requestOptions
         );
-        return {
-            success: true,
-            data: response,
-        };
     } catch (error) {
-        const errorResponse: ErrorResponseModel = error.error || {};
+        const errorResponse: ErrorResponseModel = error.error || {
+            ErrorInformation: {},
+        };
         // fields in ErrorInformationModel can start with lowercase or uppercase,
         // so we normalize them to lowercase for consistency
         const errorInformation = errorResponse?.ErrorInformation && {
@@ -89,15 +88,19 @@ export async function apiRequest<T>(
         } else {
             message = `API request failed [URL: ${fullUrl}][Method: ${method}]: ${error.message}`;
         }
-        return {
-            success: false,
+        const errorContext = {
             error: message,
             status: error?.cause?.status,
             metadata: {
                 qs: options?.qs,
                 body: options?.body,
                 timeout: options?.timeout,
+                ...errorMetadata,
             },
         };
+        throw new NodeOperationError(
+            nodeContext.getNode(),
+            JSON.stringify(errorContext)
+        );
     }
 }

package/nodes/index.ts

@@ -0,0 +1,4 @@
+export * from './response';
+export * from './lime-crm';
+export * from './fortnox';
+export * from './modules';

package/nodes/lime-crm/LimeCrmNode.node.ts

@@ -9,28 +9,71 @@ import {
 } from 'n8n-workflow';
 
 import { metadataFields, metadataOperations } from './resources/metadata';
+import { adminFields, adminOperations } from './resources/admin';
 import { dataFields, dataOperations } from './resources/data';
 
 import {
+    ADMIN_RESOURCE,
     DATA_RESOURCE,
     METADATA_RESOURCE,
     LIME_CRM_API_CREDENTIAL_KEY,
-} from './commons';
+} from './models';
 
 import {
-    getEntitiesForErpSystem,
     getFileProperties,
     getLimetypeProperties,
     getLimetypes,
     getNoHasManyProperties,
+    getCreateMappingColumns,
+    getUpdateMappingColumns,
 } from './methods';
 
+/**
+ * Representation of a function that executes a specific Lime CRM operation.
+ *
+ * This function type is used by the Lime CRM node to dynamically invoke
+ * the appropriate handler (e.g., metadata or data operations) during node execution.
+ *
+ * @param this - The n8n {@link IExecuteFunctions} context, providing access to
+ * node parameters, credentials, and helper methods.
+ * @param args - The arguments used for the operation.
+ * @param args.operation - The name of the operation to execute (e.g., "getAll", "create").
+ * @param args.i - The index of the current item being processed in the n8n execution loop.
+ *
+ * @returns A promise that resolves with the result of the operation.
+ *
+ * @public
+ * @group Node Definition
+ */
 type OperationFn = (
     this: IExecuteFunctions,
     args: { operation: string; i: number }
 ) => Promise<unknown>;
 
+/**
+ * The main n8n node for interacting with the Lime CRM API.
+ *
+ * Provides two resource groups:
+ * - **Metadata**: Allows interaction with the structure of available Limetypes and their properties.
+ * - **Data**: Enables operations on Lime CRM data objects.
+ *
+ * The node dynamically loads available Lime CRM resources and properties and routes
+ * executions to the appropriate operation handlers.
+ *
+ * @remarks
+ * This node uses {@link metadataOperations} and {@link dataOperations} to process workflow executions
+ * based on the selected resource and operation.
+ *
+ * @public
+ * @group Node Definition
+ */
 export class LimeCrmNode implements INodeType {
+    /**
+     * Node configuration and metadata, defining available resources, operations, and credentials.
+     * Describes how the Lime CRM node appears and behaves in the n8n editor.
+     *
+     * @see {@link https://docs.n8n.io/integrations/creating-nodes/#node-description}
+     */
     description: INodeTypeDescription = {
         displayName: 'Lime CRM',
         name: 'limeCrm',
@@ -51,6 +94,7 @@ export class LimeCrmNode implements INodeType {
                 required: true,
             },
         ],
+        usableAsTool: true,
         properties: [
             {
                 displayName: 'Resource',
@@ -70,28 +114,60 @@ export class LimeCrmNode implements INodeType {
                         value: DATA_RESOURCE,
                         description: 'Work with CRM data',
                     },
+                    {
+                        name: 'Admin',
+                        value: ADMIN_RESOURCE,
+                        description: 'Work with administrative data',
+                    },
                 ],
                 default: DATA_RESOURCE,
             },
 
             ...(metadataFields as INodeProperties[]),
             ...(dataFields as INodeProperties[]),
+            ...(adminFields as INodeProperties[]),
         ],
     };
 
+    /**
+     * Methods used by the Lime CRM node to load dynamic options in the n8n UI.
+     *
+     * @remarks
+     * These functions are used to populate dropdowns and lists in the node's
+     * parameter editor. For details, see:
+     * - {@link getLimetypes}
+     * - {@link getFileProperties}
+     * - {@link getLimetypeProperties}
+     * - {@link getNoHasManyProperties}
+     * - {@link getUpdateMappingColumns}
+     * - {@link getCreateMappingColumns}
+     */
     methods = {
         loadOptions: {
-            getEntitiesForErpSystem,
             getLimetypes,
-            getFileProperties,
             getLimetypeProperties,
+            getFileProperties,
             getNoHasManyProperties,
         },
+        resourceMapping: {
+            getUpdateMappingColumns,
+            getCreateMappingColumns,
+        },
     };
 
+    /**
+     * Execute the selected operation for the configured resource.
+     *
+     * Routes the execution to either {@link metadataOperations} or {@link dataOperations},
+     * based on the user’s selection in the n8n UI.
+     *
+     * @returns A two-dimensional array of execution data for downstream nodes.
+     *
+     * @throws Error - Will throw an error if execution fails and `continueOnFail` is not enabled
+     */
     async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
         const items = this.getInputData();
-        const returnData = [];
+        let returnData: INodeExecutionData[] = [];
 
         const resource = this.getNodeParameter('resource', 0) as string;
         const operation = this.getNodeParameter('operation', 0) as string;
@@ -106,23 +182,25 @@ export class LimeCrmNode implements INodeType {
                 operationFn = dataOperations;
                 break;
             }
+            case ADMIN_RESOURCE: {
+                operationFn = adminOperations;
+                break;
+            }
         }
 
         for (let i = 0; i < items.length; i++) {
             if (!operationFn) continue;
             try {
-                const responseData = await operationFn.call(this, {
+                const responseData = (await operationFn.call(this, {
                     operation,
                     i,
-                });
+                })) as INodeExecutionData | INodeExecutionData[] | undefined;
                 if (responseData !== undefined) {
-                    returnData.push(
-                        responseData as unknown as INodeExecutionData
-                    );
+                    returnData = returnData.concat(responseData);
                 }
             } catch (error) {
                 if (this.continueOnFail()) {
-                    returnData.push({ error: error.message });
+                    returnData.push({ json: {}, error: error.message });
                     continue;
                 }
                 throw error;