@limetech/n8n-nodes-lime 0.2.0 → 0.2.1

package/nodes/lime-go/actions/person/createMail.operation.ts

@@ -1,140 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { graphqlRequest } from '../../transport/graphqlRequest';
-
-export const description: INodeProperties[] = [
-    {
-        displayName: 'Email Subject',
-        name: 'subject',
-        type: 'string',
-        default: '',
-        required: true,
-        description: 'Subject of the email',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['createMail'],
-            },
-        },
-    },
-    {
-        displayName: 'Email Body',
-        name: 'body',
-        type: 'string',
-        typeOptions: {
-            rows: 4,
-        },
-        default: '',
-        required: true,
-        description: 'Body content of the email',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['createMail'],
-            },
-        },
-    },
-    {
-        displayName: 'Person Details',
-        name: 'personDetails',
-        type: 'collection',
-        placeholder: 'Add Person Details',
-        default: {},
-        options: [
-            {
-                displayName: 'First Name',
-                name: 'firstName',
-                type: 'string',
-                default: '',
-                description: 'First name of the person',
-            },
-            {
-                displayName: 'Last Name',
-                name: 'lastName',
-                type: 'string',
-                default: '',
-                description: 'Last name of the person',
-            },
-        ],
-        required: true,
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['createMail'],
-            },
-        },
-    },
-    {
-        displayName: 'Organization Details',
-        name: 'organizationDetails',
-        type: 'collection',
-        placeholder: 'Add Organization Details',
-        default: {},
-        options: [
-            {
-                displayName: 'Name',
-                name: 'name',
-                type: 'string',
-                default: '',
-                description: 'Name of the organization',
-            },
-            {
-                displayName: 'City',
-                name: 'city',
-                type: 'string',
-                default: '',
-                description: 'City of the organization',
-            },
-        ],
-        required: true,
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['createMail'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, { i }: { i: number }) {
-    const subject = this.getNodeParameter('subject', i) as string;
-    const body = this.getNodeParameter('body', i) as string;
-    const personDetails = this.getNodeParameter('personDetails', i) as {
-        firstName: string;
-        lastName: string;
-    };
-    const organizationDetails = this.getNodeParameter('organizationDetails', i) as {
-        name: string;
-        city: string;
-    };
-
-    const mutation = `
-		mutation ($input: CreateMailInput!) {
-			createMail(input: $input) {
-				mailId
-			}
-		}
-	`;
-
-    const input = {
-        email: {
-            subject,
-            body,
-        },
-        person: {
-            firstName: personDetails.firstName,
-            lastName: personDetails.lastName,
-        },
-        organization: {
-            name: organizationDetails.name,
-            city: organizationDetails.city,
-        },
-    };
-
-    const variables = { input };
-    const responseData = await graphqlRequest.call(this, mutation, variables);
-
-    return responseData.createMail;
-}
-
-// Add an export to ensure TypeScript recognizes this as a module
-export default {};

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

@@ -1,51 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { graphqlRequest } from '../../transport/graphqlRequest';
-import { personFields } from './personFields';
-
-export const description: INodeProperties[] = [
-    {
-        displayName: 'Person ID',
-        name: 'id',
-        type: 'string',
-        default: '',
-        required: true,
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['get'],
-            },
-        },
-        description: 'The ID of the person to retrieve',
-    },
-    ...personFields,
-];
-
-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[];
-    const includeEmployer = this.getNodeParameter('includeEmployer', i) as boolean;
-
-    let fieldsToReturn = [...returnFields];
-
-    // Add employer details if requested
-    if (includeEmployer) {
-        const employerFields = this.getNodeParameter('employerFields', i) as string[];
-        fieldsToReturn.push(`employer { ${employerFields.join(' ')} }`);
-    }
-
-    const query = `
-		query ($id: ID!) {
-			person(id: $id) {
-				${fieldsToReturn.join('\n')}
-			}
-		}
-	`;
-
-    const variables = { id };
-    const responseData = await graphqlRequest.call(this, query, variables);
-
-    return responseData.person;
-}
-
-// Add an export to ensure TypeScript recognizes this as a module
-export default {};

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

@@ -1,69 +0,0 @@
-import { INodeProperties } from 'n8n-workflow';
-
-import * as get from './get.operation';
-import * as search from './search.operation';
-import * as update from './update.operation';
-import * as createMail from './createMail.operation';
-
-export const person = {
-    description: [
-        {
-            displayName: 'Operation',
-            name: 'operation',
-            type: 'options',
-            noDataExpression: true,
-            displayOptions: {
-                show: {
-                    resource: ['person'],
-                },
-            },
-            options: [
-                {
-                    name: 'Get',
-                    value: 'get',
-                    description: 'Get a specific person by ID',
-                    action: 'Get a person by ID',
-                },
-                {
-                    name: 'Search',
-                    value: 'search',
-                    description: 'Search for persons',
-                    action: 'Search persons',
-                },
-                {
-                    name: 'Update',
-                    value: 'update',
-                    description: 'Update a person',
-                    action: 'Update a person',
-                },
-                {
-                    name: 'Create Mail',
-                    value: 'createMail',
-                    description: 'Add an email as a note',
-                    action: 'Create mail note',
-                },
-            ],
-            default: 'get',
-        },
-        ...get.description,
-        ...search.description,
-        ...update.description,
-        ...createMail.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 'search':
-                return await search.execute.call(this, { i });
-            case 'update':
-                return await update.execute.call(this, { i });
-            case 'createMail':
-                return await createMail.execute.call(this, { i });
-            default:
-                throw new Error(`The operation "${operation}" is not supported!`);
-        }
-    },
-};

package/nodes/lime-go/actions/person/personFields.ts

@@ -1,132 +0,0 @@
-import { INodeProperties } from 'n8n-workflow';
-
-export const personFields: INodeProperties[] = [
-    {
-        displayName: 'Return Fields',
-        name: 'returnFields',
-        type: 'multiOptions',
-        options: [
-            {
-                name: 'ID',
-                value: 'id',
-            },
-            {
-                name: 'Name',
-                value: 'name',
-            },
-            {
-                name: 'Email',
-                value: 'email',
-            },
-            {
-                name: 'Phone Number',
-                value: 'phoneNumber',
-            },
-            {
-                name: 'Employer Name',
-                value: 'employerName',
-            },
-            {
-                name: 'Position',
-                value: 'position',
-            },
-            {
-                name: 'Tags',
-                value: 'tags',
-            },
-            {
-                name: 'Currently Employed',
-                value: 'currentlyEmployed',
-            },
-            {
-                name: 'Email Consent',
-                value: 'emailConsent',
-            },
-            {
-                name: 'Custom Fields',
-                value: 'customFields { title type value }',
-            },
-        ],
-        default: ['id', 'name', 'email'],
-        description: 'The fields to return',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['get', 'search', 'update'],
-            },
-        },
-    },
-    {
-        displayName: 'Include Employer Details',
-        name: 'includeEmployer',
-        type: 'boolean',
-        default: false,
-        description: 'Whether to include detailed employer information',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['get', 'search'],
-            },
-        },
-    },
-    {
-        displayName: 'Employer Fields',
-        name: 'employerFields',
-        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: 'Tags',
-                value: 'tags',
-            },
-            {
-                name: 'Temperature',
-                value: 'temperature',
-            },
-            {
-                name: 'Customer Relation',
-                value: 'customerRelation',
-            },
-            {
-                name: 'Responsible Coworker',
-                value: 'responsibleCoworker { id name email phoneNumber }',
-            },
-            {
-                name: 'Custom Fields',
-                value: 'customFields { title type value }',
-            },
-        ],
-        default: ['id', 'name'],
-        description: 'The employer fields to return',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['get', 'search'],
-                includeEmployer: [true],
-            },
-        },
-    },
-];

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

@@ -1,88 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { graphqlRequest } from '../../transport/graphqlRequest';
-import { personFields } from './personFields';
-
-export const description: INodeProperties[] = [
-    {
-        displayName: 'Search Query',
-        name: 'query',
-        type: 'string',
-        default: '',
-        placeholder: 'anna.johansson@lundalogik.se',
-        description: 'Searches in person name, email, or employer name',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['search'],
-            },
-        },
-    },
-    {
-        displayName: 'Limit',
-        name: 'limit',
-        type: 'number',
-        default: 10,
-        description: 'Max number of results to return (max: 20)',
-        typeOptions: {
-            minValue: 1,
-            maxValue: 20,
-        },
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['search'],
-            },
-        },
-    },
-    {
-        displayName: 'Offset',
-        name: 'offset',
-        type: 'number',
-        default: 0,
-        description: 'Number of results to skip',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['search'],
-            },
-        },
-    },
-    ...personFields,
-];
-
-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[];
-    const includeEmployer = this.getNodeParameter('includeEmployer', i) as boolean;
-
-    let fieldsToReturn = [...returnFields];
-
-    // Add employer details if requested
-    if (includeEmployer) {
-        const employerFields = this.getNodeParameter('employerFields', i) as string[];
-        fieldsToReturn.push(`employer { ${employerFields.join(' ')} }`);
-    }
-
-    const graphqlQuery = `
-		query ($query: String, $first: Int!, $offset: Int!) {
-			persons(query: $query, first: $first, offset: $offset) {
-				${fieldsToReturn.join('\n')}
-			}
-		}
-	`;
-
-    const variables = {
-        query,
-        first: limit,
-        offset,
-    };
-
-    const responseData = await graphqlRequest.call(this, graphqlQuery, variables);
-
-    return responseData.persons;
-}
-
-// Add an export to ensure TypeScript recognizes this as a module
-export default {};

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

@@ -1,122 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { graphqlRequest } from '../../transport/graphqlRequest';
-import { personFields } from './personFields';
-
-export const description: INodeProperties[] = [
-    {
-        displayName: 'Person ID',
-        name: 'id',
-        type: 'string',
-        default: '',
-        required: true,
-        description: 'ID of the person to update',
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['update'],
-            },
-        },
-    },
-    {
-        displayName: 'Update Fields',
-        name: 'updateFields',
-        type: 'collection',
-        placeholder: 'Add Field',
-        default: {},
-        options: [
-            {
-                displayName: 'Email',
-                name: 'email',
-                type: 'string',
-                default: '',
-                description: 'Email address of the person',
-            },
-            {
-                displayName: 'Email Consent',
-                name: 'emailConsent',
-                type: 'boolean',
-                default: false,
-                description: 'Whether the person has given consent to receive emails',
-            },
-            {
-                displayName: 'Tags',
-                name: 'tags',
-                type: 'string',
-                default: '',
-                placeholder: 'tag1,tag2',
-                description: 'Comma-separated tags to add to the person',
-            },
-            {
-                displayName: 'Remove Tags',
-                name: 'removeTags',
-                type: 'string',
-                default: '',
-                placeholder: 'tag1,tag2',
-                description: 'Comma-separated tags to remove from the person',
-            },
-        ],
-        displayOptions: {
-            show: {
-                resource: ['person'],
-                operation: ['update'],
-            },
-        },
-    },
-    ...personFields,
-];
-
-export async function execute(this: IExecuteFunctions, { i }: { i: number }) {
-    const id = this.getNodeParameter('id', i) as string;
-    const updateFields = this.getNodeParameter('updateFields', i) as {
-        email?: string;
-        emailConsent?: boolean;
-        tags?: string;
-        removeTags?: string;
-    };
-    const returnFields = this.getNodeParameter('returnFields', i) as string[];
-
-    // Prepare input for GraphQL mutation
-    const input: Record<string, any> = {
-        id,
-    };
-
-    // Add optional fields if provided
-    if (updateFields.email !== undefined) {
-        input.email = updateFields.email;
-    }
-
-    if (updateFields.emailConsent !== undefined) {
-        input.emailConsent = updateFields.emailConsent;
-    }
-
-    // Handle tags
-    const tags: Record<string, any> = {};
-    if (updateFields.tags) {
-        tags.addTags = updateFields.tags.split(',').map(tag => tag.trim());
-    }
-
-    if (updateFields.removeTags) {
-        tags.removeTags = updateFields.removeTags.split(',').map(tag => tag.trim());
-    }
-
-    if (Object.keys(tags).length > 0) {
-        input.tags = tags;
-    }
-
-    // Execute GraphQL mutation
-    const mutation = `
-		mutation ($input: UpdatePersonInput!) {
-			updatePerson(input: $input) {
-				${returnFields.join('\n')}
-			}
-		}
-	`;
-
-    const variables = { input };
-    const responseData = await graphqlRequest.call(this, mutation, variables);
-
-    return responseData.updatePerson;
-}
-
-// Add an export to ensure TypeScript recognizes this as a module
-export default {};

package/nodes/lime-go/transport/graphqlRequest.ts

@@ -1,30 +0,0 @@
-import { IExecuteFunctions } from 'n8n-workflow';
-
-export async function graphqlRequest(
-    this: IExecuteFunctions,
-    query: string,
-    variables?: object,
-) {
-    const response = await this.helpers.requestWithAuthentication.call(
-        this,
-        'limeGoApi',
-        {
-            method: 'POST',
-            url: 'https://api.lime-go.com/v1/graphql',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: {
-                query,
-                variables,
-            },
-            json: true,
-        },
-    );
-
-    if (response.errors) {
-        throw new Error(`GraphQL request failed: ${JSON.stringify(response.errors)}`);
-    }
-
-    return response.data;
-}

package/tsconfig.json

@@ -1,30 +0,0 @@
-{
-	"compilerOptions": {
-		"strict": true,
-		"module": "commonjs",
-		"moduleResolution": "node",
-		"target": "es2019",
-		"lib": ["es2019", "es2020", "es2022"],
-		"removeComments": true,
-		"useUnknownInCatchVariables": false,
-		"forceConsistentCasingInFileNames": true,
-		"noImplicitAny": true,
-		"noImplicitReturns": true,
-		"noUnusedLocals": true,
-		"strictNullChecks": true,
-		"preserveConstEnums": true,
-		"esModuleInterop": true,
-		"resolveJsonModule": true,
-		"incremental": true,
-		"declaration": true,
-		"sourceMap": true,
-		"skipLibCheck": true,
-		"outDir": "./dist/",
-	},
-	"include": [
-		"credentials/**/*",
-		"nodes/**/*",
-		"nodes/**/*.json",
-		"package.json",
-	],
-}