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

package/nodes/lime-crm/utils/webhook.ts

@@ -0,0 +1,81 @@
+import { Webhook, WebhookContext, WebhookFunctions } from '../models';
+
+/**
+ * Extract and format event identifiers from the node parameters.
+ *
+ * Builds an array of event strings in the format `<limetype>.<eventType>`
+ * based on the selected events.
+ *
+ * @param hookData - The n8n hook context
+ * @returns An array of formatted event strings.
+ *
+ * @internal
+ * @group Utils
+ */
+function getEvents(hookData: WebhookFunctions): string[] {
+    const eventData = hookData.getNodeParameter('events', []) as {
+        event: Array<{
+            limetype: string;
+            eventType: string;
+        }>;
+    };
+    const eventItems = eventData.event;
+    const events: string[] = [];
+    for (const eventItem of eventItems) {
+        events.push(`${eventItem.limetype}.${eventItem.eventType}`);
+    }
+    return events;
+}
+
+/**
+ * Generate a unique webhook name based on the selected Lime type and event.
+ *
+ * The name is constructed using the format:
+ * `<limetype>-<eventType>-<timestamp>`, ensuring uniqueness for each webhook.
+ *
+ * @param hookData - The n8n hook context used to access node parameters
+ * @returns A unique webhook name string.
+ *
+ * @internal
+ * @group Utils
+ */
+function createWebhookName(hookData: WebhookFunctions): string {
+    interface Events {
+        event: Array<{
+            limetype: string;
+            eventType: string;
+        }>;
+    }
+
+    const events = hookData.getNodeParameter('events') as Events;
+    return `${events.event[0].limetype}-${events.event[0].eventType}-${Date.now()}`;
+}
+
+/**
+ * Retrieve a fully constructed webhook object from the given node context.
+ *
+ * @param hookData - The n8n node context
+ *
+ * @returns A {@link Webhook} object with a generated name
+ *
+ * @public
+ * @group Utils
+ */
+export function getWebhook(hookData: WebhookFunctions): Webhook {
+    const node = hookData.getNode();
+    const workflow = hookData.getWorkflow();
+    const context: WebhookContext = {
+        nodeId: node.id,
+        nodeName: node.name,
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+    };
+
+    return {
+        data: hookData.getWorkflowStaticData('node'),
+        events: getEvents(hookData),
+        url: hookData.getNodeWebhookUrl('default'),
+        context: context,
+        name: createWebhookName(hookData),
+    };
+}

package/nodes/modules.ts

@@ -0,0 +1,44 @@
+import { INodeProperties, INodePropertyOptions } from 'n8n-workflow';
+
+/**
+ * Helper class describing a typical module for .operation.ts files
+ */
+interface N8NOperationModule {
+    description: INodePropertyOptions;
+    properties?: INodeProperties[];
+}
+
+/**
+ * Utility class used to simplify handling modules in N8N classes and
+ * show them in a standardized way
+ */
+export class N8NOperationModuleHandler {
+    modules: N8NOperationModule[];
+
+    /**
+     * Constructor class
+     * @param modules - list of modules for a given resource
+     */
+    constructor(modules: N8NOperationModule[]) {
+        this.modules = modules.sort((operation1, operation2) =>
+            operation1.description.name.localeCompare(
+                operation2.description.name,
+                'en'
+            )
+        );
+    }
+
+    /**
+     * Return descriptions for all the modules for a given resource
+     */
+    getDescriptions(): INodePropertyOptions[] {
+        return this.modules.map((operation) => operation.description);
+    }
+
+    /**
+     * Returns flatten properties for all modules for a given resource
+     */
+    getProperties(): INodeProperties[] {
+        return this.modules.flatMap((operation) => operation.properties || []);
+    }
+}

package/nodes/response.ts

@@ -0,0 +1,54 @@
+import { IBinaryData } from 'n8n-workflow';
+import { ErrorResponse, WorkflowErrorContext } from './errorHandling';
+
+/**
+ * Wrapper for successful response
+ */
+export type SuccessResponse<T> = {
+    success: true;
+    data: T;
+};
+
+/**
+ * Generic wrapper used for describing the data we are returning from workflow
+ * execution for the user
+ */
+export type WorkflowResponse<T> = T | { error: WorkflowErrorContext };
+
+/**
+ * Generic wrapper used for describing the data we are getting from the
+ * external API layer
+ */
+export type APIResponse<T> = SuccessResponse<T> | ErrorResponse;
+
+/**
+ * Response object that includes both JSON data and optional binary file content.
+ * Works in communication layer
+ *
+ * @typeParam T - The shape of the JSON data returned in the response
+ * @property json -  The {@link APIResponse} object, containing structured JSON data.
+ * @property binary - An optional record of binary file data
+ *
+ * @public
+ * @group Response
+ */
+export type FileAPIResponse<T> = {
+    json: APIResponse<T>;
+    binary?: Record<string, IBinaryData>;
+};
+
+/**
+ * Response object that includes both JSON data and optional binary file content.
+ * Works in user interface layer
+ *
+ * @typeParam T - The shape of the JSON data returned in the response
+ * @property json -  The {@link WorflowResponse} object, containing structured JSON data.
+ * @property binary - An optional record of binary file data
+ *
+ * @public
+ * @group Response
+ */
+export type WorkflowFileResponse<T> = {
+    json: WorkflowResponse<T>;
+    binary?: Record<string, IBinaryData>;
+};

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.5.0",
+  "version": "2.5.0-dev.1",
   "description": "n8n node to connect to Lime CRM",
-  "license": "MIT",
-  "main": "index.js",
+  "main": "nodes/index.ts",
   "scripts": {
     "build": "tsc && copyfiles \"nodes/**/*.svg\" dist",
     "dev": "tsc --watch",
@@ -13,7 +12,9 @@
     "lint:fix": "eslint --max-warnings=0 . --fix",
     "format": "prettier -c .",
     "format:fix": "prettier --write .",
-    "test": "jest"
+    "test": "jest",
+    "docs": "npx typedoc",
+    "knip": "knip"
   },
   "keywords": [
     "n8n",
@@ -36,41 +37,33 @@
     ]
   },
   "devDependencies": {
+    "@limetech/eslint-config": "^4.0.0",
     "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.4",
-    "@semantic-release/release-notes-generator": "^14.0.3",
     "@types/jest": "^30.0.0",
-    "@types/node": "^16.11.10",
-    "@types/request-promise-native": "^1.0.18",
+    "@types/node": "^24.10.1",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.38.0",
-    "@typescript-eslint/parser": "^8.38.0",
-    "concurrently": "^7.0.0",
+    "concurrently": "^9.2.1",
     "copyfiles": "^2.4.1",
-    "eslint": "^9.32.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-n8n-nodes-base": "^1.16.1",
-    "eslint-plugin-prettier": "^5.5.3",
-    "install": "^0.13.0",
-    "jest": "^30.0.5",
-    "nodemon": "^2.0.15",
-    "npm": "^11.5.2",
+    "eslint": "^9.39.1",
+    "jest": "^30.2.0",
+    "knip": "^5.69.0",
+    "nodemon": "^3.1.11",
     "prettier": "^3.6.2",
-    "semantic-release": "^24.2.7",
-    "ts-jest": "^29.4.1",
-    "typescript": "^5.9.2"
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.5",
+    "typedoc": "^0.28.14",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@limetech/eslint-config": "^3.0.2",
-    "@semantic-release/exec": "^7.1.0",
     "currency-codes": "^2.2.0",
-    "request": "^2.88.2",
-    "request-promise-native": "^1.0.9",
     "ws": "^8.18.3"
   },
   "peerDependencies": {
     "n8n-workflow": "^1.109.0"
+  },
+  "publishConfig": {
+    "access": "public"
   }
-}
+}

package/tests/nodes/lime-crm/methods.spec.ts

@@ -0,0 +1,91 @@
+import {
+    getCreateMappingColumns,
+    getUpdateMappingColumns,
+    LimetypeProperty,
+    SuccessResponse,
+} from '../../../nodes';
+import { ILoadOptionsFunctions } from 'n8n-workflow';
+import * as transport from '../../../nodes/lime-crm/transport';
+
+const mockILoadOptionFunctions = {
+    getNodeParameter: jest.fn().mockReturnValue('company'),
+} as unknown as ILoadOptionsFunctions;
+
+const propertiesResponseMock = {
+    success: true,
+    data: [
+        { name: 'p1', localname: 'Property 1', type: 'yesno', required: true },
+        {
+            name: 'p2',
+            localname: 'Property 2',
+            type: 'string',
+            required: false,
+            length: 2137,
+        },
+        {
+            name: 'p3',
+            localname: 'Property 3',
+            type: 'option',
+            required: true,
+            options: [
+                { key: 'op1', text: 'Option 1', inactive: false },
+                { key: 'op2', text: 'Option 2', inactive: false },
+                { key: 'op3', text: 'Option 3', inactive: true },
+            ],
+        },
+    ],
+} as SuccessResponse<LimetypeProperty[]>;
+
+describe('resourceMapping', () => {
+    beforeEach(() => {
+        jest.spyOn(transport, 'getProperties').mockResolvedValue(
+            propertiesResponseMock
+        );
+    });
+    it('gets valid resource mapping for create', async () => {
+        const columns = await getCreateMappingColumns.call(
+            mockILoadOptionFunctions
+        );
+        const property1 = columns.fields.find((p) => p.id == 'p1')!;
+
+        expect(property1.displayName).toBe('Property 1 [yesno]');
+        expect(property1.required).toBe(true);
+        expect(property1.defaultMatch).toBe(false);
+        expect(property1.display).toBe(true);
+        expect(property1.type).toBe('boolean');
+        expect(property1.options).toBe(undefined);
+
+        const property2 = columns.fields.find((p) => p.id == 'p2')!;
+        expect(property2.displayName).toBe('Property 2 [string(2137)]');
+        expect(property2.required).toBe(false);
+        expect(property2.defaultMatch).toBe(false);
+        expect(property2.display).toBe(true);
+        expect(property2.type).toBe('string');
+        expect(property2.options).toBe(undefined);
+
+        const property3 = columns.fields.find((p) => p.id == 'p3')!;
+        expect(property3.displayName).toBe('Property 3 [option]');
+        expect(property3.required).toBe(true);
+        expect(property3.defaultMatch).toBe(false);
+        expect(property3.display).toBe(true);
+        expect(property3.type).toBe('options');
+
+        const options = property3.options!;
+        expect(options).toContainEqual({
+            value: 'op1',
+            name: 'Option 1',
+        });
+        expect(options).toContainEqual({
+            value: 'op2',
+            name: 'Option 2',
+        });
+        expect(options.length).toBe(2);
+    });
+    it('gets proper required values for update', async () => {
+        const columns = await getUpdateMappingColumns.call(
+            mockILoadOptionFunctions
+        );
+        const requiredValues = columns.fields.map((p) => p.required);
+        expect(requiredValues).toEqual([false, false, false]);
+    });
+});

package/tests/nodes/lime-crm/utils.spec.ts

@@ -0,0 +1,273 @@
+jest.mock('../../../nodes/lime-crm/transport', () => ({
+    createFile: jest.fn().mockResolvedValue({
+        success: true,
+        data: { id: 1 },
+    }),
+    getFileMetadata: jest.fn().mockResolvedValue({
+        success: true,
+        data: {
+            id: '123',
+            name: 'file.txt',
+        },
+    }),
+    getFileContent: jest.fn().mockResolvedValue({
+        success: true,
+        data: 'some binary data',
+    }),
+    getTasks: jest.fn(),
+}));
+
+import {
+    createFile,
+    getFileContent,
+    getFileMetadata,
+    getFilenameFromHeader,
+    getFilePropertiesNames,
+    getWebhook,
+    processFileResponse,
+    setFilename,
+    setFileProperties,
+    verifyHmac,
+    WebhookFunctions,
+} from '../../../nodes';
+
+describe('files', () => {
+    describe('setFilename', () => {
+        it('returns responseFileName if fileName is missing', () => {
+            expect(
+                setFilename({ fileExtension: 'jpg' } as any, 'default.jpg')
+            ).toBe('default.jpg');
+        });
+        it('returns existing fileName if present', () => {
+            expect(
+                setFilename({ fileName: 'aspen.jpg' } as any, 'default.jpg')
+            ).toBe('aspen.jpg');
+        });
+    });
+
+    describe('getFilenameFromHeader', () => {
+        it('returns null if header is missing', () => {
+            expect(getFilenameFromHeader({})).toBeNull();
+        });
+
+        it('parses standard filename', () => {
+            expect(
+                getFilenameFromHeader({
+                    'content-disposition': 'attachment; filename="test.txt"',
+                })
+            ).toBe('test.txt');
+        });
+
+        it('parses RFC 5987 filename*', () => {
+            expect(
+                getFilenameFromHeader({
+                    'content-disposition':
+                        "attachment; filename*=UTF-8''test%20file.txt",
+                })
+            ).toBe('test file.txt');
+        });
+    });
+
+    describe('getFilePropertiesNames', () => {
+        const limetypes = [
+            {
+                name: 'company',
+                type: 'belongsto',
+                localname: 'company',
+                required: false,
+            },
+            {
+                name: 'name',
+                type: 'string',
+                localname: 'name',
+                required: false,
+            },
+            {
+                name: 'document',
+                type: 'file',
+                localname: 'document',
+                required: false,
+            },
+            {
+                name: 'photo',
+                type: 'file',
+                localname: 'photo',
+                required: false,
+            },
+        ];
+        it('returns all file property names', async () => {
+            const result = getFilePropertiesNames(limetypes);
+            expect(result.has('document')).toBe(true);
+            expect(result.has('photo')).toBe(true);
+            expect(result.has('name')).toBe(false);
+            expect(result.has('company')).toBe(false);
+        });
+        it('returns allowed file property names', async () => {
+            const result = getFilePropertiesNames(
+                limetypes,
+                new Set(['document'])
+            );
+            expect(result.has('document')).toBe(true);
+            expect(result.has('photo')).toBe(false);
+            expect(result.has('name')).toBe(false);
+            expect(result.has('company')).toBe(false);
+        });
+    });
+
+    describe('setFileProperties', () => {
+        const mockContext: any = {
+            helpers: {
+                assertBinaryData: jest.fn(),
+            },
+        };
+        const mockBinaryData = { data: 'some binary data' };
+
+        beforeEach(() => {
+            (createFile as jest.Mock).mockClear();
+            mockContext.helpers.assertBinaryData.mockClear();
+        });
+
+        it('sets file properties successfully', async () => {
+            mockContext.helpers.assertBinaryData.mockReturnValue(
+                mockBinaryData
+            );
+
+            const definedProperties = { document: 'some binary data' };
+            const result = await setFileProperties(
+                mockContext,
+                0,
+                new Set(['document']),
+                definedProperties
+            );
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.document).toBe(1);
+            }
+        });
+
+        it('sets file ID if assertBinaryData throws an error', async () => {
+            mockContext.helpers.assertBinaryData.mockImplementation(() => {
+                throw new Error('Invalid binary data');
+            });
+            const definedProperties = { document: 2 };
+            const result = await setFileProperties(
+                mockContext,
+                0,
+                new Set(['document']),
+                definedProperties
+            );
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.document).toBe(2);
+            }
+        });
+    });
+
+    describe('processFileResponse', () => {
+        const mockNodeContext = {};
+
+        beforeEach(() => {
+            (getFileMetadata as jest.Mock).mockClear();
+            (getFileContent as jest.Mock).mockClear();
+        });
+
+        it('returns file metadata without file content', async () => {
+            const data = { document: 1 };
+            const result = await processFileResponse<{ document: number }>(
+                mockNodeContext as any,
+                new Set(['document']),
+                data
+            );
+            expect(result.json.success).toBe(true);
+            if (result.json.success) {
+                expect(result.json.data.document).toEqual({
+                    id: '123',
+                    name: 'file.txt',
+                });
+                expect(result.binary).toEqual({});
+            }
+        });
+
+        it('returns file metadata with file content', async () => {
+            const data = { document: 1 };
+            const result = await processFileResponse<{ document: number }>(
+                mockNodeContext as any,
+                new Set(['document']),
+                data,
+                true
+            );
+            if (result.json.success) {
+                expect(result.json.data.document).toEqual({
+                    id: '123',
+                    name: 'file.txt',
+                });
+                expect(result.binary?.document).toEqual('some binary data');
+            }
+        });
+    });
+});
+
+describe('hmac', () => {
+    describe('verifyHmac', () => {
+        const key = 'my-secret-key';
+        const data = Buffer.from('hello world');
+        const correctHmac =
+            'sha256=90eb182d8396f16d4341d582047f45c0a97d73388c5377d9ced478a2212295ad';
+
+        it('returns true when the HMAC matches', () => {
+            expect(verifyHmac(key, data, correctHmac)).toBe(true);
+        });
+
+        it('returns false when the HMAC does not match', () => {
+            expect(verifyHmac(key, data, 'wrongHmac')).toBe(false);
+        });
+    });
+});
+
+describe('webhook', () => {
+    describe('getWebhhok', () => {
+        let mockHookData: jest.Mocked<WebhookFunctions>;
+
+        beforeEach(() => {
+            jest.useFakeTimers().setSystemTime(
+                new Date('2025-11-12T12:00:00Z')
+            );
+            mockHookData = {
+                getNode: jest.fn().mockReturnValue({ id: '1', name: 'MyNode' }),
+                getWorkflow: jest
+                    .fn()
+                    .mockReturnValue({ id: '2', name: 'MyWorkflow' }),
+                getWorkflowStaticData: jest
+                    .fn()
+                    .mockReturnValue({ key: 'value' }),
+                getNodeWebhookUrl: jest
+                    .fn()
+                    .mockReturnValue('https://example.com/hook'),
+                getNodeParameter: jest.fn().mockReturnValue({
+                    event: [{ limetype: 'company', eventType: 'new' }],
+                }),
+            } as unknown as jest.Mocked<WebhookFunctions>;
+        });
+
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+
+        it('constructs a full webhook object correctly', () => {
+            const result = getWebhook(mockHookData);
+
+            expect(result).toEqual({
+                data: { key: 'value' },
+                events: ['company.new'],
+                url: 'https://example.com/hook',
+                context: {
+                    nodeId: '1',
+                    nodeName: 'MyNode',
+                    workflowId: '2',
+                    workflowName: 'MyWorkflow',
+                },
+                name: 'company-new-1762948800000',
+            });
+        });
+    });
+});

package/typedoc.css

@@ -0,0 +1,9 @@
+.tsd-page-toolbar {
+    background-color: rgb(77, 182, 172);
+    border: 0;
+}
+
+#tsd-search .title,
+#tsd-search label {
+    --color-text: white;
+}

package/typedoc.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": [
+    "./nodes/lime-crm/index.ts",
+    "./nodes/response.ts",
+    "./credentials/index.ts"
+  ],
+  "entryPointStrategy": "expand",
+  "name": "Lime N8N Documentation",
+  "customCss": "typedoc.css",
+  "out": "docs",
+  "includeVersion": true,
+  "readme": "README.md",
+  "tsconfig": "tsconfig.json",
+  "disableSources": true,
+  "hideGenerator": true,
+  "categorizeByGroup": true,
+  "cleanOutputDir": true
+}

package/.dockerignore

@@ -1 +0,0 @@
-.git

package/dist/credentials/FortnoxApi.credentials.d.ts

@@ -1,9 +0,0 @@
-import { ICredentialType, INodeProperties, IAuthenticate, ICredentialTestRequest } from 'n8n-workflow';
-export declare class FortnoxApi implements ICredentialType {
-    name: string;
-    displayName: string;
-    documentationUrl: string;
-    properties: INodeProperties[];
-    authenticate: IAuthenticate;
-    test: ICredentialTestRequest;
-}