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

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

@@ -1,13 +1,20 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { createLimeobject } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
+import { createLimeobject, getProperties } from '../../../transport';
+import { DATA_RESOURCE } from '../../../models';
 import {
-    getFileProperties,
+    getFilePropertiesNames,
     processFileResponse,
     setFileProperties,
-} from '../../../commons/files';
+} from '../../../utils';
 
+import { parseResourceMapperFields } from '../../../methods';
+
+/**
+ * Description and metadata for the "Create Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Create Single Object',
     value: 'createSingleObject',
@@ -15,6 +22,16 @@ export const description = {
     action: 'Create single object',
 };
 
+/**
+ * Node properties for the "Create Single Object" operation.
+ *
+ * @param {string} limetype - The type of entity to create
+ * @param {'fields' | 'json'} inputMethod - How the user provides object data: 'fields' for form inputs, 'json' for raw JSON
+ * @param {Array<{ name: string; value: string }>} properties - Used if inputMethod is 'fields'. List of property name/value pairs to set on the object
+ * @param {string} objectJson - Used if inputMethod is 'json'. The full object data in JSON format
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Limetype',
@@ -59,12 +76,20 @@ export const properties: INodeProperties[] = [
     {
         displayName: 'Properties',
         name: 'properties',
-        type: 'fixedCollection',
+        type: 'resourceMapper',
         placeholder: 'Add Property',
         typeOptions: {
-            multipleValues: true,
+            resourceMapper: {
+                resourceMapperMethod: 'getCreateMappingColumns',
+                mode: 'add',
+                addAllFields: false,
+                supportAutoMap: false,
+            },
+            loadOptionsDependsOn: ['limetype'],
+        },
+        default: {
+            value: null,
         },
-        default: {},
         displayOptions: {
             show: {
                 resource: [DATA_RESOURCE],
@@ -72,33 +97,6 @@ export const properties: INodeProperties[] = [
                 inputMethod: ['fields'],
             },
         },
-        options: [
-            {
-                displayName: 'Property',
-                name: 'property',
-                values: [
-                    {
-                        displayName: 'Property Name',
-                        name: 'name',
-                        type: 'options',
-                        typeOptions: {
-                            sortable: true,
-                            loadOptionsMethod: 'getLimetypeProperties',
-                            loadOptionsDependsOn: ['limetype'],
-                        },
-                        default: '',
-                        description: 'Name of the property',
-                    },
-                    {
-                        displayName: 'Property Value',
-                        name: 'value',
-                        type: 'string',
-                        default: '',
-                        description: 'Value of the property',
-                    },
-                ],
-            },
-        ],
     },
     {
         displayName: 'Object (JSON)',
@@ -119,35 +117,46 @@ export const properties: INodeProperties[] = [
     },
 ];
 
+/**
+ * Execute the "Create Single Object" operation for Lime CRM.
+ *
+ * @param i - The index of the current item in the workflow execution
+ * @remarks
+ * This method handles creating a single Lime CRM object. It supports two input methods:
+ * - `fields`: where the user provides property values via form fields.
+ * - `json`: where the user provides a full JSON object representing the entity.
+ *
+ * The method performs the following steps:
+ * 1. Reads the limetype and input method from node parameters.
+ * 2. Parses input data according to the selected input method.
+ * 3. Resolves any file properties present in the object and sets the file properties on the object.
+ * 4. Sends a request to the Lime API to create the object.
+ * 5. Processes any returned file data and formats the response.
+ *
+ * @returns The newly created Lime object.
+ *
+ * @public
+ */
 export async function execute(this: IExecuteFunctions, i: number) {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const inputMethod = this.getNodeParameter('inputMethod', i) as string;
 
     let objectData: IDataObject;
 
+    const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) return propertiesResponse.data;
+
+    const properties = propertiesResponse.data;
+
     if (inputMethod === 'json') {
         const jsonInput = this.getNodeParameter('objectJson', i) as string;
         objectData = JSON.parse(jsonInput);
     } else {
-        objectData = {};
-        const propertiesInput = this.getNodeParameter(
-            'properties.property',
-            i,
-            []
-        ) as IDataObject[];
-
-        if (propertiesInput && propertiesInput.length > 0) {
-            for (const prop of propertiesInput) {
-                if (prop.name && prop.value !== undefined) {
-                    objectData[prop.name as string] = prop.value;
-                }
-            }
-        }
+        objectData = parseResourceMapperFields(this, i, 'properties');
     }
 
-    const fileProperties = await getFileProperties(
-        this,
-        limetype,
+    const fileProperties = getFilePropertiesNames(
+        properties,
         new Set(Object.keys(objectData))
     );
 
@@ -157,19 +166,20 @@ export async function execute(this: IExecuteFunctions, i: number) {
         fileProperties,
         objectData
     );
-    if (!setFilePropertiesResponse.success) return setFilePropertiesResponse;
+    if (!setFilePropertiesResponse.success)
+        return setFilePropertiesResponse.data;
 
     const createLimeobjectResponse = await createLimeobject(
         this,
         limetype,
         setFilePropertiesResponse.data
     );
-    if (!createLimeobjectResponse.success) return createLimeobjectResponse;
+    if (!createLimeobjectResponse.success) return createLimeobjectResponse.data;
 
     const response = await processFileResponse(
         this,
         fileProperties,
         createLimeobjectResponse.data
     );
-    return response.json;
+    return response.json.data;
 }

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

@@ -1,8 +1,14 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { deleteLimeobject } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
+import { DATA_RESOURCE } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
+/**
+ * Description and metadata for the "Delete Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Delete Single Object',
     value: 'deleteSingleObject',
@@ -10,8 +16,16 @@ export const description = {
     action: 'Delete single object',
 };
 
+/**
+ * Node properties for the "Delete Single Object" operation.
+ *
+ *
+ * @param {string} limetype - The type of entity to delete. Loaded from available Limetypes
+ * @param {string} objectId - The ID of the object to delete
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
-    // Limetype selection
     {
         displayName: 'Limetype',
         name: 'limetype',
@@ -29,8 +43,6 @@ export const properties: INodeProperties[] = [
             },
         },
     },
-
-    // Object ID
     {
         displayName: 'Object ID',
         name: 'objectId',
@@ -47,9 +59,30 @@ export const properties: INodeProperties[] = [
     },
 ];
 
-export async function execute(this: IExecuteFunctions, i: number) {
+/**
+ * Execute the "Delete Single Object" operation for Lime CRM.
+ *
+ * @remarks
+ * This operation deletes a single Lime CRM object identified by its object ID.
+ * The object type is determined by the selected limetype.
+ *
+ * The method performs the following steps:
+ * 1. Retrieves the `limetype` and `objectId` from {@link properties}.
+ * 2. Calls the {@link deleteLimeobject} function to delete the object from Lime CRM.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The response from the Lime API after attempting deletion.
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<WorkflowResponse<Record<string, never>>> {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const objectId = this.getNodeParameter('objectId', i) as string;
 
-    return await deleteLimeobject(this, limetype, objectId);
+    const response = await deleteLimeobject(this, limetype, objectId);
+    return response.data;
 }

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

@@ -1,8 +1,14 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { queryLimeobjects } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
+import { IncludedProperties, queryLimeobjects } from '../../../transport';
+import { DATA_RESOURCE, DEFAULT_API_OBJECT_LIMIT } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
+/**
+ * Description and metadata for the "Get Many Objects" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Get Many Objects',
     value: 'getManyObjects',
@@ -10,14 +16,54 @@ export const description = {
     action: 'Get many objects',
 };
 
-const BATCHSIZE = 50;
+/**
+ * Maximum number of objects to fetch in a single API request.
+ * @internal
+ */
+const BATCHSIZE = 200;
 
+/**
+ * Structure of the response format when querying Lime CRM objects.
+ *
+ * @remarks
+ * This is used to define which properties are included in the API response.
+ * The keys of the `object` correspond to property names of the entity,
+ * and the values are initialized as empty strings.
+ *
+ * @example
+ * {
+ *   object: {
+ *     _id: '',
+ *     name: '',
+ *     phone: ''
+ *   }
+ * }
+ *
+ * @internal
+ */
 interface ResponseFormat {
     object: {
         [key: string]: string;
     };
 }
 
+/**
+ * Defines a collection of properties to order query results by.
+ *
+ * @remarks
+ * Each entry specifies a property name and the direction in which the results
+ * should be sorted. Multiple fields can be provided to perform multi-level sorting.
+ *
+ * @example
+ * {
+ *   orderByFields: [
+ *     { propertyName: 'name', sortDirection: 'ASC' },
+ *     { propertyName: 'createdAt', sortDirection: 'DESC' }
+ *   ]
+ * }
+ *
+ * @internal
+ */
 interface OrderByCollection {
     orderByFields: {
         propertyName: string;
@@ -25,6 +71,21 @@ interface OrderByCollection {
     }[];
 }
 
+/**
+ * Node properties for the "Get Many Objects" operation.
+ *
+ * @param {string} limetype - The type of entity to query. Loaded from available Limetypes
+ * @param {'fields' | 'json'} responseFormatInputMethod - How to format the response
+ * @param {Array<{ name: string }>} responseFormatProperties - The properties to include if using 'fields'
+ * @param {string} responseFormatJson - JSON defining the response structure if using 'json'
+ * @param {string} filter - JSON defining filtering conditions
+ * @param {number} limit - Maximum number of objects to return
+ * @param {'fields' | 'json'} orderByInputMethod - How to specify ordering
+ * @param {OrderByCollection} orderByProperties - Order by fields if using 'fields'
+ * @param {string} orderByJson - JSON defining ordering if using 'json'
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Limetype',
@@ -137,7 +198,7 @@ export const properties: INodeProperties[] = [
         displayName: 'Limit',
         name: 'limit',
         type: 'number',
-        default: 50,
+        default: DEFAULT_API_OBJECT_LIMIT,
         description: 'The maximum number of records to return',
         displayOptions: {
             show: {
@@ -238,7 +299,30 @@ export const properties: INodeProperties[] = [
     },
 ];
 
-function _createResponseFormatObject(
+/**
+ * Create the response format object when using 'fields' mode.
+ *
+ * @remarks
+ * This function takes an array of property descriptors (each with a `name` field)
+ * and constructs a response object suitable for Lime CRM queries. It initializes
+ * each property with an empty string, ensuring that all requested fields are
+ * included in the response, even if the values are not yet set.
+ *
+ * Additionally, it always includes a default `_id` field in the response object,
+ * which is typically required by Lime CRM for object identification.
+ *
+ * Example:
+ * ```ts
+ * createResponseFormatObject([{ name: 'name' }, { name: 'email' }]);
+ * // Returns: { object: { _id: '', name: '', email: '' } }
+ * ```
+ *
+ * @param properties - Array of property descriptors.
+ * @returns The ResponseFormat object.
+ *
+ * @internal
+ */
+function createResponseFormatObject(
     properties: { name: string }[] = []
 ): ResponseFormat {
     const object: Record<string, string> = { _id: '' };
@@ -248,7 +332,34 @@ function _createResponseFormatObject(
     return { object };
 }
 
-function _getOrderBy(orderByCollection: OrderByCollection) {
+/**
+ * Generate the ordering array for Lime CRM queries.
+ *
+ * @remarks
+ * This function transforms a user-provided `OrderByCollection` object into the
+ * format required by the Lime CRM API. Each property in `orderByFields` is
+ * converted into a key-value pair where the key is the property name and the
+ * value is the sort direction ('ASC' or 'DESC').
+ *
+ * If no `orderByFields` are provided, it defaults to ordering by `_id` ascending.
+ *
+ * Example:
+ * ```ts
+ * getOrderBy({
+ *   orderByFields: [
+ *     { propertyName: 'name', sortDirection: 'ASC' },
+ *     { propertyName: 'createdAt', sortDirection: 'DESC' },
+ *   ]
+ * });
+ * // Returns: [{ name: 'ASC' }, { createdAt: 'DESC' }]
+ * ```
+ *
+ * @param orderByCollection - Collection of order-by fields provided by the user.
+ * @returns An array of objects representing the order-by configuration for Lime CRM.
+ *
+ * @internal
+ */
+function getOrderBy(orderByCollection: OrderByCollection) {
     const orderBy =
         orderByCollection.orderByFields &&
         orderByCollection.orderByFields.map((field) => ({
@@ -257,57 +368,89 @@ function _getOrderBy(orderByCollection: OrderByCollection) {
     return orderBy || [{ _id: 'ASC' }];
 }
 
-async function _fetchLimeObjectsInBatches(
+/**
+ * Fetch Lime CRM objects in batches to handle large result sets or unlimited queries.
+ *
+ * @remarks
+ * This function retrieves objects from Lime CRM for a given limetype by performing
+ * multiple sequential API calls, each fetching up to BATCHSIZE records.
+ *
+ * @param limetype - The type of Lime CRM entity to fetch
+ * @param responseFormat - The format in which objects should be returned, defining which properties are included
+ * @param filter - JSON string representing the filter conditions for the query
+ * @param limit - Maximum number of objects to fetch in this request
+ * @param orderBy - Array of objects defining the sorting of the results
+ *
+ * @returns Array of fetched objects or an error response as an array.
+ */
+async function fetchLimeObjects(
     this: IExecuteFunctions,
     limetype: string,
     responseFormat: ResponseFormat,
     filter: string,
-    limit: number,
-    orderBy: Array<{ [key: string]: 'ASC' | 'DESC' }>
-) {
-    if (limit <= BATCHSIZE) {
+    limit: number | null,
+    orderBy: Record<string, 'ASC' | 'DESC'>[]
+): Promise<WorkflowResponse<IncludedProperties[]>> {
+    const allResults: IncludedProperties[] = [];
+    const parsedFilter = JSON.parse(filter);
+    const unlimited = limit === null || limit === 0;
+    const targetLimit = unlimited ? Infinity : limit;
+
+    let fetched = 0;
+    let currentOffset = 0;
+
+    while (fetched < targetLimit) {
+        const currentLimit =
+            targetLimit === Infinity
+                ? BATCHSIZE
+                : Math.min(BATCHSIZE, targetLimit - fetched);
+
         const q = JSON.stringify({
             limetype,
             responseFormat: responseFormat,
-            filter: JSON.parse(filter),
-            limit: limit,
-            offset: 0,
+            filter: parsedFilter,
+            limit: currentLimit,
+            offset: currentOffset,
             orderBy: orderBy,
         });
-        return queryLimeobjects(this, q);
-    } else {
-        let allResults: unknown[] = [];
-        let fetched = 0;
-        let currentOffset = 0;
-        while (fetched < limit) {
-            const currentLimit = Math.min(BATCHSIZE, limit - fetched);
-            const q = JSON.stringify({
-                limetype,
-                responseFormat: responseFormat,
-                filter: JSON.parse(filter),
-                limit: currentLimit,
-                offset: currentOffset,
-                orderBy,
-            });
-            const batch = await queryLimeobjects(this, q);
-            if (!batch.success) {
-                return batch;
-            }
-            const collected = batch.data.objects.length;
-            if (!batch || collected === 0) break;
-            allResults = [...allResults, ...batch.data.objects];
-            fetched += collected;
-            currentOffset += collected;
 
-            if (collected < currentLimit) break;
-        }
-        return {
-            success: true,
-            data: allResults,
-        };
+        const batchResponse = await queryLimeobjects(this, q);
+        if (!batchResponse.success) return batchResponse.data;
+
+        const batch = batchResponse.data;
+
+        const collected = batch.objects.length;
+        if (collected === 0) break;
+
+        allResults.push(...batch.objects);
+
+        fetched += collected;
+        currentOffset += collected;
+
+        if (collected < currentLimit) break;
     }
+
+    return allResults;
 }
 
+/**
+ * Execute the "Get Many Objects" operation for Lime CRM.
+ *
+ * @remarks
+ * Retrieves multiple Lime CRM objects of the selected limetype with optional filtering, ordering, and response formatting.
+ * The method supports batch fetching if the requested limit exceeds 50 records.
+ *
+ * Steps performed by the method:
+ * 1. Determine the limetype and response format (fields or JSON) from {@link properties}.
+ * 2. Determine ordering (fields or JSON) from {@link properties}.
+ * 3. Fetch data from Lime CRM, handling batching if necessary.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns The fetched Lime objects as per the requested response format.
+ *
+ * @public
+ */
 export async function execute(this: IExecuteFunctions, i: number) {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const responseFormatInputMethod = this.getNodeParameter(
@@ -319,7 +462,11 @@ export async function execute(this: IExecuteFunctions, i: number) {
         i
     ) as string;
     const filter = this.getNodeParameter('filter', i) as string;
-    const limit = this.getNodeParameter('limit', i, 50) as number;
+    const limit = this.getNodeParameter(
+        'limit',
+        i,
+        DEFAULT_API_OBJECT_LIMIT
+    ) as number;
 
     let response;
     if (responseFormatInputMethod === 'fields') {
@@ -327,7 +474,7 @@ export async function execute(this: IExecuteFunctions, i: number) {
             'responseFormatProperties',
             i
         ) as { property: [{ name: string }] };
-        response = _createResponseFormatObject(properties.property);
+        response = createResponseFormatObject(properties.property);
     } else if (responseFormatInputMethod === 'json') {
         response = this.getNodeParameter('responseFormatJson', i) as string;
         response = JSON.parse(response);
@@ -339,13 +486,13 @@ export async function execute(this: IExecuteFunctions, i: number) {
             'orderByProperties',
             i
         ) as OrderByCollection;
-        orderBy = _getOrderBy(orderByCollection);
+        orderBy = getOrderBy(orderByCollection);
     } else if (orderByInputMethod === 'json') {
         orderBy = this.getNodeParameter('orderByJson', i) as string;
         orderBy = JSON.parse(orderBy);
     }
 
-    return await _fetchLimeObjectsInBatches.call(
+    return await fetchLimeObjects.call(
         this,
         limetype,
         response,

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

@@ -1,11 +1,17 @@
 import {
     IExecuteFunctions,
+    INodeExecutionData,
     INodeProperties,
     NodeOperationError,
 } from 'n8n-workflow';
 import { getFileContent, getFileContentByLimetype } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
+import { DATA_RESOURCE } from '../../../models';
 
+/**
+ * Description and metadata for the "Get Single File" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Get Single File',
     value: 'getSingleFile',
@@ -13,6 +19,16 @@ export const description = {
     action: 'Get single file',
 };
 
+/**
+ * Node properties for the "Get Single File" operation.
+ *
+ * @param {('byFile' | 'byLimeobject')} source - Determines if the file should be fetched by its file ID or by its associated Limeobject ID
+ * @param {string} limetype - Required if fetching by Limeobject. Specifies the type of Lime CRM entity associated with the file
+ * @param {string} identifier - The ID of the file or the associated Limeobject to retrieve
+ * @param {string} property - Required if fetching by Limeobject. Specifies the file type property to fetch
+ *
+ * @public
+ */
 export const properties: INodeProperties[] = [
     {
         displayName: 'Get by',
@@ -94,18 +110,37 @@ export const properties: INodeProperties[] = [
     },
 ];
 
-export async function execute(this: IExecuteFunctions, i: number) {
+/**
+ * Execute the "Get Single File" operation for Lime CRM.
+ *
+ * @remarks
+ * This method retrieves file data from Lime CRM based on the selected source:
+ * - 'byFile': Fetches the file using its unique file ID.
+ * - 'byLimeobject': Fetches the file using an associated Limeobject ID and the specified file type property.
+ *
+ * The method returns an object containing the JSON response and the file's binary data.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns An object containing `json` and `binary` fields with the file data.
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<INodeExecutionData> {
     const source = this.getNodeParameter('source', i) as string;
     const id = this.getNodeParameter('identifier', i) as string;
 
     if (source == 'byFile') {
         const fileResponse = await getFileContent(this, id);
-        if (!fileResponse.success) {
-            return { json: fileResponse };
-        }
-
+        if (!fileResponse.success)
+            return {
+                json: fileResponse.data,
+            };
         return {
-            json: { success: fileResponse.success },
+            json: {},
             binary: { data: fileResponse.data },
         };
     }
@@ -119,12 +154,13 @@ export async function execute(this: IExecuteFunctions, i: number) {
             id,
             property
         );
-        if (!fileResponse.success) {
-            return { json: fileResponse };
-        }
+        if (!fileResponse.success)
+            return {
+                json: fileResponse.data,
+            };
 
         return {
-            json: { success: fileResponse.success },
+            json: {},
             binary: {
                 data: fileResponse.data,
             },