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

package/nodes/lime-crm/resources/data/operations/{getSingleObject.ts → getSingleObject.operation.ts}

@@ -1,9 +1,14 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { getLimeobject } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
-import { getFileProperties, processFileResponse } from '../../../commons/files';
-
+import { getLimeobject, getProperties } from '../../../transport';
+import { DATA_RESOURCE, Limeobject } from '../../../models';
+import { getFilePropertiesNames, processFileResponse } from '../../../utils';
+import { WorkflowFileResponse } from '../../../../response';
+/**
+ * Description and metadata for the "Get Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Get Single Object',
     value: 'getSingleObject',
@@ -11,6 +16,15 @@ export const description = {
     action: 'Get single object',
 };
 
+/**
+ * Node properties for the "Get Single Object" operation.
+ *
+ * @param {string} limetype - The type of entity to retrieve. Loaded from available Limetypes
+ * @param {string} objectId - The ID of the object to retrieve
+ * @param {boolean} includeFileContent - Whether to include file binary data for Limetypes that have file properties. Ignored for Limetypes without file properties
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Limetype',
@@ -62,7 +76,28 @@ export const properties: INodeProperties[] = [
     },
 ];
 
-export async function execute(this: IExecuteFunctions, i: number) {
+/**
+ * Execute the "Get Single Object" operation for Lime CRM.
+ *
+ * @remarks
+ * This method retrieves a single Lime CRM object identified by its object ID and Limetype.
+ * If `includeFileContent` is true, it also retrieves binary data for any file properties of the object.
+ *
+ * The method performs the following steps:
+ * 1. Retrieves the `limetype`, `objectId`, and `includeFileContent` from {@link properties}.
+ * 2. Calls {@link getLimeobject} to fetch the object from Lime CRM.
+ * 3. If the object has file properties and `includeFileContent` is true, it retrieves file data using {@link getFilePropertiesNames} and {@link processFileResponse}.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The Lime object data, optionally including file binary content.
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowFileResponse<Limeobject>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const objectId = this.getNodeParameter('objectId', i) as string;
     const includeFileContent = this.getNodeParameter(
@@ -71,13 +106,20 @@ export async function execute(this: IExecuteFunctions, i: number) {
     ) as boolean;
 
     const limeObjectResponse = await getLimeobject(this, limetype, objectId);
-    if (!limeObjectResponse.success) return { json: limeObjectResponse };
+    if (!limeObjectResponse.success) return { json: limeObjectResponse.data };
+
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) return { json: propertiesResponse.data };
 
-    const fileProperties = await getFileProperties(this, limetype);
-    return processFileResponse(
+    const fileProperties = getFilePropertiesNames(propertiesResponse.data);
+    const fileResponse = await processFileResponse<Limeobject>(
         this,
         fileProperties,
         limeObjectResponse.data,
         includeFileContent
     );
+    return {
+        json: fileResponse.json.data,
+        binary: fileResponse.binary,
+    };
 }

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

@@ -0,0 +1,24 @@
+/**
+ * @group Resources
+ */
+export * as createSingleObject from './createSingleObject.operation';
+/**
+ * @group Resources
+ */
+export * as getSingleObject from './getSingleObject.operation';
+/**
+ * @group Resources
+ */
+export * as updateSingleObject from './updateSingleObject.operation';
+/**
+ * @group Resources
+ */
+export * as deleteSingleObject from './deleteSingleObject.operation';
+/**
+ * @group Resources
+ */
+export * as getManyObjects from './getManyObjects.operation';
+/**
+ * @group Resources
+ */
+export * as getSingleFile from './getSingleFile.operation';

package/nodes/lime-crm/resources/data/operations/updateSingleObject.operation.ts

@@ -1,13 +1,19 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { updateLimeobject } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
+import { getProperties, updateLimeobject } from '../../../transport';
+import { DATA_RESOURCE, Limeobject } from '../../../models';
 import {
-    getFileProperties,
+    getFilePropertiesNames,
     processFileResponse,
     setFileProperties,
-} from '../../../commons/files';
+} from '../../../utils';
+import { WorkflowFileResponse } from '../../../../response';
+import { parseResourceMapperFields } from '../../../methods';
 
-// Input fields for update operation
+/**
+ * Description and metadata for the "Update Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Update Single Object',
     value: 'updateSingleObject',
@@ -15,6 +21,17 @@ export const description = {
     action: 'Update single object',
 };
 
+/**
+ * Node properties for the "Update Single Object" operation.
+ *
+ * @param {string} limetype - The type of entity to update. Loaded from available Limetypes
+ * @param {string} id - The ID of the object to update
+ * @param {'simple' | 'json'} inputType - How the object data is provided: 'simple' for form inputs, 'json' for raw JSON
+ * @param {IDataObject} simpleFields - Used if `inputType` is 'simple'. List of field name/value pairs to update
+ * @param {string} jsonData - Used if `inputType` is 'json'. Full object data in JSON format
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Limetype',
@@ -54,7 +71,7 @@ export const properties: INodeProperties[] = [
         options: [
             {
                 name: 'Simple Fields',
-                value: 'simple',
+                value: 'fields',
                 description: 'Define fields using the UI',
             },
             {
@@ -63,7 +80,7 @@ export const properties: INodeProperties[] = [
                 description: 'Define fields using JSON',
             },
         ],
-        default: 'simple',
+        default: 'fields',
         description: 'How to input the data',
         displayOptions: {
             show: {
@@ -92,81 +109,80 @@ export const properties: INodeProperties[] = [
         },
     },
     {
-        displayName: 'Fields',
-        name: 'simpleFields',
-        placeholder: 'Add Field',
-        type: 'fixedCollection',
+        displayName: 'Properties',
+        name: 'properties',
+        type: 'resourceMapper',
+        placeholder: 'Add Property',
         typeOptions: {
-            multipleValues: true,
-            sortable: true,
+            resourceMapper: {
+                resourceMapperMethod: 'getUpdateMappingColumns',
+                mode: 'add',
+                addAllFields: false,
+                supportAutoMap: false,
+            },
+            loadOptionsDependsOn: ['limetype'],
+        },
+        default: {
+            value: null,
         },
-        default: {},
         displayOptions: {
             show: {
                 resource: [DATA_RESOURCE],
                 operation: ['updateSingleObject'],
-                inputType: ['simple'],
+                inputType: ['fields'],
             },
         },
-        options: [
-            {
-                name: 'field',
-                displayName: 'Field',
-                values: [
-                    {
-                        displayName: 'Field Name',
-                        name: 'fieldName',
-                        type: 'options',
-                        typeOptions: {
-                            loadOptionsMethod: 'getLimetypeProperties',
-                            loadOptionsDependsOn: ['limetype'],
-                        },
-                        default: '',
-                        description: 'The name of the field',
-                    },
-                    {
-                        displayName: 'Field Value',
-                        name: 'fieldValue',
-                        type: 'string',
-                        default: '',
-                        description: 'The value of the field',
-                    },
-                ],
-            },
-        ],
     },
 ];
 
-export async function execute(this: IExecuteFunctions, i: number) {
+/**
+ * Execute the "Update Single Object" operation for Lime CRM.
+ *
+ * @remarks
+ * This method updates a single Lime CRM object identified by its ID and Limetype.
+ * It supports two input methods:
+ * - 'simple': key-value pairs provided via the UI
+ * - 'json': full object data in JSON format
+ *
+ * The method performs the following steps:
+ * 1. Retrieves the `limetype`, `id`, and input data from {@link properties}.
+ * 2. Collects and prepares any file properties using {@link getFilePropertiesNames} and {@link setFileProperties}.
+ * 3. Calls {@link updateLimeobject} to update the object in Lime CRM.
+ * 4. Processes the response, including file properties, using {@link processFileResponse}.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The updated Lime object data, optionally including file binary content.
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowFileResponse<Limeobject>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const id = this.getNodeParameter('id', i) as string;
     const inputType = this.getNodeParameter('inputType', i) as string;
 
     let body: IDataObject = {};
 
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success)
+        return {
+            json: propertiesResponse.data,
+        };
+    const properties = propertiesResponse.data;
+
     if (inputType === 'json') {
         const jsonData = this.getNodeParameter('jsonData', i) as string;
         body = JSON.parse(jsonData);
     } else {
-        const simpleFields = this.getNodeParameter(
-            'simpleFields.field',
-            i,
-            []
-        ) as IDataObject[];
-        for (const field of simpleFields) {
-            body[field.fieldName as string] = field.fieldValue;
-        }
+        body = parseResourceMapperFields(this, i, 'properties');
     }
 
-    const fileProperties = await getFileProperties(this, limetype);
+    const fileProperties = getFilePropertiesNames(properties);
 
-    const setFilePropertiesResponse = await setFileProperties(
-        this,
-        i,
-        fileProperties,
-        body
-    );
-    if (!setFilePropertiesResponse.success) return setFilePropertiesResponse;
+    await setFileProperties(this, i, fileProperties, body);
 
     const updateLimeobjectResponse = await updateLimeobject(
         this,
@@ -174,12 +190,18 @@ export async function execute(this: IExecuteFunctions, i: number) {
         id,
         body
     );
-    if (!updateLimeobjectResponse.success) return updateLimeobjectResponse;
+    if (!updateLimeobjectResponse.success)
+        return {
+            json: updateLimeobjectResponse.data,
+        };
 
-    const response = await processFileResponse(
+    const response = await processFileResponse<Limeobject>(
         this,
         fileProperties,
         updateLimeobjectResponse.data
     );
-    return response.json;
+    return {
+        json: response.json.data,
+        binary: response.binary,
+    };
 }

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,54 @@ 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);
+            if (Array.isArray(results)) {
+                return results.map((limetype) => ({
+                    json: limetype,
+                }));
+            } else {
+                return { json: results };
+            }
         }
         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 +97,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,12 @@
 import { IExecuteFunctions } from 'n8n-workflow';
 
 import { getLimetypesFromApi } from '../../../transport';
-import { Limetype } from '../../../model';
-import { NodeResponse } from '../../../../nodeResponse';
+import { Limetype } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
+/**
+ * Description and metadata for the "Get All Limetypes" operation in Lime CRM.
+ */
 export const description = {
     name: 'Get all Limetypes',
     value: 'getAllLimetypes',
@@ -11,8 +14,19 @@ export const description = {
     action: 'Get all Limetypes',
 };
 
+/**
+ * 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<NodeResponse<Limetype[]>> {
-    return await getLimetypesFromApi(this);
+): Promise<WorkflowResponse<Limetype[]>> {
+    const response = await getLimetypesFromApi(this);
+    return response.data;
 }

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

@@ -1,15 +1,18 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import {
-    IExecuteFunctions,
-    INodeProperties,
-    INodeExecutionData,
-    NodeOperationError,
-} from 'n8n-workflow';
-import {
+    FileMetadata,
     getFileMetadata,
     getFileMetadataByLimeobject,
 } from '../../../transport';
-import { METADATA_RESOURCE } from '../../../commons';
+import { METADATA_RESOURCE } from '../../../models';
+import { APIResponse, WorkflowResponse } from '../../../../response';
+import { handleWorkflowError } from '../../../../errorHandling';
 
+/**
+ * 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 +20,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,33 +111,40 @@ 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<WorkflowResponse<FileMetadata>> {
     const source = this.getNodeParameter('source', i) as string;
     const id = this.getNodeParameter('identifier', i) as string;
+    let response: APIResponse<FileMetadata>;
 
     if (source == 'byFile') {
-        return {
-            json: await getFileMetadata(this, id),
-        };
-    }
-    if (source == 'byLimeobject') {
+        response = await getFileMetadata(this, id);
+    } else 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
-            ),
-        };
+        response = await getFileMetadataByLimeobject(
+            this,
+            limetype,
+            id,
+            property
+        );
+    } else {
+        response = handleWorkflowError(this, {
+            message: `The source "${source} is not supported`,
+        });
     }
-
-    throw new NodeOperationError(
-        this.getNode(),
-        `The source "${source}" is not supported!`
-    );
+    return response.data;
 }

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

@@ -1,7 +1,13 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { getLimetype } from '../../../transport/limetypes';
-import { METADATA_RESOURCE } from '../../../commons';
+import { Limetype, METADATA_RESOURCE } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
+/**
+ * Description and metadata for the "Get Single Limetype" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Get Single Limetype',
     value: 'getSingleLimetype',
@@ -9,6 +15,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,8 +42,22 @@ export const properties: INodeProperties[] = [
     },
 ];
 
-export async function execute(this: IExecuteFunctions, i: number) {
+/**
+ * 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
+): Promise<WorkflowResponse<Limetype>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
 
-    return getLimetype(this, limetype);
+    const response = await getLimetype(this, limetype);
+    return response.data;
 }

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';