@limetech/n8n-nodes-lime 0.5.0 → 2.5.0-dev.1

package/nodes/lime-crm/resources/erpConnector/operations/createOrUpdateObjects.operation.ts

@@ -1,69 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { startCreateOrUpdateObjectsTask } from '../../../transport';
-import { ERP_CONNECTOR_RESOURCE } from '../../../commons';
-import { LimeCrmData } from '../transform';
-import { waitForTaskCompletion } from '../../../commons/task';
-
-export const description = {
-    name: 'Create Or Update Objects Task',
-    value: 'createOrUpdateObjects',
-    description: 'Sync data between ERP and Lime CRM',
-    action: 'Create or Update Objects',
-};
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'Data',
-        name: 'data',
-        type: 'json',
-        default: '',
-        description: 'Provide payload',
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['createOrUpdateObjects'],
-            },
-        },
-    },
-    {
-        displayName: 'Poll Interval',
-        name: 'pollInterval',
-        type: 'number',
-        default: 2,
-        description: 'Seconds between polls',
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['createOrUpdateObjects'],
-            },
-        },
-    },
-    {
-        displayName: 'Timeout',
-        name: 'timeout',
-        type: 'number',
-        default: 60,
-        description: 'Max total wait time in seconds',
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['createOrUpdateObjects'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const data = this.getNodeParameter('data', i) as LimeCrmData;
-    const pollInterval =
-        (this.getNodeParameter('pollInterval', i) as number) * 1000;
-    const timeout = (this.getNodeParameter('timeout', i) as number) * 1000;
-
-    const response = await startCreateOrUpdateObjectsTask(this, data);
-
-    if (!response.success) return response;
-
-    const taskId = response.data.id;
-    return await waitForTaskCompletion(this, taskId, pollInterval, timeout);
-}

package/nodes/lime-crm/resources/erpConnector/operations/transform.operation.ts

@@ -1,274 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    INodePropertyCollection,
-} from 'n8n-workflow';
-
-import {
-    CustomLimetypeNames,
-    Entity,
-    ErpData,
-    ErpSystem,
-    SearchParameters,
-    transform,
-} from '../transform';
-import { ERP_CONNECTOR_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Transform ERP Data',
-    value: 'transformErpData',
-    description:
-        'Transform and map ERP data into the structure required by Lime CRM',
-    action: 'Transform',
-};
-
-type PropertyMappingItem = {
-    defaultPropertyName: string;
-    customPropertyName: string;
-};
-
-type Properties = {
-    properties: PropertyMappingItem[];
-};
-
-type CustomPropertiesMapping = {
-    [key in Entity]: Properties;
-};
-
-const defaults: { [key in Entity]: string[] } = {
-    invoice: [
-        'invoice_number',
-        'company',
-        'customerid',
-        'customer_reference',
-        'coworker',
-        'invoice_type',
-        'invoice_date',
-        'invoice_expires',
-        'currency',
-        'conversionrate',
-        'invoice_sum',
-        'invoice_vat',
-        'invoice_total_sum',
-        'invoice_balance',
-        'paid',
-        'paid_date',
-        'invoice_shredded',
-    ],
-    invoicerow: [
-        'company',
-        'invoice',
-        'item',
-        'description',
-        'units',
-        'row_margin',
-        'row_value',
-        'rowid',
-    ],
-    company: ['erp_id'],
-    coworker: ['name'],
-};
-
-function getLimetypesPropertiesMapping(): INodeProperties[] {
-    return Object.keys(defaults).map((key) => ({
-        displayName: key,
-        name: key,
-        type: 'fixedCollection',
-        typeOptions: {
-            multipleValues: true,
-        },
-        default: {},
-        options: getPropertiesMapping(key as Entity),
-    }));
-}
-
-function getPropertiesMapping(limetype: Entity): INodePropertyCollection[] {
-    return [
-        {
-            displayName: 'Properties',
-            name: 'properties',
-            values: [
-                {
-                    displayName: 'Property',
-                    name: 'defaultPropertyName',
-                    type: 'options',
-                    default: '',
-                    description: 'Name of the property',
-                    options: defaults[limetype]?.map((property) => ({
-                        name: property,
-                        value: property,
-                    })),
-                },
-                {
-                    displayName: 'Custom Property Name',
-                    name: 'customPropertyName',
-                    type: 'string',
-                    default: '',
-                    description: 'Custom name of the property in your Lime CRM',
-                },
-            ],
-        },
-    ];
-}
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'ERP System',
-        name: 'erpSystem',
-        type: 'options',
-        options: [
-            {
-                name: 'Fortnox',
-                value: 'fortnox',
-            },
-        ],
-        required: true,
-        default: '',
-        description: '',
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['transformErpData'],
-            },
-        },
-    },
-    {
-        displayName: 'Entity',
-        name: 'entity',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getEntitiesForErpSystem',
-            loadOptionsDependsOn: ['erpSystem'],
-        },
-        required: true,
-        default: '',
-        description: 'Type of entity to sync',
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['transformErpData'],
-            },
-        },
-    },
-    {
-        displayName: 'Search Parameters',
-        name: 'searchParameters',
-        type: 'collection',
-        placeholder: 'Add search criteria',
-        default: {},
-        options: [
-            {
-                displayName: 'Search Property',
-                name: 'property',
-                type: 'string',
-                default: '',
-                description: 'Property to search the object by',
-            },
-            {
-                displayName: 'Search Value',
-                name: 'value',
-                type: 'string',
-                default: '',
-                description: 'Value of the search property',
-            },
-            {
-                displayName: 'Create',
-                name: 'create',
-                type: 'boolean',
-                default: true,
-                description: 'Whether to create a new object',
-            },
-        ],
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['transformErpData'],
-            },
-        },
-    },
-    {
-        displayName: 'Custom Limetype Name',
-        name: 'customLimetypeNames',
-        type: 'collection',
-        default: {},
-        description: 'Optional custom name for the Lime CRM types.',
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['transformErpData'],
-            },
-        },
-        options: [
-            {
-                displayName: 'Invoice',
-                name: 'invoice',
-                type: 'string',
-                default: 'invoice',
-            },
-            {
-                displayName: 'Invoice Row',
-                name: 'invoicerow',
-                type: 'string',
-                default: 'invoicerow',
-            },
-        ],
-    },
-    {
-        displayName: 'Custom Properties Mapping',
-        name: 'customPropertiesMapping',
-        type: 'collection',
-        default: {},
-        displayOptions: {
-            show: {
-                resource: [ERP_CONNECTOR_RESOURCE],
-                operation: ['transformErpData'],
-            },
-        },
-        description: 'Select Limetype',
-        options: getLimetypesPropertiesMapping(),
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const data = this.getInputData(i);
-
-    const erpSystem = this.getNodeParameter('erpSystem', i) as ErpSystem;
-    const entity = this.getNodeParameter('entity', i) as Entity;
-    const searchParameters = this.getNodeParameter(
-        'searchParameters',
-        i
-    ) as SearchParameters;
-    const customLimetypeNames = this.getNodeParameter(
-        'customLimetypeNames',
-        i
-    ) as CustomLimetypeNames;
-    const customPropertiesMapping = this.getNodeParameter(
-        'customPropertiesMapping',
-        i
-    ) as CustomPropertiesMapping;
-
-    const customPropertiesNames = Object.fromEntries(
-        Object.entries(customPropertiesMapping).map(
-            ([limetype, { properties }]) => [
-                limetype,
-                Object.fromEntries(
-                    properties.map(
-                        ({ defaultPropertyName, customPropertyName }) => [
-                            defaultPropertyName,
-                            customPropertyName,
-                        ]
-                    )
-                ),
-            ]
-        )
-    );
-
-    return transform(
-        erpSystem,
-        entity,
-        data[0].json as ErpData,
-        searchParameters,
-        customLimetypeNames,
-        customPropertiesNames
-    );
-}

package/nodes/lime-crm/resources/erpConnector/transform.ts

@@ -1,49 +0,0 @@
-import { FortnoxTransformer } from './transformers';
-
-export type Entity = 'invoice' | 'invoicerow' | 'company' | 'coworker';
-export type ErpSystem = 'fortnox';
-export type ErpData = Record<string, unknown>;
-
-export type CustomLimetypeNames = Partial<Record<Entity, string>>;
-
-export type CustomPropertiesNames = Partial<
-    Record<Entity, Record<string, string>>
->;
-
-export type SearchParameters = {
-    property?: string;
-    value?: string | number | boolean;
-    create?: boolean;
-};
-
-export type LimeCrmObjectData = {
-    [key: string]:
-        | LimeCrmData
-        | SearchParameters
-        | string
-        | number
-        | boolean
-        | null;
-};
-
-export type LimeCrmData = LimeCrmObjectData[];
-
-export function transform(
-    erpSystem: ErpSystem,
-    entity: Entity,
-    data: ErpData,
-    searchParameters: SearchParameters,
-    customLimetypeNames?: CustomLimetypeNames,
-    customPropertiesNames?: CustomPropertiesNames
-): LimeCrmData {
-    if (erpSystem === 'fortnox') {
-        return new FortnoxTransformer().transform(
-            entity,
-            data,
-            searchParameters,
-            customLimetypeNames,
-            customPropertiesNames
-        );
-    }
-    throw new Error(`Unsupported ERP system: ${erpSystem}`);
-}

package/nodes/lime-crm/resources/erpConnector/transformers/baseTransformer.ts

@@ -1,18 +0,0 @@
-import {
-    CustomLimetypeNames,
-    CustomPropertiesNames,
-    Entity,
-    ErpData,
-    LimeCrmData,
-    SearchParameters,
-} from '../transform';
-
-export abstract class BaseTransformer {
-    abstract transform(
-        entity: Entity,
-        data: ErpData,
-        searchParameters: SearchParameters,
-        customLimetypeNames?: CustomLimetypeNames,
-        customPropertiesNames?: CustomPropertiesNames
-    ): LimeCrmData;
-}

package/nodes/lime-crm/resources/erpConnector/transformers/fortnox.ts

@@ -1,201 +0,0 @@
-import { BaseTransformer } from './baseTransformer';
-import {
-    CustomLimetypeNames,
-    CustomPropertiesNames,
-    Entity,
-    ErpData,
-    LimeCrmData,
-    LimeCrmObjectData,
-    SearchParameters,
-} from '../transform';
-
-export interface FortnoxInvoiceRowData extends ErpData {
-    ArticleNumber: string;
-    Description: string;
-    DeliveredQuantity: string;
-    ContributionPercent: string;
-    Total: number;
-    RowId: number;
-}
-
-export interface FortnoxInvoiceData extends ErpData {
-    DocumentNumber: string;
-    InvoiceType: string;
-    InvoiceDate: string;
-    DueDate: string;
-    Currency: string;
-    Net: number;
-    TotalVAT: number;
-    Total: number;
-    Balance: number;
-    FinalPayDate: string | null;
-    CustomerNumber: string;
-    YourReference: string;
-    OurReference: string;
-    InvoiceRows: FortnoxInvoiceRowData[];
-}
-
-export class FortnoxTransformer extends BaseTransformer {
-    readonly INVOICE_MAPPING: {
-        [key: string]: (
-            _data: FortnoxInvoiceData,
-            _customPropertiesNames?: CustomPropertiesNames
-        ) => string | number | boolean | object | null;
-    } = {
-        invoice_number: (_data, _customPropertiesNames) =>
-            _data['DocumentNumber'],
-        invoice_type: (_data, _customPropertiesNames) => _data['InvoiceType'],
-        invoice_date: (_data, _customPropertiesNames) => _data['InvoiceDate'],
-        invoice_expires: (_data, _customPropertiesNames) => _data['DueDate'],
-        currency: (_data, _customPropertiesNames) => _data['Currency'],
-        invoice_sum: (_data, _customPropertiesNames) => _data['Net'],
-        invoice_vat: (_data, _customPropertiesNames) => _data['TotalVAT'],
-        invoice_total_sum: (_data, _customPropertiesNames) => _data['Total'],
-        invoice_balance: (_data, _customPropertiesNames) => _data['Balance'],
-        paid: (_data, _customPropertiesNames) => _data['Balance'] === 0,
-        paid_date: (_data, _customPropertiesNames) => _data['FinalPayDate'],
-        invoice_shredded: (_data, _customPropertiesNames) => false,
-        customerid: (_data, _customPropertiesNames) => _data['CustomerNumber'],
-        customer_reference: (_data, _customPropertiesNames) =>
-            _data['YourReference'],
-        company: (_data, _customPropertiesNames) => ({
-            _search: {
-                property:
-                    _customPropertiesNames?.company?.['erp_id'] || 'erp_id',
-                value: _data['CustomerNumber'],
-                create: false,
-            },
-        }),
-        coworker: (_data, _customPropertiesNames) => ({
-            _search: {
-                property: _customPropertiesNames?.coworker?.['name'] || 'name',
-                value: _data['OurReference'],
-                create: false,
-            },
-        }),
-    };
-
-    readonly INVOICE_ROW_MAPPING: {
-        [key: string]: (
-            _data: FortnoxInvoiceRowData,
-            _customPropertiesNames?: CustomPropertiesNames
-        ) => string | number | boolean | object;
-    } = {
-        company: (_data, _customPropertiesNames) => ({
-            _search: {
-                property:
-                    _customPropertiesNames?.company?.['erp_id'] || 'erp_id',
-                value: _data['CustomerNumber'],
-                create: false,
-            },
-        }),
-        invoice: (_data, _customPropertiesNames) => ({
-            _search: {
-                property:
-                    _customPropertiesNames?.invoice?.['invoice_number'] ||
-                    'invoice_number',
-                value: _data['DocumentNumber'],
-                create: false,
-            },
-        }),
-        item: (_data, _customPropertiesNames) => _data['ArticleNumber'],
-        description: (_data, _customPropertiesNames) => _data['Description'],
-        units: (_data, _customPropertiesNames) => +_data['DeliveredQuantity'],
-        row_margin: (_data, _customPropertiesNames) =>
-            +_data['ContributionPercent'],
-        row_value: (_data, _customPropertiesNames) => +_data['Total'],
-        rowid: (_data, _customPropertiesNames) => _data['RowId'],
-    };
-
-    transform(
-        entity: Entity,
-        data: ErpData,
-        searchParameters: SearchParameters,
-        customLimetypeNames?: CustomLimetypeNames,
-        customPropertiesNames?: CustomPropertiesNames
-    ): LimeCrmData {
-        if (entity === 'invoice') {
-            {
-                return this._transformInvoice(
-                    data as FortnoxInvoiceData,
-                    searchParameters,
-                    customLimetypeNames,
-                    customPropertiesNames
-                );
-            }
-        } else {
-            {
-                throw new Error(`Unsupported entity type: ${entity}`);
-            }
-        }
-    }
-
-    protected _transformInvoice(
-        data: FortnoxInvoiceData,
-        searchParameters: SearchParameters,
-        customLimetypeNames?: CustomLimetypeNames,
-        customPropertiesNames?: CustomPropertiesNames
-    ): LimeCrmData {
-        const limeCrmData: LimeCrmData = [];
-
-        const invoice: LimeCrmObjectData = {
-            _limetype: customLimetypeNames?.invoice || 'invoice',
-            _search: searchParameters,
-        };
-
-        for (const [limeCrmKey, getLimeCrmValue] of Object.entries(
-            this.INVOICE_MAPPING
-        )) {
-            invoice[
-                customPropertiesNames?.invoice?.[limeCrmKey] || limeCrmKey
-            ] = getLimeCrmValue(data, customPropertiesNames);
-        }
-        limeCrmData.push(invoice);
-
-        for (const invoiceRow of data['InvoiceRows']) {
-            invoiceRow['DocumentNumber'] = data['DocumentNumber'];
-            invoiceRow['CustomerNumber'] = data['CustomerNumber'];
-            limeCrmData.push(
-                ...this._transformInvoiceRow(
-                    invoiceRow,
-                    {
-                        property:
-                            customPropertiesNames?.invoicerow?.['rowid'] ||
-                            'rowid',
-                        value: invoiceRow['RowId'],
-                        create: true,
-                    },
-                    customLimetypeNames,
-                    customPropertiesNames
-                )
-            );
-        }
-
-        return limeCrmData;
-    }
-
-    protected _transformInvoiceRow(
-        data: FortnoxInvoiceRowData,
-        searchParameters: SearchParameters,
-        customLimetypeNames?: CustomLimetypeNames,
-        customPropertiesNames?: CustomPropertiesNames
-    ): LimeCrmData {
-        const limeCrmData: LimeCrmData = [];
-
-        const invoiceRow: LimeCrmObjectData = {
-            _limetype: customLimetypeNames?.invoicerow || 'invoicerow',
-            _search: searchParameters,
-        };
-
-        for (const [limeCrmKey, getLimeCrmValue] of Object.entries(
-            this.INVOICE_ROW_MAPPING
-        )) {
-            invoiceRow[
-                customPropertiesNames?.invoicerow?.[limeCrmKey] || limeCrmKey
-            ] = getLimeCrmValue(data, customPropertiesNames);
-        }
-        limeCrmData.push(invoiceRow);
-
-        return limeCrmData;
-    }
-}

package/nodes/lime-crm/resources/erpConnector/transformers/index.ts

@@ -1 +0,0 @@
-export { FortnoxTransformer } from './fortnox';

package/nodes/lime-crm/transport/erpConnector.ts

@@ -1,21 +0,0 @@
-import { callLimeApi } from './commons';
-import { IAllExecuteFunctions } from 'n8n-workflow';
-import { LimeCrmData } from '../resources/erpConnector/transform';
-import { NodeResponse } from '../../nodeResponse';
-
-const ERP_CONNECTOR_URL = '/limepkg-erp-connector/';
-
-export interface CreateOrUpdateObjectsTaskResponse {
-    id: string;
-    status: string;
-    result: Record<string, unknown> | null;
-}
-
-export async function startCreateOrUpdateObjectsTask(
-    nodeContext: IAllExecuteFunctions,
-    data: LimeCrmData
-): Promise<NodeResponse<CreateOrUpdateObjectsTaskResponse>> {
-    return await callLimeApi(nodeContext, 'PUT', ERP_CONNECTOR_URL, {
-        body: data,
-    });
-}

package/nodes/lime-crm/transport/task.ts

@@ -1,32 +0,0 @@
-import { IAllExecuteFunctions } from 'n8n-workflow';
-import { callLimeApi } from './commons';
-
-const TASK_URL = '/api/v1/task/';
-
-interface Task {
-    id: string;
-    status: 'PENDING' | 'STARTED' | 'SUCCESS' | 'FAILURE' | 'REVOKED' | 'RETRY';
-    result: unknown;
-}
-
-interface GetTasksApiResponse {
-    _embedded: {
-        tasks: Task[];
-    };
-}
-
-export async function getTasks(
-    nodeContext: IAllExecuteFunctions,
-    taskId: string
-) {
-    return await callLimeApi<GetTasksApiResponse>(
-        nodeContext,
-        'GET',
-        TASK_URL,
-        {
-            qs: {
-                id: taskId,
-            },
-        }
-    );
-}

package/nodes/nodeResponse.ts

@@ -1,13 +0,0 @@
-type SuccessResponse<T> = {
-    success: true;
-    data: T;
-};
-
-type FailureResponse = {
-    success: false;
-    error: string;
-    status?: number;
-    metadata?: Record<string, unknown>;
-};
-
-export type NodeResponse<T> = SuccessResponse<T> | FailureResponse;