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

package/nodes/lime-crm/methods/resourceMapping.ts

@@ -0,0 +1,141 @@
+import {
+    FieldType,
+    ILoadOptionsFunctions,
+    ResourceMapperFields,
+    LoggerProxy as Logger,
+    IExecuteFunctions,
+    IDataObject,
+    ResourceMapperValue,
+} from 'n8n-workflow';
+import { getProperties } from '../transport';
+import { LimetypeProperty } from '../models';
+
+/**
+ * A map of Lime CRM field types to n8n native types
+ */
+const LimeCrmTypeToFieldType = new Map(
+    Object.entries({
+        option: 'options',
+        yesno: 'boolean',
+        decimal: 'number',
+        number: 'number',
+    })
+);
+
+/**
+ * Function which maps Lime CRM to n8n types using the map above. If the type
+ * is not declared in a map, string is used.
+ * @param limeCrmType
+ * @returns n8n native {@link FieldType}
+ */
+function mapLimeCrmType(limeCrmType: string): FieldType {
+    return (LimeCrmTypeToFieldType.get(limeCrmType) as FieldType) || 'string';
+}
+
+/**
+ * Get a `length` addition to the input headers when there's a string field
+ *
+ * @param property - a {@link LimetypeProperty}
+ * @returns a string with length wrapped in quotes or an empty string
+ */
+function getPropertyLength(property: LimetypeProperty): string {
+    return property.type === 'string' ? `(${property.length})` : '';
+}
+
+/**
+ * Base function to get the description of ResourceMapper fields
+ * @param nodeContext
+ * @param mode - either `create` or `update` - based on this flag a `required`
+ * @param limetype - name of a limetype we are creating or updating
+ * property is set
+ */
+async function getMappingColumns(
+    nodeContext: ILoadOptionsFunctions,
+    mode: 'create' | 'update',
+    limetype: string
+): Promise<ResourceMapperFields> {
+    const propertiesResponse = await getProperties(nodeContext, limetype);
+    if (!propertiesResponse.success) {
+        Logger.error(
+            `There was an error with fetching properties: ${JSON.stringify(propertiesResponse.data)}`
+        );
+        return {
+            fields: [],
+        };
+    }
+    const noRelationProperties = propertiesResponse.data.filter(
+        (property) => property.type !== 'hasmany'
+    );
+
+    const fields = noRelationProperties.map((property) => {
+        const propertyLengthDescription = getPropertyLength(property);
+        return {
+            id: property.name,
+            displayName: `${property.localname} [${property.type}${propertyLengthDescription}]`,
+            required: mode === 'create' ? property.required : false,
+            defaultMatch: false,
+            display: true,
+            type: mapLimeCrmType(property.type),
+            options:
+                property.type === 'option' && property.options
+                    ? property.options
+                          .filter((option) => !option.inactive)
+                          .map((option) => {
+                              return {
+                                  value: option.key,
+                                  name: option.text,
+                              };
+                          })
+                    : undefined,
+        };
+    });
+    return {
+        fields: fields.sort((a, b) => {
+            if (a.required !== b.required) {
+                return a.required ? -1 : 1;
+            }
+            return a.displayName.localeCompare(b.displayName);
+        }),
+    };
+}
+
+/**
+ * Parse resource mapper fields from n8n workflow
+ * @param context - Node execution context
+ * @param i - The index of the current item in the workflow execution
+ * @param inputName - name of the resource mapper input
+ * @returns IDataObject - parsed data from resource mapper
+ */
+
+export function parseResourceMapperFields(
+    context: IExecuteFunctions,
+    i: number,
+    inputName: string
+): IDataObject {
+    const propertiesInput = context.getNodeParameter(
+        inputName,
+        i
+    ) as ResourceMapperValue;
+
+    return propertiesInput.value as IDataObject;
+}
+
+/**
+ * Method for getting resource mapper fields in `create` mode
+ */
+export async function getCreateMappingColumns(
+    this: ILoadOptionsFunctions
+): Promise<ResourceMapperFields> {
+    const limetype = this.getNodeParameter('limetype') as string;
+    return getMappingColumns(this, 'create', limetype);
+}
+
+/**
+ * Method for getting resource mapper fields in `update` mode
+ */
+export async function getUpdateMappingColumns(
+    this: ILoadOptionsFunctions
+): Promise<ResourceMapperFields> {
+    const limetype = this.getNodeParameter('limetype') as string;
+    return getMappingColumns(this, 'update', limetype);
+}

package/nodes/lime-crm/models/limetype.ts

@@ -1,11 +1,26 @@
 import { APIResponseValue } from './constants';
 
+/**
+ * Limetype option used only for fields with `option` type.
+ * @property key - ID of an option, used as a value for POST/PUT requests in API
+ * @property text - display name of an option
+ * @property inactive - flag describing whether the property is used or not
+ */
+type LimetypePropertyOption = {
+    key: string;
+    text: string;
+    inactive: boolean;
+};
+
 /**
  * Representation of a property of a Limetype.
  *
  * @property name - The internal name of the property
  * @property localname - The display name of the property
  * @property type - The type of the property (e.g., string, file, hasmany)
+ * @property required - describes whether a property is required or not
+ * @property options - a set of {@link LimetypePropertyOption} used only for
+ * fields with type `option`.
  *
  * @public
  * @group Models
@@ -14,6 +29,9 @@ export type LimetypeProperty = {
     name: string;
     localname: string;
     type: string;
+    required: boolean;
+    length?: number;
+    options?: LimetypePropertyOption[];
 } & Record<string, APIResponseValue>;
 
 /**

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

@@ -68,10 +68,15 @@ export async function adminOperations(
     switch (operation) {
         case 'getManyUsers': {
             const result = await operations.getManyUsers.execute.call(this, i);
-
-            return result.map((item: User) => ({
-                json: item,
-            }));
+            if (Array.isArray(result)) {
+                return result.map((item: User) => ({
+                    json: item,
+                }));
+            } else {
+                return {
+                    json: result,
+                };
+            }
         }
         case 'getSingleUser': {
             return {

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

@@ -8,6 +8,7 @@ import {
     DEFAULT_API_OBJECT_LIMIT,
 } from '../../../models';
 import { fetchManyUsers } from '../../../transport';
+import { WorkflowResponse } from '../../../../response';
 
 export const description = {
     name: 'Get many users',
@@ -144,7 +145,7 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<User[]> {
+): Promise<WorkflowResponse<User[]>> {
     const active = this.getNodeParameter('active', i) as
         | boolean
         | NullOptionType;
@@ -162,5 +163,12 @@ export async function execute(
         i,
         false
     ) as boolean;
-    return await fetchManyUsers(this, active, userType, limit, withCoworker);
+    const response = await fetchManyUsers(
+        this,
+        active,
+        userType,
+        limit,
+        withCoworker
+    );
+    return response.data;
 }

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

@@ -1,14 +1,11 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodeOperationError,
-} from 'n8n-workflow';
-
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 import { User, ADMIN_RESOURCE } from '../../../models';
 import {
     fetchSingleUserById,
     fetchSingleUserByLimeobjectId,
 } from '../../../transport';
+import { WorkflowResponse, APIResponse } from '../../../../response';
+import { handleWorkflowError } from '../../../../errorHandling';
 
 export const description = {
     name: 'Get single user',
@@ -94,20 +91,22 @@ export const properties: INodeProperties[] = [
 export async function execute(
     this: IExecuteFunctions,
     i: number
-): Promise<User> {
+): Promise<WorkflowResponse<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;
 
+    let response: APIResponse<User>;
+
     if (source == 'byUser') {
-        return await fetchSingleUserById(this, id, withCoworker);
-    }
-    if (source == 'byLimeobject') {
-        return await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+        response = await fetchSingleUserById(this, id, withCoworker);
+    } else if (source == 'byLimeobject') {
+        response = await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+    } 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/data/index.ts

@@ -87,21 +87,30 @@ export async function dataOperations(
         }
         case 'updateSingleObject': {
             return {
-                json: await operations.updateSingleObject.execute.call(this, i),
+                ...(await operations.updateSingleObject.execute.call(this, i)),
             };
         }
         case 'deleteSingleObject': {
-            await operations.deleteSingleObject.execute.call(this, i);
-            return { json: {} };
+            const response = await operations.deleteSingleObject.execute.call(
+                this,
+                i
+            );
+            return { json: response };
         }
         case 'getManyObjects': {
             const result = await operations.getManyObjects.execute.call(
                 this,
                 i
             );
-            return result.map((item) => ({
-                json: item,
-            }));
+            if (Array.isArray(result)) {
+                return result.map((item) => ({
+                    json: item,
+                }));
+            } else {
+                return {
+                    json: result,
+                };
+            }
         }
         case 'getSingleFile': {
             return await operations.getSingleFile.execute.call(this, i);

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

@@ -1,15 +1,15 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { createLimeobject, getProperties } from '../../../transport';
-import { DATA_RESOURCE, LimetypeProperty } from '../../../models';
+import { DATA_RESOURCE } from '../../../models';
 import {
-    adaptProperty,
     getFilePropertiesNames,
-    getPropertyType,
     processFileResponse,
     setFileProperties,
 } from '../../../utils';
 
+import { parseResourceMapperFields } from '../../../methods';
+
 /**
  * Description and metadata for the "Create Single Object" operation in Lime CRM.
  *
@@ -76,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],
@@ -89,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: 'getNoHasManyProperties',
-                            loadOptionsDependsOn: ['limetype'],
-                        },
-                        default: '',
-                        description: 'Name of the property',
-                    },
-                    {
-                        displayName: 'Property Value',
-                        name: 'value',
-                        type: 'string',
-                        default: '',
-                        description: 'Value of the property',
-                    },
-                ],
-            },
-        ],
     },
     {
         displayName: 'Object (JSON)',
@@ -136,39 +117,6 @@ 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.
  *
@@ -195,13 +143,16 @@ export async function execute(this: IExecuteFunctions, i: number) {
 
     let objectData: IDataObject;
 
-    const properties = await getProperties(this, limetype);
+    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 = parseSimpleFieldsData(this, i, properties);
+        objectData = parseResourceMapperFields(this, i, 'properties');
     }
 
     const fileProperties = getFilePropertiesNames(
@@ -215,17 +166,20 @@ export async function execute(this: IExecuteFunctions, i: number) {
         fileProperties,
         objectData
     );
+    if (!setFilePropertiesResponse.success)
+        return setFilePropertiesResponse.data;
 
     const createLimeobjectResponse = await createLimeobject(
         this,
         limetype,
-        setFilePropertiesResponse
+        setFilePropertiesResponse.data
     );
+    if (!createLimeobjectResponse.success) return createLimeobjectResponse.data;
 
     const response = await processFileResponse(
         this,
         fileProperties,
-        createLimeobjectResponse
+        createLimeobjectResponse.data
     );
-    return response.json;
+    return response.json.data;
 }

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

@@ -2,6 +2,7 @@ import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { deleteLimeobject } from '../../../transport';
 import { DATA_RESOURCE } from '../../../models';
+import { WorkflowResponse } from '../../../../response';
 
 /**
  * Description and metadata for the "Delete Single Object" operation in Lime CRM.
@@ -75,9 +76,13 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+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.operation.ts

@@ -2,6 +2,7 @@ import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 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.
@@ -389,7 +390,7 @@ async function fetchLimeObjects(
     filter: string,
     limit: number | null,
     orderBy: Record<string, 'ASC' | 'DESC'>[]
-): Promise<IncludedProperties[]> {
+): Promise<WorkflowResponse<IncludedProperties[]>> {
     const allResults: IncludedProperties[] = [];
     const parsedFilter = JSON.parse(filter);
     const unlimited = limit === null || limit === 0;
@@ -413,7 +414,10 @@ async function fetchLimeObjects(
             orderBy: orderBy,
         });
 
-        const batch = await queryLimeobjects(this, q);
+        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;

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

@@ -1,5 +1,6 @@
 import {
     IExecuteFunctions,
+    INodeExecutionData,
     INodeProperties,
     NodeOperationError,
 } from 'n8n-workflow';
@@ -125,15 +126,22 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+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.data,
+            };
         return {
             json: {},
-            binary: { data: fileResponse },
+            binary: { data: fileResponse.data },
         };
     }
     if (source == 'byLimeobject') {
@@ -146,11 +154,15 @@ export async function execute(this: IExecuteFunctions, i: number) {
             id,
             property
         );
+        if (!fileResponse.success)
+            return {
+                json: fileResponse.data,
+            };
 
         return {
             json: {},
             binary: {
-                data: fileResponse,
+                data: fileResponse.data,
             },
         };
     }

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

@@ -1,9 +1,9 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
 import { getLimeobject, getProperties } from '../../../transport';
-import { DATA_RESOURCE } from '../../../models';
+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.
  *
@@ -94,7 +94,10 @@ export const properties: INodeProperties[] = [
  *
  * @public
  */
-export async function execute(this: IExecuteFunctions, i: number) {
+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(
@@ -103,14 +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.data };
 
     const propertiesResponse = await getProperties(this, limetype);
+    if (!propertiesResponse.success) return { json: propertiesResponse.data };
 
-    const fileProperties = getFilePropertiesNames(propertiesResponse);
-    return processFileResponse(
+    const fileProperties = getFilePropertiesNames(propertiesResponse.data);
+    const fileResponse = await processFileResponse<Limeobject>(
         this,
         fileProperties,
-        limeObjectResponse,
+        limeObjectResponse.data,
         includeFileContent
     );
+    return {
+        json: fileResponse.json.data,
+        binary: fileResponse.binary,
+    };
 }