@limetech/n8n-nodes-lime 0.4.0 → 0.5.0

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/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);
-}

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

@@ -1,58 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodePropertyTypes,
-} from 'n8n-workflow';
-
-import * as getType from './operations/getType.operation';
-import * as listTypes from './operations/listTypes.operation';
-import * as getProperties from './operations/getProperties.operation';
-import { LIMETYPE_RESOURCE } from '../../commons';
-
-export const limeTypeFields: INodeProperties[] = [
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [LIMETYPE_RESOURCE],
-            },
-        },
-        options: [
-            {
-                ...listTypes.description,
-            },
-            {
-                ...getType.description,
-            },
-            {
-                ...getProperties.description,
-            },
-        ],
-        default: 'listTypes',
-    },
-
-    // Operation-specific fields
-    ...getType.properties,
-    ...getProperties.properties,
-];
-
-// Operations router
-export async function limeTypeOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number }
-) {
-    if (operation === 'listTypes') {
-        return await listTypes.execute.call(this);
-    }
-    if (operation === 'getType') {
-        return await getType.execute.call(this, i);
-    }
-    if (operation === 'getProperties') {
-        return await getProperties.execute.call(this, i);
-    }
-
-    return null;
-}

package/nodes/lime-crm/resources/limeType/operations/getProperties.operation.ts

@@ -1,42 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { getProperties } from '../../../transport';
-import { LIMETYPE_RESOURCE, LimeTypeProperty } from '../../../commons';
-import { NodeResponse } from '../../../../nodeResponse';
-
-export const description = {
-    name: 'Get Properties',
-    value: 'getProperties',
-    description: 'Get all properties for a specific entity type',
-    action: 'Get entity type properties',
-};
-
-export const properties: INodeProperties[] = [
-    // Limetype selection
-    {
-        displayName: 'Type Name',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The name of the entity type to get properties for',
-        displayOptions: {
-            show: {
-                resource: [LIMETYPE_RESOURCE],
-                operation: ['getProperties'],
-            },
-        },
-    },
-];
-
-export async function execute(
-    this: IExecuteFunctions,
-    i: number
-): Promise<NodeResponse<LimeTypeProperty[]>> {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-
-    return getProperties(this, limeType);
-}

package/nodes/lime-crm/resources/limeType/operations/getType.operation.ts

@@ -1,36 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { getLimeType } from '../../../transport/limetypes';
-import { LIMETYPE_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Get Type',
-    value: 'getType',
-    description: 'Get details about a specific entity type',
-    action: 'Get entity type details',
-};
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'Type Name',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The name of the entity type to get details for',
-        displayOptions: {
-            show: {
-                resource: [LIMETYPE_RESOURCE],
-                operation: ['getType'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-
-    return getLimeType(this, limeType);
-}

package/nodes/lime-crm/resources/limeType/operations/listTypes.operation.ts

@@ -1,18 +0,0 @@
-import { IExecuteFunctions } from 'n8n-workflow';
-
-import { getLimeTypesFromApi } from '../../../transport';
-import { LimeType } from '../../../commons';
-import { NodeResponse } from '../../../../nodeResponse';
-
-export const description = {
-    name: 'List Types',
-    value: 'listTypes',
-    description: 'Get a list of all available entity types',
-    action: 'List all entity types',
-};
-
-export async function execute(
-    this: IExecuteFunctions
-): Promise<NodeResponse<LimeType[]>> {
-    return await getLimeTypesFromApi(this);
-}