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

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,69 @@ 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,
 } 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 +92,7 @@ export class LimeCrmNode implements INodeType {
                 required: true,
             },
         ],
+        usableAsTool: true,
         properties: [
             {
                 displayName: 'Resource',
@@ -70,28 +112,54 @@ 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}
+     */
     methods = {
         loadOptions: {
-            getEntitiesForErpSystem,
             getLimetypes,
-            getFileProperties,
             getLimetypeProperties,
+            getFileProperties,
             getNoHasManyProperties,
         },
     };
 
+    /**
+     * 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 +174,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;

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

@@ -10,7 +10,7 @@ import {
     NodeConnectionTypes,
 } from 'n8n-workflow';
 
-import { getWebhook, LIME_CRM_API_CREDENTIAL_KEY } from './commons';
+import { LIME_CRM_API_CREDENTIAL_KEY } from './models';
 import { getLimetypes } from './methods';
 import {
     createSubscription,
@@ -19,9 +19,32 @@ import {
     listSubscriptionsWithExistingData,
 } from './transport';
 
-import { verifyHmac } from './commons';
+import { getWebhook, verifyHmac } from './utils';
 
+/**
+ * Trigger node for handling incoming webhooks from **Lime CRM**.
+ *
+ * This node subscribes to events in Lime (such as record creation, update, or deletion)
+ * and triggers workflows in n8n when those events occur.
+ *
+ * @remarks
+ * - Automatically manages webhook subscriptions in Lime CRM (create, check, delete).
+ * - Verifies incoming webhook authenticity using HMAC signatures.
+ * - Returns the received payload as JSON to connected nodes.
+ *
+ * @public
+ * @group Node Definition
+ *
+ * @see {@link getSubscription} - Fetches an existing webhook subscription
+ * @see {@link listSubscriptionsWithExistingData} - Checks for existing subscriptions matching the same target URL and events
+ * @see {@link createSubscription} - Creates a new webhook subscription in Lime
+ * @see {@link deleteSubscription} - Removes an existing webhook subscription
+ */
 export class LimeCrmTrigger implements INodeType {
+    /**
+     * Definition of the node’s metadata, input/output configuration,
+     * authentication requirements, and event subscription options.
+     */
     description: INodeTypeDescription = {
         displayName: 'Lime CRM Trigger',
         name: 'limeCrmTrigger',
@@ -112,12 +135,24 @@ export class LimeCrmTrigger implements INodeType {
         ],
     };
 
+    /**
+     * Methods used to dynamically load options in the node UI. For details, see:
+     *
+     * - {@link getLimetypes}
+     */
     methods = {
         loadOptions: {
             getLimetypes,
         },
     };
 
+    /**
+     * Webhook lifecycle management methods:
+     *
+     * - checkExists - Verifies whether the webhook already exists in Lime CRM
+     * - create - Creates a new webhook subscription in Lime CRM if one does not exist
+     * - delete - Deletes the existing webhook subscription in Lime CRM
+     */
     webhookMethods = {
         default: {
             async checkExists(this: IHookFunctions): Promise<boolean> {
@@ -127,20 +162,18 @@ export class LimeCrmTrigger implements INodeType {
                     return false;
                 }
 
-                const response = await getSubscription(this, webhook);
-                if (!response.success) {
-                    if (response.status === 404) {
+                try {
+                    await getSubscription(this, webhook);
+                } catch (error) {
+                    if (error.cause?.status === 404) {
                         delete webhook.data.webhookId;
                         delete webhook.data.webhookEvents;
                         return false;
                     }
                     Logger.warn(
-                        `There was en error while getting a webhook from Lime CRM: ${response.error}`
-                    );
-                    throw new NodeOperationError(
-                        this.getNode(),
-                        response.error
+                        `There was en error while getting a webhook from Lime CRM: ${error}`
                     );
+                    throw new NodeOperationError(this.getNode(), error);
                 }
                 return true;
             },
@@ -158,17 +191,10 @@ export class LimeCrmTrigger implements INodeType {
                 // Check if a webhook already exists in order to not duplicate it in Lime
                 // This is a different check then 'checkExists' which only takes an ID,
                 // but it's only suited for production environment
-
                 const existingSubscriptionResponse =
                     await listSubscriptionsWithExistingData(this, webhook);
-                if (!existingSubscriptionResponse.success) {
-                    throw new NodeOperationError(
-                        this.getNode(),
-                        existingSubscriptionResponse.error
-                    );
-                }
 
-                if (existingSubscriptionResponse.data.length === 0) {
+                if (existingSubscriptionResponse.length === 0) {
                     const credentials = await this.getCredentials(
                         LIME_CRM_API_CREDENTIAL_KEY
                     );
@@ -182,15 +208,8 @@ export class LimeCrmTrigger implements INodeType {
                         webhookCreateData
                     );
 
-                    if (!createSubscriptionResponse.success) {
-                        throw new NodeOperationError(
-                            this.getNode(),
-                            createSubscriptionResponse.error
-                        );
-                    }
-
-                    const subscriptionId = createSubscriptionResponse.data.id;
-                    const events = createSubscriptionResponse.data.events;
+                    const subscriptionId = createSubscriptionResponse.id;
+                    const events = createSubscriptionResponse.events;
 
                     webhook.data.webhookId = subscriptionId;
                     webhook.data.webhookEvents = events;
@@ -199,7 +218,7 @@ export class LimeCrmTrigger implements INodeType {
                     );
                     return true;
                 } else {
-                    const limeWebhook = existingSubscriptionResponse.data[0];
+                    const limeWebhook = existingSubscriptionResponse[0];
                     webhook.data.webhookId = limeWebhook.id;
                     webhook.data.webhookEvents = limeWebhook.events;
                     Logger.info(
@@ -217,8 +236,9 @@ export class LimeCrmTrigger implements INodeType {
                     { ...webhook }
                 );
                 if (webhook.data.webhookId !== undefined) {
-                    const response = await deleteSubscription(this, webhook);
-                    if (!response.success) {
+                    try {
+                        await deleteSubscription(this, webhook);
+                    } catch {
                         Logger.error(
                             `Failed to delete webhook with ID: ${webhook.data.webhookId}`,
                             {
@@ -236,6 +256,26 @@ export class LimeCrmTrigger implements INodeType {
         },
     };
 
+    /**
+     * Main webhook handler — called when Lime CRM sends an event to this node.
+     *
+     * @returns The formatted webhook response data ready for n8n workflow processing.
+     *
+     * @throws NodeOperationError if authentication fails or webhook data is invalid.
+     *
+     * @example
+     * ```ts
+     * // Example webhook body:
+     * {
+     *   "event": "deal.new",
+     *   "body": {
+     *     "id": 1001,
+     *     "limetype": "deal",
+     *     "values": { "company": 1001, "coworker": 1001, "probability": 0, ... }
+     *   }
+     * }
+     * ```
+     */
     async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
         const webhook = getWebhook(this);
         Logger.info('Webhook received. Starting webhook processing...', {

package/nodes/lime-crm/index.ts

@@ -0,0 +1,9 @@
+export * from './utils';
+export * from './methods';
+export * from './models';
+export * from './resources/data';
+export * from './resources/metadata';
+export * from './resources/admin';
+export * from './transport';
+export * from './LimeCrmNode.node';
+export * from './LimeCrmTrigger.node';