n8n-workflow-builder-mcp 0.1.0

package/tests/unit/workflowCreation.test.js

@@ -0,0 +1,110 @@
+/**
+ * Workflow Creation Tool Tests
+ */
+
+const { createWorkflowExecute } = require('../../src/tools/workflowCreation');
+const { workflowStorage } = require('../../src/models/storage');
+
+// Mock dependencies
+jest.mock('../../src/models/storage', () => ({
+    workflowStorage: {
+        saveWorkflow: jest.fn()
+    }
+}));
+
+jest.mock('../../src/utils/securityLogger', () => ({
+    logDataAccess: jest.fn(),
+    logSecurityEvent: jest.fn()
+}));
+
+jest.mock('../../src/utils/logger', () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn()
+    }
+}));
+
+jest.mock('uuid', () => ({
+    v4: jest.fn().mockReturnValue('test-uuid')
+}));
+
+// Cleanup mocks after each test
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+describe('Workflow Creation Tool', () => {
+    it('should create a workflow with minimum required parameters', async () => {
+        // Setup the mock implementation
+        workflowStorage.saveWorkflow.mockResolvedValue(true);
+
+        // Execute the tool
+        const result = await createWorkflowExecute({
+            name: 'Test Workflow'
+        });
+
+        // Verify the result
+        expect(result.workflowId).toBe('test-uuid');
+        expect(result.workflowData.name).toBe('Test Workflow');
+        expect(result.workflowData.description).toBe('');
+        expect(result.workflowData.active).toBe(false);
+        expect(result.workflowData.nodes).toEqual([]);
+        expect(result.workflowData.connections).toEqual({});
+
+        // Verify the workflowStorage.saveWorkflow was called
+        expect(workflowStorage.saveWorkflow).toHaveBeenCalledWith(
+            'test-uuid',
+            expect.objectContaining({
+                id: 'test-uuid',
+                name: 'Test Workflow'
+            }),
+            expect.stringContaining('test-uuid.json')
+        );
+    });
+
+    it('should create a workflow with all parameters', async () => {
+        // Setup the mock implementation
+        workflowStorage.saveWorkflow.mockResolvedValue(true);
+
+        // Execute the tool
+        const result = await createWorkflowExecute({
+            name: 'Test Workflow',
+            description: 'Test Description',
+            active: true,
+            settings: {
+                executionTimeout: 7200
+            },
+            userId: 'test-user'
+        });
+
+        // Verify the result
+        expect(result.workflowId).toBe('test-uuid');
+        expect(result.workflowData.name).toBe('Test Workflow');
+        expect(result.workflowData.description).toBe('Test Description');
+        expect(result.workflowData.active).toBe(true);
+        expect(result.workflowData.settings.executionTimeout).toBe(7200);
+
+        // Verify the workflowStorage.saveWorkflow was called
+        expect(workflowStorage.saveWorkflow).toHaveBeenCalledWith(
+            'test-uuid',
+            expect.objectContaining({
+                id: 'test-uuid',
+                name: 'Test Workflow',
+                description: 'Test Description',
+                active: true
+            }),
+            expect.stringContaining('test-uuid.json')
+        );
+    });
+
+    it('should handle errors properly', async () => {
+        // Setup the mock implementation to throw an error
+        const errorMessage = 'Test error message';
+        workflowStorage.saveWorkflow.mockRejectedValue(new Error(errorMessage));
+
+        // Execute the tool and expect it to throw
+        await expect(createWorkflowExecute({
+            name: 'Test Workflow'
+        })).rejects.toThrow(errorMessage);
+    });
+}); 

package/tests/unit/workflowTesting.test.js

@@ -0,0 +1,269 @@
+/**
+ * Unit tests for workflow testing tools
+ */
+
+const { testWorkflowTool, getExecutionStatusTool } = require('../../src/tools/workflowTesting');
+const { workflowStorage } = require('../../src/models/storage');
+const fetch = require('node-fetch');
+const config = require('../../config/default');
+
+// Mock dependencies
+jest.mock('../../src/models/storage');
+jest.mock('node-fetch');
+jest.mock('../../src/utils/logger', () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warn: jest.fn()
+    }
+}));
+jest.mock('../../src/utils/securityLogger', () => ({
+    logDataAccess: jest.fn(),
+    logSecurityEvent: jest.fn()
+}));
+jest.mock('../../src/models/n8nIntegration', () => ({
+    getIntegrationType: jest.fn().mockReturnValue('api')
+}));
+jest.mock('../../config/default', () => ({
+    n8n: {
+        apiUrl: 'http://localhost:5678/api/',
+        apiKey: 'test-api-key'
+    },
+    storage: {
+        workflowsPath: './test-workflow_nodes',
+        versioning: {
+            enabled: true,
+            maxVersions: 10
+        }
+    },
+    server: {
+        port: 3000,
+        env: 'test'
+    },
+    auth: {
+        jwtSecret: 'test-secret',
+        jwtExpiresIn: '1d',
+        apiKeys: ['test-key']
+    },
+    logging: {
+        level: 'info'
+    }
+}));
+
+describe('Workflow Testing Tools', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe('testWorkflowTool', () => {
+        it('should execute a workflow and return results', async () => {
+            // Mock workflowStorage.loadWorkflow to return a valid workflow
+            workflowStorage.loadWorkflow.mockResolvedValueOnce({
+                id: 'test-workflow-id',
+                name: 'Test Workflow'
+            });
+
+            // Mock successful fetch response
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce({
+                    executionId: 'test-execution-id',
+                    data: { result: 'success' },
+                    logs: ['Workflow started', 'Workflow completed'],
+                    executionTime: 1234,
+                    status: 'completed'
+                })
+            };
+            fetch.mockResolvedValueOnce(mockResponse);
+
+            // Call the tool
+            const result = await testWorkflowTool.execute({
+                workflowId: 'test-workflow-id',
+                testData: { input: 'test-data' }
+            });
+
+            // Verify fetch was called with the correct arguments
+            expect(fetch).toHaveBeenCalledWith(
+                'http://localhost:5678/api/workflows/test-workflow-id/execute',
+                expect.objectContaining({
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-N8N-API-KEY': 'test-api-key'
+                    },
+                    body: JSON.stringify({ data: { input: 'test-data' } })
+                })
+            );
+
+            // Verify result structure
+            expect(result).toEqual({
+                success: true,
+                executionId: 'test-execution-id',
+                data: { result: 'success' },
+                logs: ['Workflow started', 'Workflow completed'],
+                executionTime: 1234,
+                status: 'completed'
+            });
+        });
+
+        it('should handle workflow not found', async () => {
+            // Mock workflowStorage.loadWorkflow to return null (workflow not found)
+            workflowStorage.loadWorkflow.mockResolvedValueOnce(null);
+
+            // Call the tool and expect it to throw an error
+            await expect(testWorkflowTool.execute({
+                workflowId: 'non-existent-workflow',
+                testData: { input: 'test-data' }
+            })).rejects.toThrow('Failed to execute workflow: Workflow with ID non-existent-workflow not found');
+
+            // Verify fetch was not called
+            expect(fetch).not.toHaveBeenCalled();
+        });
+
+        it('should handle API errors', async () => {
+            // Mock workflowStorage.loadWorkflow to return a valid workflow
+            workflowStorage.loadWorkflow.mockResolvedValueOnce({
+                id: 'test-workflow-id',
+                name: 'Test Workflow'
+            });
+
+            // Mock failed fetch response
+            const mockResponse = {
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+                json: jest.fn().mockResolvedValueOnce({
+                    message: 'Workflow not found in n8n'
+                })
+            };
+            fetch.mockResolvedValueOnce(mockResponse);
+
+            // Call the tool and expect it to throw an error
+            await expect(testWorkflowTool.execute({
+                workflowId: 'test-workflow-id',
+                testData: { input: 'test-data' }
+            })).rejects.toThrow('Failed to execute workflow: 404 Not Found');
+        });
+
+        it('should handle timeouts', async () => {
+            // Mock workflowStorage.loadWorkflow to return a valid workflow
+            workflowStorage.loadWorkflow.mockResolvedValueOnce({
+                id: 'test-workflow-id',
+                name: 'Test Workflow'
+            });
+
+            // Mock fetch to simulate a timeout by rejecting with AbortError after delay
+            const abortError = new Error('The operation was aborted');
+            abortError.name = 'AbortError';
+            fetch.mockRejectedValueOnce(abortError);
+
+            // Call the tool and expect it to throw a timeout error
+            await expect(testWorkflowTool.execute({
+                workflowId: 'test-workflow-id',
+                testData: { input: 'test-data' },
+                timeout: 1000 // 1 second timeout
+            })).rejects.toThrow('Failed to execute workflow: Workflow execution timed out after 1000ms');
+        }, 10000); // Set test timeout to 10 seconds
+
+        it('should reject filesystem integration for execution', async () => {
+            // Mock getIntegrationType to return 'filesystem'
+            const { getIntegrationType } = require('../../src/models/n8nIntegration');
+            getIntegrationType.mockReturnValueOnce('filesystem');
+
+            // Mock workflowStorage.loadWorkflow to return a valid workflow
+            workflowStorage.loadWorkflow.mockResolvedValueOnce({
+                id: 'test-workflow-id',
+                name: 'Test Workflow'
+            });
+
+            // Call the tool and expect it to throw an error about filesystem integration
+            await expect(testWorkflowTool.execute({
+                workflowId: 'test-workflow-id',
+                testData: { input: 'test-data' }
+            })).rejects.toThrow('Failed to execute workflow: Direct workflow execution not supported for filesystem integration');
+
+            // Verify fetch was not called
+            expect(fetch).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('getExecutionStatusTool', () => {
+        it('should get execution status successfully', async () => {
+            // Mock successful fetch response
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValueOnce({
+                    id: 'test-execution-id',
+                    status: 'completed',
+                    data: { result: 'success' },
+                    startedAt: '2023-01-01T00:00:00.000Z',
+                    finishedAt: '2023-01-01T00:01:00.000Z',
+                    workflowId: 'test-workflow-id',
+                    mode: 'manual'
+                })
+            };
+            fetch.mockResolvedValueOnce(mockResponse);
+
+            // Call the tool
+            const result = await getExecutionStatusTool.execute({
+                executionId: 'test-execution-id'
+            });
+
+            // Verify fetch was called with the correct arguments
+            expect(fetch).toHaveBeenCalledWith(
+                'http://localhost:5678/api/executions/test-execution-id',
+                expect.objectContaining({
+                    method: 'GET',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-N8N-API-KEY': 'test-api-key'
+                    }
+                })
+            );
+
+            // Verify result structure
+            expect(result).toEqual({
+                success: true,
+                executionId: 'test-execution-id',
+                status: 'completed',
+                data: { result: 'success' },
+                startedAt: '2023-01-01T00:00:00.000Z',
+                finishedAt: '2023-01-01T00:01:00.000Z',
+                workflowId: 'test-workflow-id',
+                mode: 'manual'
+            });
+        });
+
+        it('should handle API errors', async () => {
+            // Mock failed fetch response
+            const mockResponse = {
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+                json: jest.fn().mockResolvedValueOnce({
+                    message: 'Execution not found'
+                })
+            };
+            fetch.mockResolvedValueOnce(mockResponse);
+
+            // Call the tool and expect it to throw an error
+            await expect(getExecutionStatusTool.execute({
+                executionId: 'non-existent-execution'
+            })).rejects.toThrow('Failed to get execution status: 404 Not Found');
+        });
+
+        it('should reject filesystem integration for status check', async () => {
+            // Mock getIntegrationType to return 'filesystem'
+            const { getIntegrationType } = require('../../src/models/n8nIntegration');
+            getIntegrationType.mockReturnValueOnce('filesystem');
+
+            // Call the tool and expect it to throw an error about filesystem integration
+            await expect(getExecutionStatusTool.execute({
+                executionId: 'test-execution-id'
+            })).rejects.toThrow('Failed to get execution status: Execution status check not supported for filesystem integration');
+
+            // Verify fetch was not called
+            expect(fetch).not.toHaveBeenCalled();
+        });
+    });
+}); 

package/tests/user.test.js

@@ -0,0 +1,181 @@
+/**
+ * User Model Tests
+ * 
+ * Tests for the user roles and permissions model
+ */
+
+const {
+    PERMISSIONS,
+    ROLES,
+    ROLE_PERMISSIONS,
+    hasPermission,
+    getUserPermissions,
+    validateRole
+} = require('../src/models/user');
+
+describe('User Model', () => {
+    describe('PERMISSIONS', () => {
+        it('should define all necessary permission constants', () => {
+            // Workflow permissions
+            expect(PERMISSIONS.WORKFLOW_VIEW).toBeDefined();
+            expect(PERMISSIONS.WORKFLOW_CREATE).toBeDefined();
+            expect(PERMISSIONS.WORKFLOW_EDIT).toBeDefined();
+            expect(PERMISSIONS.WORKFLOW_DELETE).toBeDefined();
+            expect(PERMISSIONS.WORKFLOW_EXECUTE).toBeDefined();
+
+            // Node permissions
+            expect(PERMISSIONS.NODE_VIEW).toBeDefined();
+            expect(PERMISSIONS.NODE_ADD).toBeDefined();
+            expect(PERMISSIONS.NODE_EDIT).toBeDefined();
+            expect(PERMISSIONS.NODE_DELETE).toBeDefined();
+
+            // Connection permissions
+            expect(PERMISSIONS.CONNECTION_VIEW).toBeDefined();
+            expect(PERMISSIONS.CONNECTION_CREATE).toBeDefined();
+            expect(PERMISSIONS.CONNECTION_DELETE).toBeDefined();
+
+            // Credential permissions
+            expect(PERMISSIONS.CREDENTIAL_VIEW).toBeDefined();
+            expect(PERMISSIONS.CREDENTIAL_CREATE).toBeDefined();
+            expect(PERMISSIONS.CREDENTIAL_EDIT).toBeDefined();
+            expect(PERMISSIONS.CREDENTIAL_DELETE).toBeDefined();
+
+            // System permissions
+            expect(PERMISSIONS.SYSTEM_ADMIN).toBeDefined();
+        });
+    });
+
+    describe('ROLES', () => {
+        it('should define all necessary roles', () => {
+            expect(ROLES.ADMIN).toBeDefined();
+            expect(ROLES.EDITOR).toBeDefined();
+            expect(ROLES.VIEWER).toBeDefined();
+        });
+    });
+
+    describe('ROLE_PERMISSIONS', () => {
+        it('should define permissions for admin role', () => {
+            const adminPerms = ROLE_PERMISSIONS[ROLES.ADMIN];
+            expect(adminPerms).toBeDefined();
+            expect(adminPerms).toContain(PERMISSIONS.SYSTEM_ADMIN);
+            expect(adminPerms).toContain(PERMISSIONS.WORKFLOW_DELETE);
+            expect(adminPerms).toContain(PERMISSIONS.CREDENTIAL_EDIT);
+        });
+
+        it('should define permissions for editor role', () => {
+            const editorPerms = ROLE_PERMISSIONS[ROLES.EDITOR];
+            expect(editorPerms).toBeDefined();
+            expect(editorPerms).toContain(PERMISSIONS.WORKFLOW_EDIT);
+            expect(editorPerms).toContain(PERMISSIONS.NODE_EDIT);
+            expect(editorPerms).not.toContain(PERMISSIONS.WORKFLOW_DELETE);
+            expect(editorPerms).not.toContain(PERMISSIONS.SYSTEM_ADMIN);
+        });
+
+        it('should define permissions for viewer role', () => {
+            const viewerPerms = ROLE_PERMISSIONS[ROLES.VIEWER];
+            expect(viewerPerms).toBeDefined();
+            expect(viewerPerms).toContain(PERMISSIONS.WORKFLOW_VIEW);
+            expect(viewerPerms).toContain(PERMISSIONS.NODE_VIEW);
+            expect(viewerPerms).not.toContain(PERMISSIONS.WORKFLOW_EDIT);
+            expect(viewerPerms).not.toContain(PERMISSIONS.NODE_EDIT);
+        });
+    });
+
+    describe('hasPermission()', () => {
+        it('should return false for undefined user', () => {
+            expect(hasPermission(undefined, PERMISSIONS.WORKFLOW_VIEW)).toBe(false);
+        });
+
+        it('should return false for user without roles', () => {
+            const user = { id: 'user123' };
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_VIEW)).toBe(false);
+        });
+
+        it('should return false if user has no matching role', () => {
+            const user = { id: 'user123', roles: ['unknown-role'] };
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_VIEW)).toBe(false);
+        });
+
+        it('should return true for admin with any permission', () => {
+            const user = { id: 'admin123', roles: [ROLES.ADMIN] };
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_DELETE)).toBe(true);
+            expect(hasPermission(user, PERMISSIONS.CREDENTIAL_EDIT)).toBe(true);
+            expect(hasPermission(user, PERMISSIONS.SYSTEM_ADMIN)).toBe(true);
+        });
+
+        it('should return correct permissions for editor role', () => {
+            const user = { id: 'editor123', roles: [ROLES.EDITOR] };
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_EDIT)).toBe(true);
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_DELETE)).toBe(false);
+        });
+
+        it('should return correct permissions for viewer role', () => {
+            const user = { id: 'viewer123', roles: [ROLES.VIEWER] };
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_VIEW)).toBe(true);
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_EDIT)).toBe(false);
+        });
+
+        it('should check permissions across multiple roles', () => {
+            const user = { id: 'multi123', roles: [ROLES.VIEWER, ROLES.EDITOR] };
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_VIEW)).toBe(true);
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_EDIT)).toBe(true);
+            expect(hasPermission(user, PERMISSIONS.WORKFLOW_DELETE)).toBe(false);
+        });
+    });
+
+    describe('getUserPermissions()', () => {
+        it('should return empty array for undefined user', () => {
+            expect(getUserPermissions(undefined)).toEqual([]);
+        });
+
+        it('should return empty array for user without roles', () => {
+            const user = { id: 'user123' };
+            expect(getUserPermissions(user)).toEqual([]);
+        });
+
+        it('should return all permissions for admin', () => {
+            const user = { id: 'admin123', roles: [ROLES.ADMIN] };
+            const permissions = getUserPermissions(user);
+
+            expect(permissions).toContain(PERMISSIONS.SYSTEM_ADMIN);
+            expect(permissions).toContain(PERMISSIONS.WORKFLOW_DELETE);
+            expect(permissions).toContain(PERMISSIONS.CREDENTIAL_EDIT);
+            expect(permissions.length).toBe(ROLE_PERMISSIONS[ROLES.ADMIN].length);
+        });
+
+        it('should return combined permissions for multiple roles', () => {
+            const user = { id: 'multi123', roles: [ROLES.VIEWER, ROLES.EDITOR] };
+            const permissions = getUserPermissions(user);
+
+            // Should include viewer permissions
+            expect(permissions).toContain(PERMISSIONS.WORKFLOW_VIEW);
+
+            // Should include editor permissions
+            expect(permissions).toContain(PERMISSIONS.WORKFLOW_EDIT);
+
+            // Should not include admin permissions
+            expect(permissions).not.toContain(PERMISSIONS.SYSTEM_ADMIN);
+
+            // Should deduplicate permissions
+            const uniquePermissions = new Set([
+                ...ROLE_PERMISSIONS[ROLES.VIEWER],
+                ...ROLE_PERMISSIONS[ROLES.EDITOR]
+            ]);
+            expect(permissions.length).toBe(uniquePermissions.size);
+        });
+    });
+
+    describe('validateRole()', () => {
+        it('should return true for valid roles', () => {
+            expect(validateRole(ROLES.ADMIN)).toBe(true);
+            expect(validateRole(ROLES.EDITOR)).toBe(true);
+            expect(validateRole(ROLES.VIEWER)).toBe(true);
+        });
+
+        it('should return false for invalid roles', () => {
+            expect(validateRole('invalid-role')).toBe(false);
+            expect(validateRole('')).toBe(false);
+            expect(validateRole(undefined)).toBe(false);
+        });
+    });
+}); 

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "target": "es2020", /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+        "module": "commonjs", /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
+        "outDir": "./dist", /* Redirect output structure to the directory. */
+        "rootDir": "./src", /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+        "strict": true, /* Enable all strict type-checking options. */
+        "esModuleInterop": true, /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+        "skipLibCheck": true, /* Skip type checking of declaration files. */
+        "forceConsistentCasingInFileNames": true, /* Disallow inconsistently-cased references to the same file. */
+        "resolveJsonModule": true /* Include modules imported with .json extension */
+    },
+    "include": [
+        "src/**/*.ts" /* Only include files in the src directory */
+    ],
+    "exclude": [
+        "node_modules",
+        "**/*.test.ts"
+    ]
+}

package/workflow_nodes/Brandfetch.json

@@ -0,0 +1,85 @@
+{
+  "nodeType": "n8n-nodes-base.Brandfetch",
+  "displayName": "Brandfetch",
+  "description": "Consume Brandfetch API",
+  "version": 1,
+  "properties": [
+    {
+      "name": "operation",
+      "displayName": "Operation",
+      "type": "options",
+      "default": null,
+      "description": "Return a company's colors"
+    },
+    {
+      "name": "Company",
+      "default": null,
+      "description": "Return a company's data"
+    },
+    {
+      "name": "Font",
+      "default": null,
+      "description": "Return a company's fonts"
+    },
+    {
+      "name": "Industry",
+      "default": null,
+      "description": "Return a company's industry"
+    },
+    {
+      "name": "Logo",
+      "default": null,
+      "description": "Return a company's logo & icon"
+    },
+    {
+      "name": "domain",
+      "displayName": "Domain",
+      "type": "string",
+      "default": "",
+      "description": "The domain name of the company",
+      "required": true
+    },
+    {
+      "name": "download",
+      "displayName": "Download",
+      "type": "boolean",
+      "default": false,
+      "description": "Name of the binary property to which to write the data of the read file",
+      "required": true
+    },
+    {
+      "name": "imageTypes",
+      "displayName": "Image Type",
+      "type": "multiOptions",
+      "default": null
+    },
+    {
+      "name": "imageFormats",
+      "displayName": "Image Format",
+      "type": "multiOptions",
+      "default": null
+    },
+    {
+      "name": "SVG",
+      "default": null
+    }
+  ],
+  "credentialsConfig": [
+    {
+      "name": "brandfetchApi",
+      "required": true
+    },
+    {
+      "name": "operation",
+      "required": false
+    },
+    {
+      "name": "domain",
+      "required": true
+    },
+    {
+      "name": "imageFormats",
+      "required": false
+    }
+  ]
+}