@limetech/n8n-nodes-lime 0.3.8 → 0.5.0

package/docker-compose.yml

@@ -16,8 +16,11 @@ services:
             - DB_POSTGRESDB_PASSWORD=n8n
             - N8N_SECURE_COOKIE=false
             - N8N_LOG_LEVEL=debug
+            - N8N_LOG_OUTPUT=console
+            - N8N_LOG_FORMAT=text
+            - NODES_EXCLUDE=["n8n-nodes-base.executeCommand", "n8n-nodes-base.readWriteFile", "n8n-nodes-base.n8n", "n8n-nodes-base.ssh"]
         volumes:
-            - ./dist:/home/node/.n8n/custom
+            - n8n_dist:/home/node/.n8n/custom
         depends_on:
             - postgres
 
@@ -28,8 +31,10 @@ services:
         command: -c "cd /source && tsc --watch"
         entrypoint: /bin/sh
         volumes:
-            - .:/source
-            - ./dist:/source/dist
+            - ./nodes:/source/nodes
+            - ./credentials:/source/credentials
+            - ./tsconfig.json:/source/tsconfig.json
+            - n8n_dist:/source/dist
 
     postgres:
         image: postgres:14
@@ -44,3 +49,4 @@ services:
 
 volumes:
     postgres_data:
+    n8n_dist:

package/nodes/fortnox/Fortnox.node.ts

@@ -5,7 +5,7 @@ import {
     INodeProperties,
     INodeType,
     INodeTypeDescription,
-    NodeConnectionType,
+    NodeConnectionTypes,
     NodeOperationError,
     NodePropertyTypes,
 } from 'n8n-workflow';
@@ -27,8 +27,8 @@ export class Fortnox implements INodeType {
         defaults: {
             name: 'Fortnox',
         },
-        inputs: [NodeConnectionType.Main],
-        outputs: [NodeConnectionType.Main],
+        inputs: [NodeConnectionTypes.Main],
+        outputs: [NodeConnectionTypes.Main],
         credentials: [
             {
                 name: FORTNOX_API_CREDENTIAL_KEY,

package/nodes/fortnox/FortnoxTrigger.node.ts

@@ -3,7 +3,7 @@ import {
     INodeTypeDescription,
     ITriggerFunctions,
     ITriggerResponse,
-    NodeConnectionType,
+    NodeConnectionTypes,
     NodeOperationError,
 } from 'n8n-workflow';
 import WebSocket from 'ws';
@@ -32,7 +32,7 @@ export class FortnoxTrigger implements INodeType {
             name: 'Fortnox Trigger',
         },
         inputs: [],
-        outputs: [NodeConnectionType.Main],
+        outputs: [NodeConnectionTypes.Main],
         credentials: [
             {
                 name: FORTNOX_API_CREDENTIAL_KEY,

package/nodes/lime-crm/LimeCrmNode.node.ts

@@ -4,30 +4,32 @@ import {
     INodeProperties,
     INodeType,
     INodeTypeDescription,
-    NodeConnectionType,
+    NodeConnectionTypes,
     NodePropertyTypes,
 } from 'n8n-workflow';
 
-import {
-    erpConnectorFields,
-    erpConnectorOperations,
-} from './resources/erpConnector';
-import { limeTypeFields, limeTypeOperations } from './resources/limeType';
-import { limeObjectFields, limeObjectOperations } from './resources/limeObject';
+import { metadataFields, metadataOperations } from './resources/metadata';
+import { dataFields, dataOperations } from './resources/data';
 
 import {
-    LIMEOBJECT_RESOURCE,
-    LIMETYPE_RESOURCE,
+    DATA_RESOURCE,
+    METADATA_RESOURCE,
     LIME_CRM_API_CREDENTIAL_KEY,
-    ERP_CONNECTOR_RESOURCE,
 } from './commons';
 
 import {
     getEntitiesForErpSystem,
-    getLimeTypeProperties,
-    getLimeTypes,
+    getFileProperties,
+    getLimetypeProperties,
+    getLimetypes,
+    getNoHasManyProperties,
 } from './methods';
 
+type OperationFn = (
+    this: IExecuteFunctions,
+    args: { operation: string; i: number }
+) => Promise<unknown>;
+
 export class LimeCrmNode implements INodeType {
     description: INodeTypeDescription = {
         displayName: 'Lime CRM',
@@ -41,8 +43,8 @@ export class LimeCrmNode implements INodeType {
         defaults: {
             name: 'Lime CRM',
         },
-        inputs: [NodeConnectionType.Main],
-        outputs: [NodeConnectionType.Main],
+        inputs: [NodeConnectionTypes.Main],
+        outputs: [NodeConnectionTypes.Main],
         credentials: [
             {
                 name: LIME_CRM_API_CREDENTIAL_KEY,
@@ -57,35 +59,33 @@ export class LimeCrmNode implements INodeType {
                 noDataExpression: true,
                 options: [
                     {
-                        name: 'Lime Type',
-                        value: LIMETYPE_RESOURCE,
-                        description: 'Work with entity type definitions',
+                        name: 'Metadata',
+                        value: METADATA_RESOURCE,
+                        description:
+                            'Work with the structure of available ' +
+                            'Limetypes and their properties',
                     },
                     {
-                        name: 'Lime Object',
-                        value: LIMEOBJECT_RESOURCE,
-                        description: 'Work with actual data records',
-                    },
-                    {
-                        name: 'ERP Connector',
-                        value: ERP_CONNECTOR_RESOURCE,
-                        description: 'Integrate data between ERP and Lime CRM',
+                        name: 'Data',
+                        value: DATA_RESOURCE,
+                        description: 'Work with CRM data',
                     },
                 ],
-                default: LIMEOBJECT_RESOURCE,
+                default: DATA_RESOURCE,
             },
 
-            ...(limeTypeFields as INodeProperties[]),
-            ...(limeObjectFields as INodeProperties[]),
-            ...(erpConnectorFields as INodeProperties[]),
+            ...(metadataFields as INodeProperties[]),
+            ...(dataFields as INodeProperties[]),
         ],
     };
 
     methods = {
         loadOptions: {
             getEntitiesForErpSystem,
-            getLimeTypes,
-            getLimeTypeProperties,
+            getLimetypes,
+            getFileProperties,
+            getLimetypeProperties,
+            getNoHasManyProperties,
         },
     };
 
@@ -96,38 +96,39 @@ export class LimeCrmNode implements INodeType {
         const resource = this.getNodeParameter('resource', 0) as string;
         const operation = this.getNodeParameter('operation', 0) as string;
 
+        let operationFn: OperationFn | undefined;
+        switch (resource) {
+            case METADATA_RESOURCE: {
+                operationFn = metadataOperations;
+                break;
+            }
+            case DATA_RESOURCE: {
+                operationFn = dataOperations;
+                break;
+            }
+        }
+
         for (let i = 0; i < items.length; i++) {
-            let responseData;
+            if (!operationFn) continue;
             try {
-                if (resource === LIMETYPE_RESOURCE) {
-                    responseData = await limeTypeOperations.call(this, {
-                        operation,
-                        i,
-                    });
-                } else if (resource === LIMEOBJECT_RESOURCE) {
-                    responseData = await limeObjectOperations.call(this, {
-                        operation,
-                        i,
-                    });
-                } else if (resource === ERP_CONNECTOR_RESOURCE) {
-                    responseData = await erpConnectorOperations.call(this, {
-                        operation,
-                        i,
-                    });
+                const responseData = await operationFn.call(this, {
+                    operation,
+                    i,
+                });
+                if (responseData !== undefined) {
+                    returnData.push(
+                        responseData as unknown as INodeExecutionData
+                    );
                 }
-
-                returnData.push({ json: responseData });
             } catch (error) {
                 if (this.continueOnFail()) {
-                    returnData.push({
-                        error: error.message,
-                        json: { error: error.message },
-                    });
+                    returnData.push({ error: error.message });
                     continue;
                 }
                 throw error;
             }
         }
+
         return [this.helpers.returnJsonArray(returnData)];
     }
 }

package/nodes/lime-crm/LimeCrmTrigger.node.ts

@@ -7,11 +7,11 @@ import {
     IWebhookResponseData,
     NodeOperationError,
     LoggerProxy as Logger,
-    NodeConnectionType,
+    NodeConnectionTypes,
 } from 'n8n-workflow';
 
 import { getWebhook, LIME_CRM_API_CREDENTIAL_KEY } from './commons';
-import { getLimeTypes } from './methods';
+import { getLimetypes } from './methods';
 import {
     createSubscription,
     deleteSubscription,
@@ -19,7 +19,7 @@ import {
     listSubscriptionsWithExistingData,
 } from './transport';
 
-import { verifyHmac } from './commons/hmac';
+import { verifyHmac } from './commons';
 
 export class LimeCrmTrigger implements INodeType {
     description: INodeTypeDescription = {
@@ -30,12 +30,12 @@ export class LimeCrmTrigger implements INodeType {
         version: 1,
         description:
             'Trigger which handles webhooks coming from Lime, e.g when ' +
-            'LimeObject is updated',
+            'an object is updated',
         defaults: {
             name: 'Lime CRM Trigger',
         },
         inputs: [],
-        outputs: [NodeConnectionType.Main],
+        outputs: [NodeConnectionTypes.Main],
         credentials: [
             {
                 name: LIME_CRM_API_CREDENTIAL_KEY,
@@ -68,18 +68,18 @@ export class LimeCrmTrigger implements INodeType {
                         displayName: 'Event',
                         values: [
                             {
-                                displayName: 'Lime Type',
-                                name: 'limeType',
+                                displayName: 'Limetype',
+                                name: 'limetype',
                                 type: 'options',
                                 typeOptions: {
-                                    loadOptionsMethod: 'getLimeTypes',
+                                    loadOptionsMethod: 'getLimetypes',
                                 },
                                 default: '',
                                 description:
-                                    'Lime Type to subscribe to events for',
+                                    'Limetype to subscribe to events for',
                             },
                             {
-                                displayName: 'Event Type',
+                                displayName: 'Event',
                                 name: 'eventType',
                                 type: 'options',
                                 options: [
@@ -87,41 +87,34 @@ export class LimeCrmTrigger implements INodeType {
                                         name: 'New',
                                         value: 'new',
                                         description:
-                                            'When a new record is created',
+                                            'When a new object is created',
                                     },
                                     {
                                         name: 'Update',
                                         value: 'update',
-                                        description: 'When a record is updated',
+                                        description:
+                                            'When an object is updated',
                                     },
                                     {
                                         name: 'Delete',
                                         value: 'delete',
-                                        description: 'When a record is deleted',
+                                        description:
+                                            'When an object is deleted',
                                     },
                                 ],
                                 default: 'new',
-                                description: 'Type of event to subscribe to',
+                                description: 'Event to subscribe to',
                             },
                         ],
                     },
                 ],
             },
-            {
-                displayName: 'Name',
-                name: 'name',
-                type: 'string',
-                default: '',
-                placeholder: 'my-lime-webhook',
-                required: true,
-                description: 'Name for this webhook subscription',
-            },
         ],
     };
 
     methods = {
         loadOptions: {
-            getLimeTypes,
+            getLimetypes,
         },
     };
 

package/nodes/lime-crm/commons/constants.ts

@@ -4,6 +4,6 @@ export const LIME_CRM_API_CREDENTIAL_KEY = 'limeCrmApi';
 
 // Resources
 
-export const LIMEOBJECT_RESOURCE = 'limeObject';
-export const LIMETYPE_RESOURCE = 'limeType';
+export const DATA_RESOURCE = 'data';
+export const METADATA_RESOURCE = 'metadata';
 export const ERP_CONNECTOR_RESOURCE = 'erpConnector';

package/nodes/lime-crm/commons/files.ts

@@ -0,0 +1,162 @@
+import {
+    IBinaryData,
+    IDataObject,
+    IExecuteFunctions,
+    LoggerProxy as Logger,
+} from 'n8n-workflow';
+import {
+    createFile,
+    getFileContent,
+    getFileMetadata,
+    getProperties,
+} from '../transport';
+import { NodeResponse } from '../../nodeResponse';
+
+type FileResponse<T> = {
+    json: NodeResponse<T>;
+    binary?: Record<string, IBinaryData>;
+};
+
+export const setFilename = (
+    preparedBinaryData: IBinaryData,
+    responseFileName: string
+) => {
+    if (!preparedBinaryData.fileName && preparedBinaryData.fileExtension) {
+        return responseFileName;
+    }
+
+    return preparedBinaryData.fileName;
+};
+
+export function getFilenameFromHeader(
+    headers: Record<string, string | string[] | undefined>
+): string | null {
+    let contentDisposition =
+        headers['content-disposition'] || headers['Content-Disposition'];
+    if (!contentDisposition) return null;
+
+    if (Array.isArray(contentDisposition)) {
+        contentDisposition = contentDisposition[0];
+    }
+
+    // Try RFC 5987 filename* format
+    const filenameStarMatch = /filename\*\s*=\s*UTF-8''([^;]+)/i.exec(
+        contentDisposition
+    );
+    if (filenameStarMatch) {
+        try {
+            return decodeURIComponent(filenameStarMatch[1]);
+        } catch {
+            return filenameStarMatch[1];
+        }
+    }
+
+    // Try regular filename="..." or filename=...
+    const filenameMatch =
+        /filename\s*=\s*"([^"]+)"|filename\s*=\s*([^;]+)/i.exec(
+            contentDisposition
+        );
+    if (filenameMatch) {
+        return filenameMatch[1] || filenameMatch[2];
+    }
+
+    return null;
+}
+
+export async function getFileProperties(
+    nodeContext: IExecuteFunctions,
+    limetype: string,
+    allowedProperties?: Set<string>
+): Promise<Set<string>> {
+    const response = await getProperties(nodeContext, limetype);
+
+    if (!response.success) return new Set();
+    return new Set(
+        response.data
+            .filter(
+                (property) =>
+                    property.type === 'file' &&
+                    (!allowedProperties || allowedProperties.has(property.name))
+            )
+            .map((property) => property.name)
+    );
+}
+
+export async function setFileProperties(
+    context: IExecuteFunctions,
+    i: number,
+    fileProperties: Set<string>,
+    definedProperties: IDataObject
+): Promise<NodeResponse<IDataObject>> {
+    for (const fileProperty of fileProperties) {
+        if (!(fileProperty in definedProperties)) continue;
+        let binaryData: IBinaryData;
+        try {
+            Logger.info(
+                `Checking whether "${definedProperties[fileProperty]}" is a valid binary object for property "${fileProperty}"...`
+            );
+            binaryData = context.helpers.assertBinaryData(
+                i,
+                definedProperties[fileProperty] as string
+            );
+        } catch {
+            Logger.info(
+                `Invalid or missing binary data for "${fileProperty}". Using original value instead.`
+            );
+            continue;
+        }
+        const response = await createFile(
+            context,
+            binaryData,
+            definedProperties[fileProperty] as string
+        );
+
+        if (response.success) {
+            definedProperties[fileProperty] = response.data.id;
+        } else return response;
+    }
+    return {
+        success: true,
+        data: definedProperties,
+    };
+}
+
+export async function processFileResponse<T extends Record<string, unknown>>(
+    nodeContext: IExecuteFunctions,
+    fileProperties: Set<string>,
+    data: T,
+    includeFileContent: boolean = false
+): Promise<FileResponse<T>> {
+    let updatedData = { ...data };
+    const binaryData: Record<string, IBinaryData> = {};
+    for (const fileProperty of fileProperties) {
+        if (!data[fileProperty]) continue;
+        const fileMetadataResponse = await getFileMetadata(
+            nodeContext,
+            data[fileProperty] as string
+        );
+        if (!fileMetadataResponse.success)
+            return { json: fileMetadataResponse };
+
+        updatedData = {
+            ...updatedData,
+            [fileProperty]: fileMetadataResponse.data,
+        };
+
+        if (includeFileContent) {
+            const fileResponse = await getFileContent(
+                nodeContext,
+                fileMetadataResponse.data.id
+            );
+            if (!fileResponse.success) return { json: fileResponse };
+            binaryData[fileProperty] = fileResponse.data;
+        }
+    }
+    return {
+        json: {
+            success: true,
+            data: updatedData,
+        },
+        binary: binaryData,
+    };
+}

package/nodes/lime-crm/commons/index.ts

@@ -1,9 +1,10 @@
 export {
     LIME_CRM_API_CREDENTIAL_KEY,
-    LIMEOBJECT_RESOURCE,
-    LIMETYPE_RESOURCE,
+    DATA_RESOURCE,
+    METADATA_RESOURCE,
     ERP_CONNECTOR_RESOURCE,
 } from './constants';
 export { Webhook, getWebhook } from './webhook';
 
-export { LimeType, LimeTypeProperty } from './limetype';
+export { verifyHmac } from './hmac';
+export { setFilename, getFilenameFromHeader } from './files';

package/nodes/lime-crm/commons/webhook.ts

@@ -24,18 +24,30 @@ export interface CreateWebhook extends Webhook {
 function _getEvents(hookData: WebhookFunctions): string[] {
     const eventData = hookData.getNodeParameter('events', []) as {
         event: Array<{
-            limeType: string;
+            limetype: string;
             eventType: string;
         }>;
     };
     const eventItems = eventData.event;
     const events: string[] = [];
     for (const eventItem of eventItems) {
-        events.push(`${eventItem.limeType}.${eventItem.eventType}`);
+        events.push(`${eventItem.limetype}.${eventItem.eventType}`);
     }
     return events;
 }
 
+function _createWebhookName(hookData: WebhookFunctions): string {
+    interface Events {
+        event: Array<{
+            limetype: string;
+            eventType: string;
+        }>;
+    }
+
+    const events = hookData.getNodeParameter('events') as Events;
+    return `${events.event[0].limetype}-${events.event[0].eventType}-${Date.now()}`;
+}
+
 export function getWebhook(hookData: WebhookFunctions): Webhook {
     const node = hookData.getNode();
     const workflow = hookData.getWorkflow();
@@ -51,6 +63,6 @@ export function getWebhook(hookData: WebhookFunctions): Webhook {
         events: _getEvents(hookData),
         url: hookData.getNodeWebhookUrl('default'),
         context: context,
-        name: hookData.getNodeParameter('name') as string,
+        name: _createWebhookName(hookData),
     };
 }

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

@@ -0,0 +1,67 @@
+import {
+    ILoadOptionsFunctions,
+    INodePropertyOptions,
+    LoggerProxy as Logger,
+} from 'n8n-workflow';
+import { getProperties } from '../transport/';
+
+async function _getProperties(nodeContext: ILoadOptionsFunctions) {
+    const limetype = nodeContext.getNodeParameter('limetype', '') as string;
+    Logger.info(`Fetching file properties for Lime type: ${limetype}`);
+    if (!limetype) return [];
+
+    const response = await getProperties(nodeContext, limetype);
+
+    return response.success ? response.data : [];
+}
+
+/**
+ * Gets property options from a specific Limetype
+ *
+ * It's not meant to be used directly in 'loadOptionsMethod'
+ *
+ * This function fetches properties for the specified Limetype and optionally filters them
+ * based on allowed types.
+ *
+ * @param [loader] - The n8n load options context
+ * @param [allowedTypes] - Optional set of property types to filter by
+ * @param [forbiddenType] - Optional set of property types to exclude
+ * @returns Array of formatted property options
+ */
+export async function getFilteredLimetypeProperties(
+    loader: ILoadOptionsFunctions,
+    allowedTypes?: Set<string>,
+    forbiddenType?: Set<string>
+): Promise<INodePropertyOptions[]> {
+    const properties = await _getProperties(loader);
+
+    return properties
+        .filter(
+            (property) =>
+                (!allowedTypes || allowedTypes.has(property.type)) &&
+                (!forbiddenType || !forbiddenType.has(property.type))
+        )
+        .map((property) => ({
+            name: (property.localname as string) || (property.name as string),
+            value: property.name as string,
+            description: `Type: ${property.type as string}${(property.required as boolean) ? ' (Required)' : ''}`,
+        }));
+}
+
+export async function getLimetypeProperties(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    return getFilteredLimetypeProperties(this);
+}
+
+export async function getFileProperties(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    return getFilteredLimetypeProperties(this, new Set(['file']));
+}
+
+export async function getNoHasManyProperties(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    return getFilteredLimetypeProperties(this, undefined, new Set(['hasmany']));
+}

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

@@ -0,0 +1,21 @@
+import { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+import { getLimetypesFromApi } from '../transport';
+
+/**
+ * Load available Lime types from the API
+ */
+export async function getLimetypes(
+    this: ILoadOptionsFunctions
+): Promise<INodePropertyOptions[]> {
+    const data: INodePropertyOptions[] = [];
+    const response = await getLimetypesFromApi(this);
+    if (response.success && response.data) {
+        for (const limetype of response.data) {
+            data.push({
+                name: limetype.localname?.singular || limetype.name,
+                value: limetype.name,
+            });
+        }
+    }
+    return data;
+}

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

@@ -1,3 +1,7 @@
 export { getEntitiesForErpSystem } from './getEntitiesForErpSystem';
-export { getLimeTypes } from './getLimeTypes';
-export { getLimeTypeProperties } from './getLimeTypeProperties';
+export { getLimetypes } from './getLimetypes';
+export {
+    getFileProperties,
+    getLimetypeProperties,
+    getNoHasManyProperties,
+} from './getLimetypeProperties';