@limetech/n8n-nodes-lime 0.1.0

package/nodes/lime-go/LimeGo.node.ts

@@ -0,0 +1,146 @@
+import {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeDescription,
+	NodeConnectionType,
+	NodeOperationError,
+} from 'n8n-workflow';
+
+// Import resource operations
+import { organization } from './actions/organization';
+import { person } from './actions/person';
+
+export class LimeGo implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Lime Go',
+		name: 'limeGo',
+		icon: 'file:lime-go.svg',
+		group: ['output'],
+		version: 1,
+		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+		description: 'Consume Lime Go API',
+		defaults: {
+			name: 'Lime Go',
+		},
+		inputs: [NodeConnectionType.Main],
+		outputs: [NodeConnectionType.Main],
+		credentials: [
+			{
+				name: 'limeGoApi',
+				required: true,
+			},
+		],
+		properties: [
+			{
+				displayName: 'Resource',
+				name: 'resource',
+				type: 'options',
+				noDataExpression: true,
+				options: [
+					{
+						name: 'Organization',
+						value: 'organization',
+						description: 'Work with organization data',
+					},
+					{
+						name: 'Person',
+						value: 'person',
+						description: 'Work with person data',
+					},
+					{
+						name: 'Test',
+						value: 'test',
+						description: 'Test the API',
+					},
+				],
+				default: 'organization',
+			},
+			// Add resource-specific operations
+			...organization.description,
+			...person.description,
+			{
+				displayName: 'Operation',
+				name: 'operation',
+				type: 'options',
+				noDataExpression: true,
+				displayOptions: {
+					show: {
+						resource: ['test'],
+					},
+				},
+				options: [
+					{
+						name: 'Ping',
+						value: 'ping',
+						description: 'Test that the LIME Go API is alive and kicking.',
+					},
+				],
+				default: 'ping',
+			},
+		],
+	};
+
+	methods = {
+		loadOptions: {
+			// Add any load options methods here as needed
+		},
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+
+		// For each item, process the operation
+		for (let i = 0; i < items.length; i++) {
+			try {
+				const resource = this.getNodeParameter('resource', i) as string;
+				const operation = this.getNodeParameter('operation', i) as string;
+
+				let responseData;
+
+				// Handle different resources and operations
+				if (resource === 'organization') {
+					// Execute the appropriate operation for organization
+					responseData = await organization.execute.call(this, { i });
+				} else if (resource === 'person') {
+					// Execute the appropriate operation for person
+					responseData = await person.execute.call(this, { i });
+				} else if (resource === 'test' && operation === 'ping') {
+					// Using n8n's requestWithAuthentication helper
+					responseData = await this.helpers.requestWithAuthentication.call(
+						this,
+						'limeGoApi',
+						{
+							method: 'GET',
+							url: 'https://api.lime-go.com/v1/ping',
+							json: true,
+						},
+					);
+				} else {
+					throw new NodeOperationError(this.getNode(), `The operation "${operation}" is not supported for resource "${resource}"!`, {
+						itemIndex: i,
+					});
+				}
+
+				// Add the result to the returned items
+				const executionData = this.helpers.constructExecutionMetaData(
+					this.helpers.returnJsonArray([responseData]),
+					{ itemData: { item: i } },
+				);
+				returnData.push(...executionData);
+
+			} catch (error) {
+				if (this.continueOnFail()) {
+					returnData.push({ json: { error: error.message } });
+					continue;
+				} else {
+					throw error;
+				}
+			}
+		}
+
+		return [returnData];
+	}
+}
+

package/nodes/lime-go/actions/organization/get.operation.ts

@@ -0,0 +1,42 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { graphqlRequest } from '../../transport/graphqlRequest';
+import { organizationFields } from './organizationFields';
+
+export const description: INodeProperties[] = [
+    {
+        displayName: 'Organization ID',
+        name: 'id',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['get'],
+            },
+        },
+        description: 'The ID of the organization to retrieve',
+    },
+    ...organizationFields,
+];
+
+export async function execute(this: IExecuteFunctions, { i }: { i: number }) {
+    const id = this.getNodeParameter('id', i) as string;
+    const returnFields = this.getNodeParameter('returnFields', i) as string[];
+
+    // Construct fields to return based on user selection
+    const fieldsToReturn = returnFields.join('\n');
+
+    const query = `
+		query ($id: ID!) {
+			organization(id: $id) {
+				${fieldsToReturn}
+			}
+		}
+	`;
+
+    const variables = { id };
+    const responseData = await graphqlRequest.call(this, query, variables);
+
+    return responseData.organization;
+}

package/nodes/lime-go/actions/organization/getByExternalKey.operation.ts

@@ -0,0 +1,57 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { graphqlRequest } from '../../transport/graphqlRequest';
+import { organizationFields } from './organizationFields';
+
+export const description: INodeProperties[] = [
+    {
+        displayName: 'External Key Value',
+        name: 'id',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['getByExternalKey'],
+            },
+        },
+        description: 'The external key value to lookup',
+    },
+    {
+        displayName: 'External Key Name',
+        name: 'externalKeyName',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['getByExternalKey'],
+            },
+        },
+        description: 'The name of the custom field or __integrationid / __bisnodeid',
+    },
+    ...organizationFields,
+];
+
+export async function execute(this: IExecuteFunctions, { i }: { i: number }) {
+    const id = this.getNodeParameter('id', i) as string;
+    const externalKeyName = this.getNodeParameter('externalKeyName', i) as string;
+    const returnFields = this.getNodeParameter('returnFields', i) as string[];
+
+    // Construct fields to return based on user selection
+    const fieldsToReturn = returnFields.join('\n');
+
+    const query = `
+		query ($id: String!, $externalKeyName: String!) {
+			organization(id: $id, externalKeyName: $externalKeyName) {
+				${fieldsToReturn}
+			}
+		}
+	`;
+
+    const variables = { id, externalKeyName };
+    const responseData = await graphqlRequest.call(this, query, variables);
+
+    return responseData.organization;
+}

package/nodes/lime-go/actions/organization/index.ts

@@ -0,0 +1,69 @@
+import { INodeProperties } from 'n8n-workflow';
+
+import * as get from './get.operation';
+import * as getByExternalKey from './getByExternalKey.operation';
+import * as search from './search.operation';
+import * as update from './update.operation';
+
+export const organization = {
+    description: [
+        {
+            displayName: 'Operation',
+            name: 'operation',
+            type: 'options',
+            noDataExpression: true,
+            displayOptions: {
+                show: {
+                    resource: ['organization'],
+                },
+            },
+            options: [
+                {
+                    name: 'Get',
+                    value: 'get',
+                    description: 'Get a specific organization by ID',
+                    action: 'Get an organization by ID',
+                },
+                {
+                    name: 'Get by External Key',
+                    value: 'getByExternalKey',
+                    description: 'Get a specific organization by External Key',
+                    action: 'Get an organization by external key',
+                },
+                {
+                    name: 'Search',
+                    value: 'search',
+                    description: 'Search for organizations',
+                    action: 'Search organizations',
+                },
+                {
+                    name: 'Update',
+                    value: 'update',
+                    description: 'Update an organization',
+                    action: 'Update an organization',
+                },
+            ],
+            default: 'get',
+        },
+        ...get.description,
+        ...getByExternalKey.description,
+        ...search.description,
+        ...update.description,
+    ] as INodeProperties[],
+    execute: async function (this: any, { i }: { i: number }) {
+        const operation = this.getNodeParameter('operation', i) as string;
+
+        switch (operation) {
+            case 'get':
+                return await get.execute.call(this, { i });
+            case 'getByExternalKey':
+                return await getByExternalKey.execute.call(this, { i });
+            case 'search':
+                return await search.execute.call(this, { i });
+            case 'update':
+                return await update.execute.call(this, { i });
+            default:
+                throw new Error(`The operation "${operation}" is not supported!`);
+        }
+    },
+};

package/nodes/lime-go/actions/organization/organizationFields.ts

@@ -0,0 +1,160 @@
+import { INodeProperties } from 'n8n-workflow';
+
+export const organizationFields: INodeProperties[] = [
+    {
+        displayName: 'Return Fields',
+        name: 'returnFields',
+        type: 'multiOptions',
+        options: [
+            {
+                name: 'ID',
+                value: 'id',
+            },
+            {
+                name: 'Name',
+                value: 'name',
+            },
+            {
+                name: 'City',
+                value: 'city',
+            },
+            {
+                name: 'Email',
+                value: 'email',
+            },
+            {
+                name: 'Phone Number',
+                value: 'phoneNumber',
+            },
+            {
+                name: 'Organization Number',
+                value: 'organizationNumber',
+            },
+            {
+                name: 'Integration ID',
+                value: 'integrationId',
+            },
+            {
+                name: 'Temperature',
+                value: 'temperature',
+            },
+            {
+                name: 'Customer Relation',
+                value: 'customerRelation',
+            },
+            {
+                name: 'Tags',
+                value: 'tags',
+            },
+            {
+                name: 'Turnover',
+                value: 'turnover',
+            },
+            {
+                name: 'Number of Employees',
+                value: 'numberOfEmployees',
+            },
+            {
+                name: 'Responsible Coworker',
+                value: 'responsibleCoworker { id name email phoneNumber }',
+            },
+            {
+                name: 'Custom Fields',
+                value: 'customFields { title type value }',
+            },
+        ],
+        default: ['id', 'name'],
+        description: 'The fields to return',
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['get', 'getByExternalKey', 'search', 'update'],
+            },
+        },
+    },
+    {
+        displayName: 'Additional Options',
+        name: 'additionalOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['get', 'getByExternalKey'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Include Employees',
+                name: 'includeEmployees',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include employees connected to the organization',
+            },
+            {
+                displayName: 'Employee Search Query',
+                name: 'employeeQuery',
+                type: 'string',
+                default: '',
+                displayOptions: {
+                    show: {
+                        includeEmployees: [true],
+                    },
+                },
+                description: 'Search query for filtering employees',
+            },
+            {
+                displayName: 'Employee Limit',
+                name: 'employeeLimit',
+                type: 'number',
+                default: 5,
+                typeOptions: {
+                    minValue: 1,
+                    maxValue: 20,
+                },
+                displayOptions: {
+                    show: {
+                        includeEmployees: [true],
+                    },
+                },
+                description: 'Max number of employees to return',
+            },
+            {
+                displayName: 'Include Deals',
+                name: 'includeDeals',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include deals connected to the organization',
+            },
+            {
+                displayName: 'Deal Search Query',
+                name: 'dealQuery',
+                type: 'string',
+                default: '',
+                displayOptions: {
+                    show: {
+                        includeDeals: [true],
+                    },
+                },
+                description: 'Search query for filtering deals',
+            },
+            {
+                displayName: 'Deal Limit',
+                name: 'dealLimit',
+                type: 'number',
+                default: 5,
+                typeOptions: {
+                    minValue: 1,
+                    maxValue: 20,
+                },
+                displayOptions: {
+                    show: {
+                        includeDeals: [true],
+                    },
+                },
+                description: 'Max number of deals to return',
+            },
+        ],
+    },
+];

package/nodes/lime-go/actions/organization/search.operation.ts

@@ -0,0 +1,73 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { graphqlRequest } from '../../transport/graphqlRequest';
+import { organizationFields } from './organizationFields';
+
+export const description: INodeProperties[] = [
+    {
+        displayName: 'Search Query',
+        name: 'query',
+        type: 'string',
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['search'],
+            },
+        },
+        description: 'Search text applied against organization name and address. Leave empty to return all organizations',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: 10,
+        typeOptions: {
+            minValue: 1,
+            maxValue: 20,
+        },
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['search'],
+            },
+        },
+        description: 'Max number of results to return (max: 20)',
+    },
+    {
+        displayName: 'Offset',
+        name: 'offset',
+        type: 'number',
+        default: 0,
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['search'],
+            },
+        },
+        description: 'Offset results by this number',
+    },
+    ...organizationFields,
+];
+
+export async function execute(this: IExecuteFunctions, { i }: { i: number }) {
+    const query = this.getNodeParameter('query', i) as string;
+    const limit = this.getNodeParameter('limit', i) as number;
+    const offset = this.getNodeParameter('offset', i) as number;
+    const returnFields = this.getNodeParameter('returnFields', i) as string[];
+
+    // Construct fields to return based on user selection
+    const fieldsToReturn = returnFields.join('\n');
+
+    const graphqlQuery = `
+		query ($query: String, $first: Int!, $offset: Int!) {
+			organizations(query: $query, first: $first, offset: $offset) {
+				${fieldsToReturn}
+			}
+		}
+	`;
+
+    const variables = { query, first: limit, offset };
+    const responseData = await graphqlRequest.call(this, graphqlQuery, variables);
+
+    return responseData.organizations;
+}

package/nodes/lime-go/actions/organization/update.operation.ts

@@ -0,0 +1,140 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { graphqlRequest } from '../../transport/graphqlRequest';
+import { organizationFields } from './organizationFields';
+
+export const description: INodeProperties[] = [
+    {
+        displayName: 'Organization ID',
+        name: 'id',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['update'],
+            },
+        },
+        description: 'The ID of the organization to update',
+    },
+    {
+        displayName: 'Update Fields',
+        name: 'updateFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['organization'],
+                operation: ['update'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Customer Relation',
+                name: 'relation',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Is a Customer',
+                        value: 'IS_A_CUSTOMER',
+                    },
+                    {
+                        name: 'Is a Lead',
+                        value: 'IS_A_LEAD',
+                    },
+                    {
+                        name: 'Is a Prospect',
+                        value: 'IS_A_PROSPECT',
+                    },
+                    {
+                        name: 'Not Interested',
+                        value: 'NOT_INTERESTED',
+                    },
+                ],
+                default: 'IS_A_CUSTOMER',
+                description: 'Set the customer relation',
+            },
+            {
+                displayName: 'Responsible Coworker Identifier',
+                name: 'responsibleCoworker',
+                type: 'string',
+                default: '',
+                description: 'Set the responsible coworker by their identifier',
+            },
+            {
+                displayName: 'Tags to Add',
+                name: 'addTags',
+                type: 'string',
+                default: '',
+                description: 'Comma-separated list of tags to add',
+            },
+            {
+                displayName: 'External Key Name',
+                name: 'externalKeyName',
+                type: 'string',
+                default: '',
+                description: 'Name of the external key field',
+            },
+            {
+                displayName: 'External Key Value',
+                name: 'externalKeyValue',
+                type: 'string',
+                default: '',
+                description: 'Value of the external key',
+            },
+        ],
+    },
+    ...organizationFields,
+];
+
+export async function execute(this: IExecuteFunctions, { i }: { i: number }) {
+    const id = this.getNodeParameter('id', i) as string;
+    const updateFields = this.getNodeParameter('updateFields', i) as {
+        relation?: string;
+        responsibleCoworker?: string;
+        addTags?: string;
+        externalKeyName?: string;
+        externalKeyValue?: string;
+    };
+    const returnFields = this.getNodeParameter('returnFields', i) as string[];
+
+    // Construct fields to return based on user selection
+    const fieldsToReturn = returnFields.join('\n');
+
+    // Build input object for the mutation
+    const input: Record<string, any> = { id };
+
+    if (updateFields.relation) {
+        input.relation = updateFields.relation;
+    }
+
+    if (updateFields.responsibleCoworker) {
+        input.responsibleCoworker = { identifier: updateFields.responsibleCoworker };
+    }
+
+    if (updateFields.addTags) {
+        const tagList = updateFields.addTags.split(',').map(tag => tag.trim());
+        input.tags = { addTags: tagList };
+    }
+
+    if (updateFields.externalKeyName && updateFields.externalKeyValue) {
+        input.externalKey = {
+            name: updateFields.externalKeyName,
+            value: updateFields.externalKeyValue,
+        };
+    }
+
+    const query = `
+		mutation ($input: UpdateOrganizationInput!) {
+			updateOrganization(input: $input) {
+				${fieldsToReturn}
+			}
+		}
+	`;
+
+    const variables = { input };
+    const responseData = await graphqlRequest.call(this, query, variables);
+
+    return responseData.updateOrganization;
+}