@limetech/n8n-nodes-lime 0.4.0 → 0.5.0

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,10 +1,10 @@
 export {
     LIME_CRM_API_CREDENTIAL_KEY,
-    LIMEOBJECT_RESOURCE,
-    LIMETYPE_RESOURCE,
+    DATA_RESOURCE,
+    METADATA_RESOURCE,
     ERP_CONNECTOR_RESOURCE,
-    LIME_QUERY_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';

package/nodes/lime-crm/model.ts

@@ -0,0 +1,22 @@
+type LimetypeProperty = {
+    name: string;
+    localname: string;
+    type: string;
+} & Record<string, unknown>;
+
+type LimetypeLocalName = {
+    singular: string;
+    plural: string;
+};
+
+type Limetype = {
+    name: string;
+    localname: LimetypeLocalName;
+    properties: LimetypeProperty[];
+} & Record<string, unknown>;
+
+type Limeobject = {
+    id_: number;
+} & Record<string, unknown>;
+
+export { LimetypeProperty, Limetype, Limeobject };

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

@@ -0,0 +1,80 @@
+import {
+    INodeExecutionData,
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+    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 { DATA_RESOURCE } from '../../commons';
+
+export const dataFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+            },
+        },
+        options: [
+            createSingleObject.description,
+            getSingleObject.description,
+            updateSingleObject.description,
+            deleteSingleObject.description,
+            getManyObjects.description,
+            getSingleFile.description,
+        ],
+        default: 'fetchMany',
+    },
+
+    ...createSingleObject.properties,
+    ...getSingleObject.properties,
+    ...updateSingleObject.properties,
+    ...deleteSingleObject.properties,
+    ...getSingleFile.properties,
+    ...getManyObjects.properties,
+];
+
+export async function dataOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+): Promise<INodeExecutionData> {
+    switch (operation) {
+        case 'createSingleObject': {
+            return { json: await createSingleObject.execute.call(this, i) };
+        }
+        case 'getSingleObject': {
+            return await getSingleObject.execute.call(this, i);
+        }
+        case 'updateSingleObject': {
+            return { json: await updateSingleObject.execute.call(this, i) };
+        }
+        case 'deleteSingleObject': {
+            await deleteSingleObject.execute.call(this, i);
+            return { json: { success: true } };
+        }
+        case 'getManyObjects': {
+            return {
+                json: await getManyObjects.execute.call(this, i),
+            };
+        }
+        case 'getSingleFile': {
+            return await getSingleFile.execute.call(this, i);
+        }
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The operation "${operation}" is not supported!`
+    );
+}

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

@@ -1,35 +1,38 @@
 import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { createLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
+import { createLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+import {
+    getFileProperties,
+    processFileResponse,
+    setFileProperties,
+} from '../../../commons/files';
 
 export const description = {
-    name: 'Create Object',
-    value: 'create',
-    description: 'Create a new object',
-    action: 'Create an object',
+    name: 'Create Single Object',
+    value: 'createSingleObject',
+    description: 'Create a single new object',
+    action: 'Create single object',
 };
 
 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 create',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
             },
         },
     },
-
-    // Object data input method
     {
         displayName: 'Input Method',
         name: 'inputMethod',
@@ -48,13 +51,11 @@ export const properties: INodeProperties[] = [
         description: 'How to input the object data',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
             },
         },
     },
-
-    // Dynamic properties for form input
     {
         displayName: 'Properties',
         name: 'properties',
@@ -62,15 +63,12 @@ export const properties: INodeProperties[] = [
         placeholder: 'Add Property',
         typeOptions: {
             multipleValues: true,
-            sortable: true,
-            loadOptionsMethod: 'getLimeTypeProperties',
-            loadOptionsDependsOn: ['limeType'],
         },
         default: {},
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
                 inputMethod: ['fields'],
             },
         },
@@ -84,8 +82,9 @@ export const properties: INodeProperties[] = [
                         name: 'name',
                         type: 'options',
                         typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
+                            sortable: true,
+                            loadOptionsMethod: 'getLimetypeProperties',
+                            loadOptionsDependsOn: ['limetype'],
                         },
                         default: '',
                         description: 'Name of the property',
@@ -101,8 +100,6 @@ export const properties: INodeProperties[] = [
             },
         ],
     },
-
-    // JSON input
     {
         displayName: 'Object (JSON)',
         name: 'objectJson',
@@ -111,8 +108,8 @@ export const properties: INodeProperties[] = [
         description: 'Object to create in JSON format',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
+                resource: [DATA_RESOURCE],
+                operation: ['createSingleObject'],
                 inputMethod: ['json'],
             },
         },
@@ -123,7 +120,7 @@ export const properties: INodeProperties[] = [
 ];
 
 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 inputMethod = this.getNodeParameter('inputMethod', i) as string;
 
     let objectData: IDataObject;
@@ -148,5 +145,31 @@ export async function execute(this: IExecuteFunctions, i: number) {
         }
     }
 
-    return await createLimeObject(this, limeType, objectData);
+    const fileProperties = await getFileProperties(
+        this,
+        limetype,
+        new Set(Object.keys(objectData))
+    );
+
+    const setFilePropertiesResponse = await setFileProperties(
+        this,
+        i,
+        fileProperties,
+        objectData
+    );
+    if (!setFilePropertiesResponse.success) return setFilePropertiesResponse;
+
+    const createLimeobjectResponse = await createLimeobject(
+        this,
+        limetype,
+        setFilePropertiesResponse.data
+    );
+    if (!createLimeobjectResponse.success) return createLimeobjectResponse;
+
+    const response = await processFileResponse(
+        this,
+        fileProperties,
+        createLimeobjectResponse.data
+    );
+    return response.json;
 }

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

@@ -1,31 +1,31 @@
 import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
 
-import { deleteLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
+import { deleteLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
 
 export const description = {
-    name: 'Delete Object',
-    value: 'delete',
-    description: 'Delete an existing object',
-    action: 'Delete an object',
+    name: 'Delete Single Object',
+    value: 'deleteSingleObject',
+    description: 'Delete one specific object',
+    action: 'Delete single object',
 };
 
 export const properties: INodeProperties[] = [
     // Limetype selection
     {
-        displayName: 'Lime Type',
-        name: 'limeType',
+        displayName: 'Limetype',
+        name: 'limetype',
         type: 'options',
         typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
+            loadOptionsMethod: 'getLimetypes',
         },
         required: true,
         default: '',
         description: 'The type of entity to delete',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['delete'],
+                resource: [DATA_RESOURCE],
+                operation: ['deleteSingleObject'],
             },
         },
     },
@@ -40,16 +40,16 @@ export const properties: INodeProperties[] = [
         description: 'The ID of the object to delete',
         displayOptions: {
             show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['delete'],
+                resource: [DATA_RESOURCE],
+                operation: ['deleteSingleObject'],
             },
         },
     },
 ];
 
 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 objectId = this.getNodeParameter('objectId', i) as string;
 
-    return await deleteLimeObject(this, limeType, objectId);
+    return await deleteLimeobject(this, limetype, objectId);
 }