@limetech/n8n-nodes-lime 0.4.0 → 0.5.0

package/nodes/lime-crm/resources/data/operations/getManyObjects.ts

@@ -0,0 +1,356 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { queryLimeobjects } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Many Objects',
+    value: 'getManyObjects',
+    description: 'Get a list of many objects',
+    action: 'Get many objects',
+};
+
+const BATCHSIZE = 50;
+
+interface ResponseFormat {
+    object: {
+        [key: string]: string;
+    };
+}
+
+interface OrderByCollection {
+    orderByFields: {
+        propertyName: string;
+        sortDirection: 'ASC' | 'DESC';
+    }[];
+}
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity to query',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Response Format',
+        name: 'responseFormatInputMethod',
+        type: 'options',
+        required: true,
+        default: 'fields',
+        description: 'Select how the response should be formatted',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+        options: [
+            {
+                name: 'Properties',
+                value: 'fields',
+            },
+            {
+                name: 'JSON',
+                value: 'json',
+            },
+        ],
+    },
+    {
+        displayName: 'Response Format (Form Fields)',
+        name: 'responseFormatProperties',
+        type: 'fixedCollection',
+        placeholder: 'Add Property',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                responseFormatInputMethod: ['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: 'Response Format (JSON)',
+        name: 'responseFormatJson',
+        type: 'json',
+        required: true,
+        default: '{\n\t"object": {\n\t\t"_id": ""\n\t}\n}',
+        description:
+            'Information included in the response when using JSON format',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                responseFormatInputMethod: ['json'],
+            },
+        },
+    },
+    {
+        displayName: 'Filter (JSON)',
+        name: 'filter',
+        type: 'json',
+        default: '{}',
+        description: "The filter DSL defining the query's conditions",
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 50,
+        description: 'The maximum number of records to return',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+    },
+    {
+        displayName: 'Order By',
+        name: 'orderByInputMethod',
+        type: 'options',
+        required: true,
+        default: 'fields',
+        description: 'Select how the response should be ordered',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+            },
+        },
+        options: [
+            {
+                name: 'Form Fields',
+                value: 'fields',
+            },
+            {
+                name: 'JSON',
+                value: 'json',
+            },
+        ],
+    },
+    {
+        displayName: 'Order By (Form Fields)',
+        name: 'orderByProperties',
+        type: 'fixedCollection',
+        placeholder: 'Add Property',
+        typeOptions: {
+            multipleValues: true,
+        },
+        default: {},
+        description:
+            'The list of properties by which to order the query results',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                orderByInputMethod: ['fields'],
+            },
+        },
+        options: [
+            {
+                name: 'orderByFields',
+                displayName: 'Order By Fields',
+                values: [
+                    {
+                        displayName: 'Property Name',
+                        name: 'propertyName',
+                        type: 'options',
+                        required: true,
+                        typeOptions: {
+                            sortable: true,
+                            loadOptionsMethod: 'getNoHasManyProperties',
+                            loadOptionsDependsOn: ['limetype'],
+                        },
+                        default: '',
+                        description: 'Name of the property to order by',
+                    },
+                    {
+                        displayName: 'Sort Direction',
+                        name: 'sortDirection',
+                        type: 'options',
+                        default: 'ASC',
+                        description: 'Ordering direction',
+                        options: [
+                            { name: 'Ascending', value: 'ASC' },
+                            { name: 'Descending', value: 'DESC' },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        displayName: 'Order By (JSON)',
+        name: 'orderByJson',
+        type: 'json',
+        required: true,
+        default: '[\n\t{\n\t\t"_id": "ASC"\n\t}\n]',
+        description: 'Provide ordering in JSON',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getManyObjects'],
+                orderByInputMethod: ['json'],
+            },
+        },
+    },
+];
+
+function _createResponseFormatObject(
+    properties: { name: string }[] = []
+): ResponseFormat {
+    const object: Record<string, string> = { _id: '' };
+    for (const { name } of properties) {
+        if (name) object[name] = '';
+    }
+    return { object };
+}
+
+function _getOrderBy(orderByCollection: OrderByCollection) {
+    const orderBy =
+        orderByCollection.orderByFields &&
+        orderByCollection.orderByFields.map((field) => ({
+            [field.propertyName]: field.sortDirection,
+        }));
+    return orderBy || [{ _id: 'ASC' }];
+}
+
+async function _fetchLimeObjectsInBatches(
+    this: IExecuteFunctions,
+    limetype: string,
+    responseFormat: ResponseFormat,
+    filter: string,
+    limit: number,
+    orderBy: Array<{ [key: string]: 'ASC' | 'DESC' }>
+) {
+    if (limit <= BATCHSIZE) {
+        const q = JSON.stringify({
+            limetype,
+            responseFormat: responseFormat,
+            filter: JSON.parse(filter),
+            limit: limit,
+            offset: 0,
+            orderBy: orderBy,
+        });
+        return queryLimeobjects(this, q);
+    } else {
+        let allResults: unknown[] = [];
+        let fetched = 0;
+        let currentOffset = 0;
+        while (fetched < limit) {
+            const currentLimit = Math.min(BATCHSIZE, limit - fetched);
+            const q = JSON.stringify({
+                limetype,
+                responseFormat: responseFormat,
+                filter: JSON.parse(filter),
+                limit: currentLimit,
+                offset: currentOffset,
+                orderBy,
+            });
+            const batch = await queryLimeobjects(this, q);
+            if (!batch.success) {
+                return batch;
+            }
+            const collected = batch.data.objects.length;
+            if (!batch || collected === 0) break;
+            allResults = [...allResults, ...batch.data.objects];
+            fetched += collected;
+            currentOffset += collected;
+
+            if (collected < currentLimit) break;
+        }
+        return {
+            success: true,
+            data: allResults,
+        };
+    }
+}
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    const limetype = this.getNodeParameter('limetype', i) as string;
+    const responseFormatInputMethod = this.getNodeParameter(
+        'responseFormatInputMethod',
+        i
+    ) as string;
+    const orderByInputMethod = this.getNodeParameter(
+        'orderByInputMethod',
+        i
+    ) as string;
+    const filter = this.getNodeParameter('filter', i) as string;
+    const limit = this.getNodeParameter('limit', i, 50) as number;
+
+    let response;
+    if (responseFormatInputMethod === 'fields') {
+        const properties = this.getNodeParameter(
+            'responseFormatProperties',
+            i
+        ) as { property: [{ name: string }] };
+        response = _createResponseFormatObject(properties.property);
+    } else if (responseFormatInputMethod === 'json') {
+        response = this.getNodeParameter('responseFormatJson', i) as string;
+        response = JSON.parse(response);
+    }
+
+    let orderBy;
+    if (orderByInputMethod === 'fields') {
+        const orderByCollection = this.getNodeParameter(
+            'orderByProperties',
+            i
+        ) as OrderByCollection;
+        orderBy = _getOrderBy(orderByCollection);
+    } else if (orderByInputMethod === 'json') {
+        orderBy = this.getNodeParameter('orderByJson', i) as string;
+        orderBy = JSON.parse(orderBy);
+    }
+
+    return await _fetchLimeObjectsInBatches.call(
+        this,
+        limetype,
+        response,
+        filter,
+        limit,
+        orderBy
+    );
+}

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

@@ -0,0 +1,138 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+import { getFileContent, getFileContentByLimetype } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Single File',
+    value: 'getSingleFile',
+    description: 'Get the file data for one specific file',
+    action: 'Get single file',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Get by',
+        name: 'source',
+        type: 'options',
+        required: true,
+        placeholder: 'Add Source',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+            },
+        },
+        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: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+    {
+        displayName: 'Identifier',
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the file or Limeobject to retrieve',
+        displayOptions: {
+            show: {
+                resource: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+            },
+        },
+        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: [DATA_RESOURCE],
+                operation: ['getSingleFile'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+];
+
+export async function execute(this: IExecuteFunctions, i: number) {
+    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 };
+        }
+
+        return {
+            json: { success: fileResponse.success },
+            binary: { data: fileResponse.data },
+        };
+    }
+    if (source == 'byLimeobject') {
+        const limetype = this.getNodeParameter('limetype', i) as string;
+        const property = this.getNodeParameter('property', i) as string;
+
+        const fileResponse = await getFileContentByLimetype(
+            this,
+            limetype,
+            id,
+            property
+        );
+        if (!fileResponse.success) {
+            return { json: fileResponse };
+        }
+
+        return {
+            json: { success: fileResponse.success },
+            binary: {
+                data: fileResponse.data,
+            },
+        };
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The source "${source}" is not supported!`
+    );
+}

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

@@ -0,0 +1,83 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import { getLimeobject } from '../../../transport';
+import { DATA_RESOURCE } from '../../../commons';
+import { getFileProperties, processFileResponse } from '../../../commons/files';
+
+export const description = {
+    name: 'Get Single Object',
+    value: 'getSingleObject',
+    description: 'Get one specific object',
+    action: 'Get single object',
+};
+
+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'],
+            },
+        },
+    },
+];
+
+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);
+    if (!limeObjectResponse.success) return { json: limeObjectResponse };
+
+    const fileProperties = await getFileProperties(this, limetype);
+    return processFileResponse(
+        this,
+        fileProperties,
+        limeObjectResponse.data,
+        includeFileContent
+    );
+}