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

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

@@ -1,64 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodePropertyTypes,
-} from 'n8n-workflow';
-
-import * as create from './operations/create.operation';
-import * as get from './operations/get.operation';
-import * as update from './operations/update.operation';
-import * as delete_ from './operations/delete.operation';
-import * as fetchMany from './operations/fetchMany.operation';
-
-import { LIMEOBJECT_RESOURCE } from '../../commons';
-
-export const limeObjectFields: INodeProperties[] = [
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-            },
-        },
-        options: [
-            create.description,
-            get.description,
-            update.description,
-            delete_.description,
-            fetchMany.description,
-        ],
-        default: 'fetchMany',
-    },
-
-    ...create.properties,
-    ...get.properties,
-    ...update.properties,
-    ...delete_.properties,
-    ...fetchMany.properties,
-];
-
-export async function limeObjectOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number }
-) {
-    if (operation === 'create') {
-        return await create.execute.call(this, i);
-    }
-    if (operation === 'get') {
-        return await get.execute.call(this, i);
-    }
-    if (operation === 'update') {
-        return await update.execute.call(this, i);
-    }
-    if (operation === 'delete') {
-        return await delete_.execute.call(this, i);
-    }
-    if (operation === 'fetchMany') {
-        return await fetchMany.execute.call(this, i);
-    }
-
-    return null;
-}

package/nodes/lime-crm/resources/limeObject/operations/create.operation.ts

@@ -1,152 +0,0 @@
-import { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { createLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Create Object',
-    value: 'create',
-    description: 'Create a new object',
-    action: 'Create an object',
-};
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'LimeType',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to create',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
-            },
-        },
-    },
-
-    // Object data input method
-    {
-        displayName: 'Input Method',
-        name: 'inputMethod',
-        type: 'options',
-        options: [
-            {
-                name: 'Form Fields',
-                value: 'fields',
-            },
-            {
-                name: 'JSON',
-                value: 'json',
-            },
-        ],
-        default: 'fields',
-        description: 'How to input the object data',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
-            },
-        },
-    },
-
-    // Dynamic properties for form input
-    {
-        displayName: 'Properties',
-        name: 'properties',
-        type: 'fixedCollection',
-        placeholder: 'Add Property',
-        typeOptions: {
-            multipleValues: true,
-            sortable: true,
-            loadOptionsMethod: 'getLimeTypeProperties',
-            loadOptionsDependsOn: ['limeType'],
-        },
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
-                inputMethod: ['fields'],
-            },
-        },
-        options: [
-            {
-                displayName: 'Property',
-                name: 'property',
-                values: [
-                    {
-                        displayName: 'Property Name',
-                        name: 'name',
-                        type: 'options',
-                        typeOptions: {
-                            loadOptionsMethod: 'getLimeTypeProperties',
-                            loadOptionsDependsOn: ['limeType'],
-                        },
-                        default: '',
-                        description: 'Name of the property',
-                    },
-                    {
-                        displayName: 'Property Value',
-                        name: 'value',
-                        type: 'string',
-                        default: '',
-                        description: 'Value of the property',
-                    },
-                ],
-            },
-        ],
-    },
-
-    // JSON input
-    {
-        displayName: 'Object (JSON)',
-        name: 'objectJson',
-        type: 'json',
-        default: '{\n  "name": "New Company",\n  "phone": "123-456-7890"\n}',
-        description: 'Object to create in JSON format',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['create'],
-                inputMethod: ['json'],
-            },
-        },
-        typeOptions: {
-            alwaysOpenEditWindow: true,
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const inputMethod = this.getNodeParameter('inputMethod', i) as string;
-
-    let objectData: IDataObject;
-
-    if (inputMethod === 'json') {
-        const jsonInput = this.getNodeParameter('objectJson', i) as string;
-        objectData = JSON.parse(jsonInput);
-    } else {
-        objectData = {};
-        const propertiesInput = this.getNodeParameter(
-            'properties.property',
-            i,
-            []
-        ) as IDataObject[];
-
-        if (propertiesInput && propertiesInput.length > 0) {
-            for (const prop of propertiesInput) {
-                if (prop.name && prop.value !== undefined) {
-                    objectData[prop.name as string] = prop.value;
-                }
-            }
-        }
-    }
-
-    return await createLimeObject(this, limeType, objectData);
-}

package/nodes/lime-crm/resources/limeObject/operations/delete.operation.ts

@@ -1,55 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { deleteLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Delete Object',
-    value: 'delete',
-    description: 'Delete an existing object',
-    action: 'Delete an object',
-};
-
-export const properties: INodeProperties[] = [
-    // Limetype selection
-    {
-        displayName: 'Lime Type',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to delete',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['delete'],
-            },
-        },
-    },
-
-    // Object ID
-    {
-        displayName: 'Object ID',
-        name: 'objectId',
-        type: 'string',
-        required: true,
-        default: '',
-        description: 'The ID of the object to delete',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['delete'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const objectId = this.getNodeParameter('objectId', i) as string;
-
-    return await deleteLimeObject(this, limeType, objectId);
-}

package/nodes/lime-crm/resources/limeObject/operations/fetchMany.operation.ts

@@ -1,112 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { fetchManyLimeObjects } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Fetch many',
-    value: 'fetchMany',
-    description: 'Fetch many Lime objects',
-    action: 'Fetch many objects',
-};
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'Lime Type',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to search for',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Search Term',
-        name: 'searchTerm',
-        type: 'string',
-        default: '',
-        description: 'Term to search for',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Search Fields',
-        name: 'searchField',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypeProperties',
-            loadOptionsDependsOn: ['limeType'],
-        },
-        default: [],
-        description:
-            'Fields to search in. If none selected, searches across all searchable fields',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Limit',
-        name: 'limit',
-        type: 'number',
-        default: 50,
-        description: 'Max number of results to return',
-        typeOptions: {
-            minValue: 1,
-        },
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Offset',
-        name: 'offset',
-        type: 'number',
-        default: 0,
-        description: 'Offset to first object to return',
-        typeOptions: {
-            minValue: 0,
-        },
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const searchTerm = this.getNodeParameter('searchTerm', i, '') as string;
-    const searchField = this.getNodeParameter('searchField', i) as string;
-    const limit = this.getNodeParameter('limit', i, 50);
-    const offset = this.getNodeParameter('offset', i, 0) as number;
-    const options = this.getNodeParameter('options', i, {});
-
-    return await fetchManyLimeObjects(
-        this,
-        limeType,
-        searchField,
-        searchTerm,
-        limit,
-        offset,
-        (options.sortField as string) || null
-    );
-}

package/nodes/lime-crm/resources/limeObject/operations/get.operation.ts

@@ -1,54 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { getLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Get Object',
-    value: 'get',
-    description: 'Get a single object by ID',
-    action: 'Get an object',
-};
-
-export const properties: INodeProperties[] = [
-    // Limetype selection
-    {
-        displayName: 'Lime Type',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to retrieve',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['get'],
-            },
-        },
-    },
-
-    // Object ID
-    {
-        displayName: 'Object ID',
-        name: 'objectId',
-        type: 'string',
-        required: true,
-        default: '',
-        description: 'The ID of the object to retrieve',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['get'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const objectId = this.getNodeParameter('objectId', i) as string;
-    return getLimeObject(this, limeType, objectId);
-}

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

@@ -1,40 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodePropertyTypes,
-} from 'n8n-workflow';
-
-import * as query from './operations/query.operation';
-import { LIME_QUERY_RESOURCE } from '../../commons';
-
-export const queryFields: INodeProperties[] = [
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-            },
-        },
-        options: [
-            {
-                ...query.description,
-            },
-        ],
-        default: 'query',
-    },
-
-    ...query.properties,
-];
-
-export async function queryOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number }
-) {
-    if (operation === 'query') {
-        return await query.execute.call(this, i);
-    }
-    return null;
-}

package/nodes/lime-crm/resources/limeQuery/operations/query.operation.ts

@@ -1,222 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { queryLimeObjects } from '../../../transport';
-import { LIME_QUERY_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Query',
-    value: 'query',
-    description: 'Query objects with Lime Query API',
-    action: 'Query objects',
-};
-
-interface OrderByCollection {
-    orderByFields: {
-        propertyName: string;
-        sortDirection: 'ASC' | 'DESC';
-    }[];
-}
-
-interface ActiveObjectCollection {
-    activeObjectFields: {
-        limetype: string;
-        id: number;
-    };
-}
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'Lime Type',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to query',
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-    },
-    {
-        displayName: 'Response Format (JSON)',
-        name: 'responseFormat',
-        type: 'json',
-        required: true,
-        default: '{}',
-        description: 'Information that should be included in the response',
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-    },
-    {
-        displayName: 'Filter (JSON)',
-        name: 'filter',
-        type: 'json',
-        default: '{}',
-        description: "The filter DSL defining the query's conditions",
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-    },
-    {
-        displayName: 'Limit',
-        name: 'limit',
-        type: 'number',
-        default: null,
-        description: 'The maximum number of records to return',
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-    },
-    {
-        displayName: 'Order By',
-        name: 'orderBy',
-        type: 'fixedCollection',
-        typeOptions: {
-            multipleValues: true,
-        },
-        default: {},
-        description:
-            'The list of properties by which to order the query results',
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-        options: [
-            {
-                name: 'orderByFields',
-                displayName: 'Order By Fields',
-                values: [
-                    {
-                        displayName: 'Property Name',
-                        name: 'propertyName',
-                        type: 'string',
-                        description: 'Name of the property to order by',
-                        default: '',
-                        required: true,
-                    },
-                    {
-                        displayName: 'Sort Direction',
-                        name: 'sortDirection',
-                        type: 'options',
-                        default: 'ASC',
-                        description: 'Ordering direction',
-                        options: [
-                            { name: 'ASC', value: 'ASC' },
-                            { name: 'DESC', value: 'DESC' },
-                        ],
-                    },
-                ],
-            },
-        ],
-    },
-    {
-        displayName: 'Offset',
-        name: 'offset',
-        type: 'number',
-        default: null,
-        description:
-            'The offset from which to start returning records. This operation requires the `Order By` field to be set',
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-    },
-    {
-        displayName: 'Active Object',
-        name: 'activeObject',
-        type: 'fixedCollection',
-        default: {},
-        description:
-            "A dict with keys 'limetype' and 'id' representing the active object in the context of the query",
-        displayOptions: {
-            show: {
-                resource: [LIME_QUERY_RESOURCE],
-                operation: ['query'],
-            },
-        },
-        options: [
-            {
-                name: 'activeObjectFields',
-                displayName: 'Active Object Fields',
-                values: [
-                    {
-                        displayName: 'Lime Type',
-                        name: 'limetype',
-                        type: 'options',
-                        description: 'Name of the limetype',
-                        default: '',
-                        typeOptions: {
-                            loadOptionsMethod: 'getLimeTypes',
-                        },
-                        required: true,
-                    },
-                    {
-                        displayName: 'Lime Object ID',
-                        name: 'id',
-                        type: 'number',
-                        default: 0,
-                        description:
-                            'ID representing the object in the context of the query',
-                        required: true,
-                    },
-                ],
-            },
-        ],
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const responseFormat = this.getNodeParameter('responseFormat', i) as string;
-    const filter = this.getNodeParameter('filter', i) as string;
-    const limit = this.getNodeParameter('limit', i) as number;
-    const offset = this.getNodeParameter('offset', i) as number;
-    const orderByCollection = this.getNodeParameter(
-        'orderBy',
-        i
-    ) as OrderByCollection;
-    const activeObjectCollection = this.getNodeParameter(
-        'activeObject',
-        i
-    ) as ActiveObjectCollection;
-
-    const orderBy =
-        orderByCollection.orderByFields &&
-        orderByCollection.orderByFields.map((field) => ({
-            [field.propertyName]: field.sortDirection,
-        }));
-
-    const q = JSON.stringify({
-        limetype: limeType,
-        responseFormat: JSON.parse(responseFormat),
-        filter: JSON.parse(filter),
-        limit: limit,
-        offset: offset,
-        orderBy: orderBy,
-    });
-
-    const activeObject = JSON.stringify(
-        activeObjectCollection.activeObjectFields
-    );
-
-    return queryLimeObjects(this, q, activeObject);
-}