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

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

@@ -0,0 +1,116 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { getLimeobject, getProperties } from '../../../transport';
+import { DATA_RESOURCE } from '../../../models';
+import { getFilePropertiesNames, processFileResponse } from '../../../utils';
+
+/**
+ * Description and metadata for the "Get Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
+export const description = {
+    name: 'Get Single Object',
+    value: 'getSingleObject',
+    description: 'Get one specific object',
+    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',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to retrieve',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleObject'],
+            },
+        },
+    },
+
+    {
+        displayName: 'Object ID',
+        name: 'objectId',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the object to retrieve',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleObject'],
+            },
+        },
+    },
+    {
+        displayName: 'Include file content',
+        name: 'includeFileContent',
+        type: 'boolean',
+        default: false,
+        description:
+            'Include file binary data if the Limetype has any file properties. ' +
+            'Keep performance in mind before activating this. ' +
+            'For Limetypes without any file properties, this setting is ignored.',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleObject'],
+            },
+        },
+    },
+];
+
+/**
+ * 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) {
+    const limetype = this.getNodeParameter('limetype', i) as string;
+    const objectId = this.getNodeParameter('objectId', i) as string;
+    const includeFileContent = this.getNodeParameter(
+        'includeFileContent',
+        i
+    ) as boolean;
+
+    const limeObjectResponse = await getLimeobject(this, limetype, objectId);
+
+    const propertiesResponse = await getProperties(this, limetype);
+
+    const fileProperties = getFilePropertiesNames(propertiesResponse);
+    return processFileResponse(
+        this,
+        fileProperties,
+        limeObjectResponse,
+        includeFileContent
+    );
+}

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/{limeObject/operations/update.operation.ts → data/operations/updateSingleObject.operation.ts}

@@ -1,30 +1,52 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { updateLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
+import { getProperties, updateLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../models';
+import {
+    adaptProperty,
+    getFilePropertiesNames,
+    getPropertyType,
+    processFileResponse,
+    setFileProperties,
+} from '../../../utils';
 
-// Input fields for update operation
+/**
+ * Description and metadata for the "Update Single Object" operation in Lime CRM.
+ *
+ * @public
+ */
 export const description = {
-    name: 'Update',
-    value: 'update',
-    description: 'Update an existing record',
-    action: 'Update a record',
+    name: 'Update Single Object',
+    value: 'updateSingleObject',
+    description: 'Update one specific object',
+    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',
-        name: 'limeType',
+        displayName: 'Limetype',
+        name: 'limetype',
         type: 'options',
         typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
+            loadOptionsMethod: 'getLimetypes',
         },
         required: true,
         default: '',
         description: 'The type of entity to update',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
             },
         },
     },
@@ -37,8 +59,8 @@ export const properties: INodeProperties[] = [
         description: 'ID of the record to update',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
             },
         },
     },
@@ -62,8 +84,8 @@ export const properties: INodeProperties[] = [
         description: 'How to input the data',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
             },
         },
     },
@@ -80,8 +102,8 @@ export const properties: INodeProperties[] = [
         },
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
                 inputType: ['json'],
             },
         },
@@ -98,8 +120,8 @@ export const properties: INodeProperties[] = [
         default: {},
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['update'],
+                resource: [DATA_RESOURCE],
+                operation: ['updateSingleObject'],
                 inputType: ['simple'],
             },
         },
@@ -113,8 +135,8 @@ export const properties: INodeProperties[] = [
                         name: 'fieldName',
                         type: 'options',
                         typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
+                            loadOptionsMethod: 'getNoHasManyProperties',
+                            loadOptionsDependsOn: ['limetype'],
                         },
                         default: '',
                         description: 'The name of the field',
@@ -132,13 +154,36 @@ export const properties: INodeProperties[] = [
     },
 ];
 
+/**
+ * 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) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
+    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 properties = await getProperties(this, limetype);
+
     if (inputType === 'json') {
         const jsonData = this.getNodeParameter('jsonData', i) as string;
         body = JSON.parse(jsonData);
@@ -149,9 +194,30 @@ export async function execute(this: IExecuteFunctions, i: number) {
             []
         ) as IDataObject[];
         for (const field of simpleFields) {
-            body[field.fieldName as string] = field.fieldValue;
+            const fieldName = field.fieldName as string;
+            const fieldValue = field.fieldValue as string;
+            body[fieldName] = adaptProperty(
+                fieldValue,
+                getPropertyType(fieldName, properties)
+            );
         }
     }
 
-    return updateLimeObject(this, limeType, id, body);
+    const fileProperties = getFilePropertiesNames(properties);
+
+    await setFileProperties(this, i, fileProperties, body);
+
+    const updateLimeobjectResponse = await updateLimeobject(
+        this,
+        limetype,
+        id,
+        body
+    );
+
+    const response = await processFileResponse(
+        this,
+        fileProperties,
+        updateLimeobjectResponse
+    );
+    return response.json;
 }

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

@@ -0,0 +1,97 @@
+import {
+    INodeExecutionData,
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+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',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+            },
+        },
+        options: moduleHandler.getDescriptions(),
+        default: 'getAllLimetypes',
+    },
+
+    ...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 | INodeExecutionData[]> {
+    switch (operation) {
+        case 'getAllLimetypes': {
+            const results = await operations.getAllLimetypes.execute.call(this);
+            return results.map((limetype) => ({
+                json: limetype,
+            }));
+        }
+        case 'getSingleLimetype': {
+            return {
+                json: await operations.getSingleLimetype.execute.call(this, i),
+            };
+        }
+        case 'getSingleFileMetadata': {
+            return {
+                json: await operations.getSingleFileMetadata.execute.call(
+                    this,
+                    i
+                ),
+            };
+        }
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The operation "${operation}" is not supported!`
+    );
+}
+
+export * from './operations';

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

@@ -0,0 +1,28 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+
+import { getLimetypesFromApi } from '../../../transport';
+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',
+    description: 'Get a list of all available Limetypes',
+    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<Limetype[]> {
+    return await getLimetypesFromApi(this);
+}

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

@@ -0,0 +1,147 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+import {
+    FileMetadata,
+    getFileMetadata,
+    getFileMetadataByLimeobject,
+} from '../../../transport';
+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',
+    description: 'Get the metadata for a single file',
+    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',
+        name: 'source',
+        type: 'options',
+        required: true,
+        placeholder: 'Add Source',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+            },
+        },
+        options: [
+            {
+                name: 'File ID',
+                value: 'byFile',
+                description: 'Get file by its ID',
+            },
+            {
+                name: 'Limeobject ID',
+                value: 'byLimeobject',
+                description: "Get file by it's associated Limeobject ID",
+            },
+        ],
+        default: 'byFile',
+    },
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity associated with the file',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+    {
+        displayName: 'Identifier',
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the file or Limeobject to retrieve',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+            },
+        },
+        placeholder: 'e.g., 12345',
+    },
+    {
+        displayName: 'File type property',
+        name: 'property',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getFileProperties',
+            loadOptionsDependsOn: ['limetype'],
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity associated with the file',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+];
+
+/**
+ * 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<FileMetadata> {
+    const source = this.getNodeParameter('source', i) as string;
+    const id = this.getNodeParameter('identifier', i) as string;
+
+    if (source == 'byFile') {
+        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 await getFileMetadataByLimeobject(this, limetype, id, property);
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The source "${source}" is not supported!`
+    );
+}

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

@@ -0,0 +1,58 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { getLimetype } from '../../../transport/limetypes';
+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',
+    description: 'Get details about a specific Limetype',
+    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',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The name of the entity type to get details for',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleLimetype'],
+            },
+        },
+    },
+];
+
+/**
+ * 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;
+
+    return getLimetype(this, limetype);
+}

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