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

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

@@ -0,0 +1,75 @@
+/**
+ * Set of helper functions, classes and types used for adapting the data from
+ * N8N's simple fields to Lime CRM format
+ */
+
+import { LimetypeProperty } from '../models';
+import { YES_NO_PROPERTY_TYPE, PropertyTypeMap } from '../models';
+
+/**
+ * Base inteface for Property Adapter class
+ */
+interface PropertyAdapter<T> {
+    adapt(value: string): T | string;
+}
+
+/**
+ * Adapter which takes a string from user input and parses it into boolean to
+ * conform to Lime CRM's YesNo type
+ */
+class YesNoPropertyAdapter implements PropertyAdapter<boolean> {
+    adapt(value: string): boolean | string {
+        if (value == 'true') {
+            return true;
+        } else if (value == 'false') {
+            return false;
+        }
+        return value;
+    }
+}
+
+/**
+ * Factory class which returns the proper adapter based on data type
+ * @param propertyType
+ */
+function getPropertyAdapter(
+    propertyType: string
+): PropertyAdapter<PropertyTypeMap[keyof PropertyTypeMap]> | null {
+    if (propertyType == YES_NO_PROPERTY_TYPE) {
+        return new YesNoPropertyAdapter();
+    }
+    return null;
+}
+
+/**
+ * Main function which takes the value from simple fields mode and the type of
+ * property and parses it accordingly to what Lime CRM expects
+ * @param propertyValue - user input, always string
+ * @param propertyType - type of property from Lime CRM
+ *
+ * @public
+ * @group Utils
+ */
+export function adaptProperty(propertyValue: string, propertyType: string) {
+    const adapter = getPropertyAdapter(propertyType);
+    return adapter === null ? propertyValue : adapter.adapt(propertyValue);
+}
+
+/**
+ * Given the name of the property and the set of Limetype properties, return the
+ * property type
+ * @param propertyName - name of the property we want to get the type of
+ * @param properties - list of {@link LimetypeProperty} entries
+ *
+ * @public
+ * @group Utils
+ */
+export function getPropertyType(
+    propertyName: string,
+    properties: LimetypeProperty[]
+): string {
+    return (
+        properties.find((property) => property.name === propertyName)?.type ||
+        'string'
+    );
+}

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,16 @@
+import { IBinaryData } from 'n8n-workflow';
+
+/**
+ * Response object that includes both JSON data and optional binary file content.
+ *
+ * @typeParam T - The shape of the JSON data returned in the response
+ * @property json -  The n8n node response, containing structured JSON data.
+ * @property binary - An optional record of binary file data
+ *
+ * @public
+ * @group Response
+ */
+export type FileResponse<T> = {
+    json: T;
+    binary?: Record<string, IBinaryData>;
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.5.0",
+  "version": "2.3.1-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 +13,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 +38,30 @@
     ]
   },
   "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"
   }
-}
+}

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

@@ -0,0 +1,238 @@
+jest.mock('../../../nodes/lime-crm/transport', () => ({
+    createFile: jest.fn().mockResolvedValue({
+        id: 1,
+    }),
+    getFileMetadata: jest.fn().mockResolvedValue({
+        id: '123',
+        name: 'file.txt',
+    }),
+    getFileContent: jest.fn().mockResolvedValue('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' },
+            { name: 'name', type: 'string', localname: 'name' },
+            { name: 'document', type: 'file', localname: 'document' },
+            { name: 'photo', type: 'file', localname: 'photo' },
+        ];
+        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.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.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(
+                mockNodeContext as any,
+                new Set(['document']),
+                data
+            );
+
+            expect(result.json.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(
+                mockNodeContext as any,
+                new Set(['document']),
+                data,
+                true
+            );
+
+            expect(result.json.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/Dockerfile

@@ -1,21 +0,0 @@
-# ----------- Stage 1: Build -----------
-FROM node:18 AS builder
-
-RUN mkdir /source
-WORKDIR /source
-COPY . .
-RUN npm install -g typescript@5.3.2
-RUN npm install --include=dev
-RUN npm run build
-
-
-# ----------- Stage 2: Production -----------
-FROM n8nio/n8n:1.113.2
-
-ENV N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom
-
-USER root
-COPY --from=builder /source/dist /home/node/.n8n/custom
-
-USER node
-WORKDIR /home/node

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

package/dist/credentials/FortnoxApi.credentials.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FortnoxApi = void 0;
-const commons_1 = require("../nodes/fortnox/commons");
-const transport_1 = require("../nodes/fortnox/transport");
-class FortnoxApi {
-    constructor() {
-        this.name = commons_1.FORTNOX_API_CREDENTIAL_KEY;
-        this.displayName = 'Fortnox API';
-        this.documentationUrl = 'https://www.fortnox.se/developer';
-        this.properties = [
-            {
-                displayName: 'Token',
-                name: 'token',
-                type: 'string',
-                typeOptions: {
-                    password: true,
-                },
-                default: '',
-                required: true,
-                description: 'Token for authentication with the Fortnox API',
-            },
-            {
-                displayName: 'Client Secret',
-                name: 'clientSecret',
-                type: 'string',
-                typeOptions: {
-                    password: true,
-                },
-                default: '',
-                description: 'Unique key provided when you register your Fortnox integration',
-            },
-        ];
-        this.authenticate = {
-            type: 'generic',
-            properties: {
-                headers: {
-                    Authorization: '=Bearer {{$credentials.token}}',
-                    Accept: 'application/json',
-                    'Content-Type': 'application/json',
-                },
-            },
-        };
-        this.test = {
-            request: {
-                baseURL: transport_1.FORTNOX_BASE_URL,
-                url: 'invoices',
-                method: 'GET',
-                headers: {
-                    Authorization: '=Bearer {{$credentials.token}}',
-                },
-            },
-        };
-    }
-}
-exports.FortnoxApi = FortnoxApi;
-//# sourceMappingURL=FortnoxApi.credentials.js.map

package/dist/credentials/FortnoxApi.credentials.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FortnoxApi.credentials.js","sourceRoot":"","sources":["../../credentials/FortnoxApi.credentials.ts"],"names":[],"mappings":";;;AAOA,sDAAsE;AACtE,0DAA8D;AAE9D,MAAa,UAAU;IAAvB;QACI,SAAI,GAAG,oCAA0B,CAAC;QAClC,gBAAW,GAAG,aAAa,CAAC;QAC5B,qBAAgB,GAAG,kCAAkC,CAAC;QACtD,eAAU,GAAsB;YAC5B;gBACI,WAAW,EAAE,OAAO;gBACpB,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE;oBACT,QAAQ,EAAE,IAAI;iBACjB;gBACD,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,IAAI;gBACd,WAAW,EAAE,+CAA+C;aAC/D;YACD;gBACI,WAAW,EAAE,eAAe;gBAC5B,IAAI,EAAE,cAAc;gBACpB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE;oBACT,QAAQ,EAAE,IAAI;iBACjB;gBACD,OAAO,EAAE,EAAE;gBACX,WAAW,EACP,gEAAgE;aACvE;SACJ,CAAC;QAEF,iBAAY,GAAkB;YAC1B,IAAI,EAAE,SAAS;YACf,UAAU,EAAE;gBACR,OAAO,EAAE;oBACL,aAAa,EAAE,gCAAgC;oBAC/C,MAAM,EAAE,kBAAkB;oBAC1B,cAAc,EAAE,kBAAkB;iBACrC;aACJ;SACJ,CAAC;QAEF,SAAI,GAA2B;YAC3B,OAAO,EAAE;gBACL,OAAO,EAAE,4BAAgB;gBACzB,GAAG,EAAE,UAAU;gBACf,MAAM,EAAE,KAA4B;gBACpC,OAAO,EAAE;oBACL,aAAa,EAAE,gCAAgC;iBAClD;aACJ;SACJ,CAAC;IACN,CAAC;CAAA;AAlDD,gCAkDC"}

package/dist/credentials/LimeCrmApi.credentials.d.ts

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