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

package/nodes/lime-crm/resources/metadata/index.ts

@@ -6,11 +6,30 @@ import {
     NodeOperationError,
 } from 'n8n-workflow';
 
-import * as getSingleLimetype from './operations/getSingleLimetype';
-import * as getAllLimetypes from './operations/getAllLimetypes.operation';
-import * as getSingleFileMetadata from '../metadata/operations/getSingleFileMetadata';
-import { METADATA_RESOURCE } from '../../commons';
+import * as operations from './operations';
+import { METADATA_RESOURCE } from '../../models';
+import { N8NOperationModuleHandler } from '../../../modules';
 
+const moduleHandler = new N8NOperationModuleHandler([
+    operations.getAllLimetypes,
+    operations.getSingleLimetype,
+    operations.getSingleFileMetadata,
+]);
+
+/**
+ * Fields and operations for the **Metadata** resource in Lime CRM.
+ *
+ * @remarks
+ * - These fields are displayed in the n8n node UI when the resource is set to `Metadata`.
+ * - Each operation corresponds to fetching or inspecting metadata in Lime CRM.
+ *
+ * @group Resources
+ * @public
+ *
+ * @see {@link getAllLimetypes} - Operation to retrieve a list of all available Limetypes
+ * @see {@link getSingleLimetype} - Operation to retrieve details about a specific Limetype
+ * @see {@link getSingleFileMetadata} - Operation to fetch metadata for a specific file
+ */
 export const metadataFields: INodeProperties[] = [
     {
         displayName: 'Operation',
@@ -22,31 +41,50 @@ export const metadataFields: INodeProperties[] = [
                 resource: [METADATA_RESOURCE],
             },
         },
-        options: [
-            getAllLimetypes.description,
-            getSingleLimetype.description,
-            getSingleFileMetadata.description,
-        ],
-        default: 'listTypes',
+        options: moduleHandler.getDescriptions(),
+        default: 'getAllLimetypes',
     },
 
-    ...getSingleLimetype.properties,
-    ...getSingleFileMetadata.properties,
+    ...moduleHandler.getProperties(),
 ];
 
+/**
+ * Execute a specific **Metadata** operation on Lime CRM.
+ *
+ * @param args - Contextual parameters for the operation being executed
+ * @param args.operation - The operation to perform (e.g., `getAllLimetypes`, `getSingleLimetype`)
+ * @param args.i - The index of the input item to process
+ *
+ * @returns A promise resolving to the n8n object containing the result of the operation.
+ *
+ * @throws NodeOperationError if the operation is unsupported or fails.
+ *
+ * @public
+ * @group Resources
+ */
 export async function metadataOperations(
     this: IExecuteFunctions,
     { operation, i }: { operation: string; i: number }
-): Promise<INodeExecutionData> {
+): Promise<INodeExecutionData | INodeExecutionData[]> {
     switch (operation) {
         case 'getAllLimetypes': {
-            return { json: await getAllLimetypes.execute.call(this) };
+            const results = await operations.getAllLimetypes.execute.call(this);
+            return results.map((limetype) => ({
+                json: limetype,
+            }));
         }
         case 'getSingleLimetype': {
-            return { json: await getSingleLimetype.execute.call(this, i) };
+            return {
+                json: await operations.getSingleLimetype.execute.call(this, i),
+            };
         }
         case 'getSingleFileMetadata': {
-            return { json: await getSingleFileMetadata.execute.call(this, i) };
+            return {
+                json: await operations.getSingleFileMetadata.execute.call(
+                    this,
+                    i
+                ),
+            };
         }
     }
 
@@ -55,3 +93,5 @@ export async function metadataOperations(
         `The operation "${operation}" is not supported!`
     );
 }
+
+export * from './operations';

package/nodes/lime-crm/resources/metadata/operations/getAllLimetypes.operation.ts

@@ -1,9 +1,11 @@
 import { IExecuteFunctions } from 'n8n-workflow';
 
 import { getLimetypesFromApi } from '../../../transport';
-import { Limetype } from '../../../model';
-import { NodeResponse } from '../../../../nodeResponse';
+import { Limetype } from '../../../models';
 
+/**
+ * Description and metadata for the "Get All Limetypes" operation in Lime CRM.
+ */
 export const description = {
     name: 'Get all Limetypes',
     value: 'getAllLimetypes',
@@ -11,8 +13,16 @@ export const description = {
     action: 'Get all Limetypes',
 };
 
-export async function execute(
-    this: IExecuteFunctions
-): Promise<NodeResponse<Limetype[]>> {
+/**
+ * Retrieve a list of all available Limetypes from Lime CRM.
+ *
+ * This operation queries the Lime CRM API for all accessible Limetypes,
+ * such as company, person, deal, etc.
+ *
+ * @returns An array of Limetype objects
+ *
+ * @public
+ */
+export async function execute(this: IExecuteFunctions): Promise<Limetype[]> {
     return await getLimetypesFromApi(this);
 }

package/nodes/lime-crm/resources/metadata/operations/{getSingleFileMetadata.ts → getSingleFileMetadata.operation.ts}

@@ -1,15 +1,20 @@
 import {
     IExecuteFunctions,
     INodeProperties,
-    INodeExecutionData,
     NodeOperationError,
 } from 'n8n-workflow';
 import {
+    FileMetadata,
     getFileMetadata,
     getFileMetadataByLimeobject,
 } from '../../../transport';
-import { METADATA_RESOURCE } from '../../../commons';
+import { METADATA_RESOURCE } from '../../../models';
 
+/**
+ * Description and metadata for the "Get Single File Metadata" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Get Single File Metadata',
     value: 'getSingleFileMetadata',
@@ -17,6 +22,16 @@ export const description = {
     action: 'Get single file metadata',
 };
 
+/**
+ * Node parameter definitions for the "Get Single File Metadata" operation.
+ *
+ * @param source - Determines whether the file is retrieved by its ID or by its associated Limeobject ID
+ * @param limetype - The Lime CRM entity type associated with the file (required when `source` is `byLimeobject`)
+ * @param identifier - The unique identifier of the file or Limeobject to retrieve metadata for
+ * @param property - The file property in the Limeobject containing the file reference (used when `source` is `byLimeobject`)
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Get by',
@@ -98,29 +113,31 @@ export const properties: INodeProperties[] = [
     },
 ];
 
+/**
+ * Execute the "Get Single File Metadata" operation.
+ *
+ * Retrieves file metadata either directly via its file ID, or through its associated Limeobject.
+ * The function dynamically calls the correct method depending on user configuration.
+ *
+ * @param i - The index of the current item being processed within the n8n execution loop.
+ * @returns File metadata
+ *
+ * @public
+ */
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<INodeExecutionData> {
+): Promise<FileMetadata> {
     const source = this.getNodeParameter('source', i) as string;
     const id = this.getNodeParameter('identifier', i) as string;
 
     if (source == 'byFile') {
-        return {
-            json: await getFileMetadata(this, id),
-        };
+        return await getFileMetadata(this, id);
     }
     if (source == 'byLimeobject') {
         const limetype = this.getNodeParameter('limetype', i) as string;
         const property = this.getNodeParameter('property', i) as string;
-        return {
-            json: await getFileMetadataByLimeobject(
-                this,
-                limetype,
-                id,
-                property
-            ),
-        };
+        return await getFileMetadataByLimeobject(this, limetype, id, property);
     }
 
     throw new NodeOperationError(

package/nodes/lime-crm/resources/metadata/operations/{getSingleLimetype.ts → getSingleLimetype.operation.ts}

@@ -1,7 +1,12 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { getLimetype } from '../../../transport/limetypes';
-import { METADATA_RESOURCE } from '../../../commons';
+import { METADATA_RESOURCE } from '../../../models';
 
+/**
+ * Description and metadata for the "Get Single Limetype" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Get Single Limetype',
     value: 'getSingleLimetype',
@@ -9,6 +14,13 @@ export const description = {
     action: 'Get single Limetype',
 };
 
+/**
+ * Node parameter definitions for the "Get Single Limetype" operation.
+ *
+ * @param limetype - The name of the entity type (Limetype) to retrieve details for
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Limetype',
@@ -29,6 +41,16 @@ export const properties: INodeProperties[] = [
     },
 ];
 
+/**
+ * Execute the "Get Single Limetype" operation.
+ *
+ * Retrieves detailed information about a specific Limetype from Lime CRM.
+ *
+ * @param i - The index of the current item being processed within the n8n execution loop.
+ * @returns Limetype details as returned from the API.
+ *
+ * @public
+ */
 export async function execute(this: IExecuteFunctions, i: number) {
     const limetype = this.getNodeParameter('limetype', i) as string;
 

package/nodes/lime-crm/resources/metadata/operations/index.ts

@@ -0,0 +1,12 @@
+/**
+ * @group Resources
+ */
+export * as getSingleLimetype from './getSingleLimetype.operation';
+/**
+ * @group Resources
+ */
+export * as getAllLimetypes from './getAllLimetypes.operation';
+/**
+ * @group Resources
+ */
+export * as getSingleFileMetadata from './getSingleFileMetadata.operation';

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

@@ -1,9 +1,25 @@
-import { LIME_CRM_API_CREDENTIAL_KEY } from '../commons';
-import { IAllExecuteFunctions } from 'n8n-workflow';
-import { NodeResponse } from '../../nodeResponse';
+import { LIME_CRM_API_CREDENTIAL_KEY } from '../models';
+import { IAllExecuteFunctions, NodeOperationError } from 'n8n-workflow';
 
-type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
+/**
+ * HTTP methods supported by the Lime CRM API.
+ *
+ * @group Transport
+ * @public
+ */
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
 
+/**
+ * Return a copy of the given object with specified keys removed.
+ *
+ * @param data - The source object
+ * @param keys - An array of keys to remove from the object
+ *
+ * @returns A new object with the specified keys omitted
+ *
+ * @public
+ * @group Transport
+ */
 export function removeKeys<T extends object, K extends keyof T>(
     data: T,
     keys: K[]
@@ -15,6 +31,16 @@ export function removeKeys<T extends object, K extends keyof T>(
     return obj;
 }
 
+/**
+ * Retrieve the base URL for the Lime CRM API from stored credentials.
+ *
+ * @param context - The n8n execution context
+ *
+ * @returns The Lime CRM API base URL as a string
+ *
+ * @internal
+ * @group Transport
+ */
 async function getLimeUrl(context: IAllExecuteFunctions): Promise<string> {
     const credentials = await context.getCredentials(
         LIME_CRM_API_CREDENTIAL_KEY
@@ -22,36 +48,68 @@ async function getLimeUrl(context: IAllExecuteFunctions): Promise<string> {
     return credentials.url as string;
 }
 
+/**
+ * CallLimeAPI arguments wrapped in a single interface to enable keyword-style
+ * arguments.
+ *
+ * @property method - The HTTP method to use (GET, POST, etc.)
+ * @property url - The API endpoint URL (relative path)
+ * @property requestOptions - Optional additional request options (headers, body, query, etc.)
+ * @property json - Whether to parse the response as JSON.
+ * @property errorMetadata - Additional information we want to pass to message in case of error
+ *
+ * @public
+ * @group Transport
+ */
+
+interface LimeAPIArguments {
+    method: HTTPMethod;
+    url: string;
+    requestOptions?: Record<string, unknown>;
+    json?: boolean;
+    errorMetadata?: Record<string, unknown>;
+}
+
+/**
+ * Make an authenticated HTTP request to the Lime CRM API and returns a structured response.
+ *
+ * @typeParam T - The expected type of the API response data
+ * @param nodeContext - The n8n execution context
+ * @param options - {@link LimeAPIArguments} object
+ *
+ * @returns API data or response details
+ *
+ * @public
+ * @group Transport
+ */
 export async function callLimeApi<T>(
     nodeContext: IAllExecuteFunctions,
-    method: HTTPMethod,
-    url: string,
-    options?: Record<string, unknown>,
-    json = true
-): Promise<NodeResponse<T>> {
+    options: LimeAPIArguments
+): Promise<T> {
     try {
-        const response: T =
-            await nodeContext.helpers.requestWithAuthentication.call(
-                nodeContext,
-                LIME_CRM_API_CREDENTIAL_KEY,
-                {
-                    method: method,
-                    url: url,
-                    json: json,
-                    baseURL: await getLimeUrl(nodeContext),
-                    ...options,
-                }
-            );
-        return {
-            success: true,
-            data: response,
-        };
+        return await nodeContext.helpers.requestWithAuthentication.call(
+            nodeContext,
+            LIME_CRM_API_CREDENTIAL_KEY,
+            {
+                method: options.method,
+                url: options.url,
+                json: options.json || true,
+                baseURL: await getLimeUrl(nodeContext),
+                ...options.requestOptions,
+            }
+        );
     } catch (error) {
-        return {
-            success: false,
+        const errorContext = {
             error: error instanceof Error ? error.message : String(error),
             status: error?.cause?.status,
-            metadata: options,
+            metadata: {
+                ...options.requestOptions,
+                ...options.errorMetadata,
+            },
         };
+        throw new NodeOperationError(
+            nodeContext.getNode(),
+            JSON.stringify(errorContext)
+        );
     }
 }