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

package/nodes/lime-crm/resources/admin/operations/getSingleUser.operation.ts

@@ -0,0 +1,113 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+import { User, ADMIN_RESOURCE } from '../../../models';
+import {
+    fetchSingleUserById,
+    fetchSingleUserByLimeobjectId,
+} from '../../../transport';
+
+export const description = {
+    name: 'Get single user',
+    value: 'getSingleUser',
+    description: 'Get a single user data',
+    action: 'Get single user',
+};
+
+/**
+ * Node properties for the "Get Single User" operation.
+ *
+ * @param {string} id - The ID of the user to retrieve
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Get by',
+        name: 'source',
+        type: 'options',
+        required: true,
+        placeholder: 'Add Source',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getSingleUser'],
+            },
+        },
+        options: [
+            {
+                name: 'User ID',
+                value: 'byUser',
+                description: 'Get user by its ID',
+            },
+            {
+                name: 'Limeobject ID',
+                value: 'byLimeobject',
+                description: "Get user by it's related Limeobject ID",
+            },
+        ],
+        default: 'byUser',
+    },
+    {
+        displayName: 'Identifier',
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the user or Limeobject to retrieve',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getSingleUser'],
+            },
+        },
+    },
+    {
+        displayName: 'Include Coworker',
+        name: 'withCoworker',
+        type: 'boolean',
+        default: '',
+        description: 'Whether to include coworker data in the response',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getSingleUser'],
+            },
+        },
+    },
+];
+/**
+ * Execute the "Get Single Object" operation for Lime CRM.
+ *
+ * @remarks
+ * This method retrieves a single Lime CRM user identified by its ID.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns User data.
+ *
+ * @public
+ */
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<User> {
+    const source = this.getNodeParameter('source', i) as string;
+    const id = this.getNodeParameter('identifier', i) as string;
+    const withCoworker = this.getNodeParameter('withCoworker', i) as boolean;
+
+    if (source == 'byUser') {
+        return await fetchSingleUserById(this, id, withCoworker);
+    }
+    if (source == 'byLimeobject') {
+        return await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The source "${source}" is not supported!`
+    );
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @group Resources
+ */
+export * as getManyUsers from './getManyUsers.operation';
+/**
+ * @group Resources
+ */
+export * as getSingleUser from './getSingleUser.operation';

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

@@ -6,15 +6,40 @@ import {
     NodeOperationError,
 } from 'n8n-workflow';
 
-import * as createSingleObject from './operations/createSingleObject';
-import * as getSingleObject from './operations/getSingleObject';
-import * as updateSingleObject from './operations/updateSingleObject.operation';
-import * as deleteSingleObject from './operations/deleteSingleObject';
-import * as getManyObjects from './operations/getManyObjects';
-import * as getSingleFile from './operations/getSingleFile';
+import * as operations from './operations';
 
-import { DATA_RESOURCE } from '../../commons';
+import { DATA_RESOURCE } from '../../models';
+import { N8NOperationModuleHandler } from '../../../modules';
 
+/**
+ * List of modules consisting data operations
+ */
+const moduleHandler = new N8NOperationModuleHandler([
+    operations.createSingleObject,
+    operations.getSingleObject,
+    operations.updateSingleObject,
+    operations.deleteSingleObject,
+    operations.getManyObjects,
+    operations.getSingleFile,
+]);
+
+/**
+ * Fields and operations for the **Data** resource in Lime CRM.
+ *
+ * @remarks
+ * - These fields are displayed in the n8n node UI when the resource is set to `Data`.
+ * - Each operation corresponds to a CRUD action or a file retrieval for Lime objects.
+ *
+ * @group Resources
+ * @public
+ *
+ * @see {@link createSingleObject} - Operation to create a single Limeobject
+ * @see {@link getSingleObject} - Operation to retrieve a single Limeobject by ID
+ * @see {@link updateSingleObject} - Operation to update a single Limeobject by ID
+ * @see {@link deleteSingleObject} - Operation to delete a single Limeobject by ID
+ * @see {@link getManyObjects} - Operation to fetch multiple Limeobjects based on search criteria
+ * @see {@link getSingleFile} - Operation to retrieve a single from Lime CRM
+ */
 export const dataFields: INodeProperties[] = [
     {
         displayName: 'Operation',
@@ -26,50 +51,60 @@ export const dataFields: INodeProperties[] = [
                 resource: [DATA_RESOURCE],
             },
         },
-        options: [
-            createSingleObject.description,
-            getSingleObject.description,
-            updateSingleObject.description,
-            deleteSingleObject.description,
-            getManyObjects.description,
-            getSingleFile.description,
-        ],
+        options: moduleHandler.getDescriptions(),
         default: 'fetchMany',
     },
 
-    ...createSingleObject.properties,
-    ...getSingleObject.properties,
-    ...updateSingleObject.properties,
-    ...deleteSingleObject.properties,
-    ...getSingleFile.properties,
-    ...getManyObjects.properties,
+    ...moduleHandler.getProperties(),
 ];
 
+/**
+ * Execute a specific **Data** operation on Lime CRM objects.
+ *
+ * @param args - Contextual parameters for the operation being executed
+ * @param args.operation - The operation to perform (e.g., `createSingleObject`, `getManyObjects`)
+ * @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 dataOperations(
     this: IExecuteFunctions,
     { operation, i }: { operation: string; i: number }
-): Promise<INodeExecutionData> {
+): Promise<INodeExecutionData | INodeExecutionData[]> {
     switch (operation) {
         case 'createSingleObject': {
-            return { json: await createSingleObject.execute.call(this, i) };
+            return {
+                json: await operations.createSingleObject.execute.call(this, i),
+            };
         }
         case 'getSingleObject': {
-            return await getSingleObject.execute.call(this, i);
+            return await operations.getSingleObject.execute.call(this, i);
         }
         case 'updateSingleObject': {
-            return { json: await updateSingleObject.execute.call(this, i) };
+            return {
+                json: await operations.updateSingleObject.execute.call(this, i),
+            };
         }
         case 'deleteSingleObject': {
-            await deleteSingleObject.execute.call(this, i);
-            return { json: { success: true } };
+            await operations.deleteSingleObject.execute.call(this, i);
+            return { json: {} };
         }
         case 'getManyObjects': {
-            return {
-                json: await getManyObjects.execute.call(this, i),
-            };
+            const result = await operations.getManyObjects.execute.call(
+                this,
+                i
+            );
+            return result.map((item) => ({
+                json: item,
+            }));
         }
         case 'getSingleFile': {
-            return await getSingleFile.execute.call(this, i);
+            return await operations.getSingleFile.execute.call(this, i);
         }
     }
 
@@ -78,3 +113,5 @@ export async function dataOperations(
         `The operation "${operation}" is not supported!`
     );
 }
+
+export * from './operations';

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, LimetypeProperty } from '../../../models';
 import {
-    getFileProperties,
+    adaptProperty,
+    getFilePropertiesNames,
+    getPropertyType,
     processFileResponse,
     setFileProperties,
-} from '../../../commons/files';
+} from '../../../utils';
 
+/**
+ * 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',
@@ -83,7 +100,7 @@ export const properties: INodeProperties[] = [
                         type: 'options',
                         typeOptions: {
                             sortable: true,
-                            loadOptionsMethod: 'getLimetypeProperties',
+                            loadOptionsMethod: 'getNoHasManyProperties',
                             loadOptionsDependsOn: ['limetype'],
                         },
                         default: '',
@@ -119,35 +136,76 @@ export const properties: INodeProperties[] = [
     },
 ];
 
+/**
+ *
+ * @param context - Node execution context
+ * @param i - The index of the current item in the workflow execution
+ * @param properties - List of {@link LimeTypeProperty} fetched from Lime CRM
+ * @returns IDataObject - parsed data from Simple Fields mode
+ */
+function parseSimpleFieldsData(
+    context: IExecuteFunctions,
+    i: number,
+    properties: LimetypeProperty[]
+): IDataObject {
+    const objectData: IDataObject = {};
+    const propertiesInput = context.getNodeParameter(
+        'properties.property',
+        i,
+        []
+    ) as IDataObject[];
+
+    if (propertiesInput && propertiesInput.length > 0) {
+        for (const prop of propertiesInput) {
+            if (prop.name && prop.value !== undefined) {
+                const propertyName = prop.name as string;
+                objectData[propertyName] = adaptProperty(
+                    prop.value as string,
+                    getPropertyType(propertyName, properties)
+                );
+            }
+        }
+    }
+    return objectData;
+}
+
+/**
+ * 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 properties = await getProperties(this, limetype);
+
     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 = parseSimpleFieldsData(this, i, properties);
     }
 
-    const fileProperties = await getFileProperties(
-        this,
-        limetype,
+    const fileProperties = getFilePropertiesNames(
+        properties,
         new Set(Object.keys(objectData))
     );
 
@@ -157,19 +215,17 @@ export async function execute(this: IExecuteFunctions, i: number) {
         fileProperties,
         objectData
     );
-    if (!setFilePropertiesResponse.success) return setFilePropertiesResponse;
 
     const createLimeobjectResponse = await createLimeobject(
         this,
         limetype,
-        setFilePropertiesResponse.data
+        setFilePropertiesResponse
     );
-    if (!createLimeobjectResponse.success) return createLimeobjectResponse;
 
     const response = await processFileResponse(
         this,
         fileProperties,
-        createLimeobjectResponse.data
+        createLimeobjectResponse
     );
     return response.json;
 }

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

@@ -1,8 +1,13 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { deleteLimeobject } from '../../../transport';
-import { DATA_RESOURCE } from '../../../commons';
+import { DATA_RESOURCE } from '../../../models';
 
+/**
+ * Description and metadata for the "Delete Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
     name: 'Delete Single Object',
     value: 'deleteSingleObject',
@@ -10,8 +15,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 +42,6 @@ export const properties: INodeProperties[] = [
             },
         },
     },
-
-    // Object ID
     {
         displayName: 'Object ID',
         name: 'objectId',
@@ -47,6 +58,23 @@ export const properties: INodeProperties[] = [
     },
 ];
 
+/**
+ * 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) {
     const limetype = this.getNodeParameter('limetype', i) as string;
     const objectId = this.getNodeParameter('objectId', i) as string;