@limetech/n8n-nodes-lime 2.5.3 → 2.5.5-dev.1

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

@@ -1,91 +0,0 @@
-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

@@ -1,273 +0,0 @@
-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/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"
-  ]
-}

package/typedoc.css

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

package/typedoc.json

@@ -1,19 +0,0 @@
-{
-  "$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
-}