feat: Make it possible to dynamically load community nodes (#2849)

* ✨ Make it possible to dynamically load node packages * ⚡ Fix comment * ✨ Make possible to dynamically install nodes from npm * Created migration for sqlite regarding community nodes * Saving to db whenever a package with nodes is installed * Created endpoint to fetch installed packages * WIP - uninstall package with nodes * Fix lint issues * Updating nodes via API * Lint and improvement fixes * Created community node helpers and removed packages taht do not contain nodes * Check for package updates when fetching installed packages * Blocked access to non-owner and preventing incorrect install of packages * Added auto healing process * Unit tests for helpers * Finishing tests for helpers * Improved unit tests, refactored more helpers and created integration tests for GET * Implemented detection of missing packages on init and added warning to frontend settings * Add check for banned packages and fix broken tests * Create migrations for other db systems * Updated with latest changes from master * Fixed conflict errors * Improved unit tests, refactored more helpers and created integration tests for GET * Implemented detection of missing packages on init and added warning to frontend settings * 🔥 Removing access check for the Settings sidebar item * ✨ Added inital community nodes settings screen * ⚡Added executionMode flag to settings * ✨ Implemented N8N-callout component * 💄Updating Callout component template propery names * 💄 Updating Callout component styling. * 💄Updating Callout component sizing and colors. * ✔️ Updating Callout component test snapshots after styling changes * ✨ Updating the `ActionBox` component so it supports callouts and conditional button rendering * 💄 Removing duplicate callout theme validation in the `ActionBox` component. Adding a selection control for it in the storybook. * ✨ Added warning message if instance is in the queue mode. Updated colors based on the new design. * ⚡ Added a custom permission support to router * 🔨 Implemented UM detection as a custom permission. * 👌Updating route permission logic. * ✨ Implemented installed community packages list in the settings view * 👌 Updating settings routes rules and community nodes setting view. * Allow installation of packages that failed to load * 👌 Updating `ActionBox`, `CommuntyPackageCard` components and settings loading logic. * 👌 Fixing community nodes loading state and sidebar icon spacing. * ✨ Implemented loading skeletons for community package cards * 👌 Handling errrors while loading installed package list. Updating spacing. * 👌 Updating community nodes error messages. * Added disable flag * 🐛 Fixing a community nodes update detection bug when there are missing packages. (#3497) * ✨ Added front-end support for community nodes feature flag * ✨ Implemented community package installation modal dialog * 💄 Community nodes installation modal updates: Moved links to constants and used them in translations, disabling inputs in loading state. * ✨ Implemented community packages install flow * Standardize error codes (#3501) * Standardize error: 400 for request issues such as invalid package name and 500 for installation problems * Fix http status code for when package is not found * ✨ Implemented community package installation modal dialog * 💄 Community nodes installation modal updates: Moved links to constants and used them in translations, disabling inputs in loading state. * ✨ Implemented community packages install flow * ✨ Updated error handling based on the response codes * ✨ Implemented community package installation modal dialog * ✨ Implemented community package uninstall flow. * ✨ Finished update confirm modal UI * 💄 Replaced community nodes tooltip image with the one exported from figma. * ✨ Implemented community package update process * ✨ Updating community nodes list after successful package update * 🔒 Updating public API setting route to use new access rules. Updating express app definition in community nodes tests * ✨ Implemented community package installation modal dialog * 💄 Community nodes installation modal updates: Moved links to constants and used them in translations, disabling inputs in loading state. * ✨ Implemented community packages install flow * ✨ Updated error handling based on the response codes * Change output for installation request * Improve payload for update requests * 👌 Updating community nodes install modal UI * 👌 Updating community nodes confirm modal logic * 👌 Refactoring community nodes confirm modal dialog * 👌 Separating community nodes components loading states * 💄 Updating community nodes install modal spacing. * Fix behavior for installing already installed packages * 💡 Commenting community nodes install process * 🔥 Removing leftover commits of deleted Vue mutations * ✨ Updated node list to identify community nodes and handle node name clash * ✨ Implemented missing community node dialog. * 💄 Updating n8n-tabs component to support tooltips * ✨ Updating node details with community node details. * 🔨 Using back-end response when updating community packages * 👌 Updating tabs component and refactoring community nodes store mutations * 👌 Adding community node flag to node type descriptions and using it to identify community nodes * 👌 Hiding unnecessary elements from missing node details panel. * 👌 Updating missing node type descriptions for custom and community nodes * 👌 Updating community node package name detection logic * 👌 Removing communityNode flag from node description * ✨ Adding `force` flag to credentials fetching (#3527) * ✨ Adding `force` flag to credentials fetching which can be used to skip check when loading credentials * ✨ Forcing credentials loading when opening nodeView * 👌 Minor updates to community nodes details panel * tests for post endpoint * duplicate comments * Add Patch and Delete enpoints tests * 🔒 Using `pageCategory`prop to assemble the list of settings routes instead of hard-coded array (#3562) * 📈 Added front-end telemetry events for community nodes * 📈 Updating community nodes telemetry events * 💄 Updating community nodes settings UI elements based on product/design review * 💄 Updating node view & node details view for community nodes based on product/design feedback * 💄 Fixing community node text capitalisation * ✨ Adding community node install error message under the package name input field * Fixed and improved tests * Fix lint issue * feat: Migrated to npm release of riot-tmpl fork. * 📈 Updating community nodes telemetry events based on the product review * 💄 Updating community nodes UI based on the design feedback * 🔀 Merging recent node draggable panels changes * Implement self healing process * Improve error messages for package name requirement and disk space * 💄 Removing front-end error message override since appropriate response is available from the back-end * Fix lint issues * Fix installed node name * 💄 Removed additional node name parsing * 📈 Updating community nodes telemetry events * Fix postgres migration for cascading nodes when package is removed * Remove postman mock for banned packages * 📈 Adding missing telemetry event for community node documentation click * 🐛 Fixing community nodes UI bugs reported during the bug bash * Fix issue with uninstalling packages not reflecting UI * 🐛 Fixing a missing node type bug when trying to run a workflow. * Improve error detection for installing packages * 💄 Updating community nodes components styling and wording based on the product feedback * Implement telemetry be events * Add author name and email to packages * Fix telemetry be events for community packages * 📈 Updating front-end telemetry events with community nodes author data * 💄 Updating credentials documentation link logic to handle community nodes credentials * 🐛 Fixing draggable panels logic * Fix duplicate wrong import * 💄 Hiding community nodes credentials documentation links when they don't contain an absolute URL * Fix issue with detection of missing packages * 💄 Adding the `Docs` tab to community nodes * 💄 Adding a failed loading indicator to community nodes list * Prevent n8n from crashing on startup * Refactor and improve code quality * ⚡ Remove not needed depenedency Co-authored-by: Omar Ajoue <krynble@gmail.com> Co-authored-by: Milorad Filipović <milorad@n8n.io> Co-authored-by: Milorad FIlipović <miloradfilipovic19@gmail.com> Co-authored-by: agobrech <ael.gobrecht@gmail.com> Co-authored-by: Alex Grozav <alex@grozav.com>
2022-07-20 16:24:03 +02:00
parent a02b206170
commit c85faff4f1
80 changed files with 3951 additions and 166 deletions
--- a/packages/cli/test/integration/nodes.api.test.ts
+++ b/packages/cli/test/integration/nodes.api.test.ts
@@ -0,0 +1,341 @@
+import { exec } from 'child_process';
+import express from 'express';
+import * as utils from './shared/utils';
+import type { InstalledNodePayload, InstalledPackagePayload } from './shared/types';
+import type { Role } from '../../src/databases/entities/Role';
+import type { User } from '../../src/databases/entities/User';
+import * as testDb from './shared/testDb';
+
+jest.mock('../../src/CommunityNodes/helpers',  () => ({
+  matchPackagesWithUpdates: jest.requireActual('../../src/CommunityNodes/helpers').matchPackagesWithUpdates,
+	parsePackageName: jest.requireActual('../../src/CommunityNodes/helpers').parsePackageName,
+	hasPackageLoadedSuccessfully: jest.fn(),
+	searchInstalledPackage: jest.fn(),
+  executeCommand: jest.fn(),
+	checkPackageStatus: jest.fn(),
+	removePackageFromMissingList: jest.fn(),
+}));
+
+jest.mock('../../src/CommunityNodes/packageModel',  () => ({
+	getAllInstalledPackages: jest.requireActual('../../src/CommunityNodes/packageModel').getAllInstalledPackages,
+	removePackageFromDatabase: jest.fn(),
+	searchInstalledPackage: jest.fn(),
+}));
+
+import { executeCommand, checkPackageStatus, hasPackageLoadedSuccessfully, removePackageFromMissingList } from '../../src/CommunityNodes/helpers';
+import { getAllInstalledPackages, searchInstalledPackage, removePackageFromDatabase } from '../../src/CommunityNodes/packageModel';
+import { CURRENT_PACKAGE_VERSION, UPDATED_PACKAGE_VERSION } from './shared/constants';
+import { installedPackagePayload } from './shared/utils';
+
+jest.mock('../../src/telemetry');
+
+jest.mock('../../src/LoadNodesAndCredentials', () => ({
+	LoadNodesAndCredentials: jest.fn(),
+}));
+import { LoadNodesAndCredentials } from '../../src/LoadNodesAndCredentials';
+
+
+
+let app: express.Application;
+let testDbName = '';
+let globalOwnerRole: Role;
+let globalMemberRole: Role;
+let ownerShell: User;
+
+beforeAll(async () => {
+	app = await utils.initTestServer({ endpointGroups: ['nodes'], applyAuth: true });
+	const initResult = await testDb.init();
+	testDbName = initResult.testDbName;
+
+	utils.initConfigFile();
+
+	globalOwnerRole = await testDb.getGlobalOwnerRole();
+	globalMemberRole = await testDb.getGlobalMemberRole();
+	ownerShell = await testDb.createUserShell(globalOwnerRole);
+
+	utils.initTestLogger();
+	utils.initTestTelemetry();
+});
+
+beforeEach(async () => {
+	await testDb.truncate(['InstalledNodes', 'InstalledPackages'], testDbName);
+	// @ts-ignore
+	executeCommand.mockReset();
+	// @ts-ignore
+	checkPackageStatus.mockReset();
+	// @ts-ignore
+	searchInstalledPackage.mockReset();
+		// @ts-ignore
+	hasPackageLoadedSuccessfully.mockReset();
+});
+
+afterAll(async () => {
+	await testDb.terminate(testDbName);
+});
+
+test('GET /nodes should return empty list when no nodes are installed', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+
+	const response = await authOwnerAgent.get('/nodes').send();
+
+	expect(response.statusCode).toBe(200);
+	expect(response.body.data).toHaveLength(0);
+});
+
+test('GET /nodes should return list with installed package and node', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const installedPackage = await saveMockPackage(installedPackagePayload());
+	await saveMockNode(utils.installedNodePayload(installedPackage.packageName));
+
+	const response = await authOwnerAgent.get('/nodes').send();
+
+	expect(response.statusCode).toBe(200);
+	expect(response.body.data).toHaveLength(1);
+	expect(response.body.data[0].installedNodes).toHaveLength(1);
+});
+
+test('GET /nodes should return list with multiple installed package and node', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const installedPackage1 = await saveMockPackage(installedPackagePayload());
+	await saveMockNode(utils.installedNodePayload(installedPackage1.packageName));
+
+	const installedPackage2 = await saveMockPackage(installedPackagePayload());
+	await saveMockNode(utils.installedNodePayload(installedPackage2.packageName));
+	await saveMockNode(utils.installedNodePayload(installedPackage2.packageName));
+
+	const response = await authOwnerAgent.get('/nodes').send();
+
+	expect(response.statusCode).toBe(200);
+	expect(response.body.data).toHaveLength(2);
+	expect([...response.body.data[0].installedNodes, ...response.body.data[1].installedNodes]).toHaveLength(3);
+});
+
+test('GET /nodes should not check for updates when there are no packages installed', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+
+	await authOwnerAgent.get('/nodes').send();
+
+	expect(executeCommand).toHaveBeenCalledTimes(0);
+});
+
+test('GET /nodes should check for updates when there are packages installed', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const installedPackage = await saveMockPackage(installedPackagePayload());
+	await saveMockNode(utils.installedNodePayload(installedPackage.packageName));
+
+	await authOwnerAgent.get('/nodes').send();
+
+	expect(executeCommand).toHaveBeenCalledWith('npm outdated --json', {"doNotHandleError": true});
+});
+
+test('GET /nodes should mention updates when available', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const installedPackage = await saveMockPackage(installedPackagePayload());
+	await saveMockNode(utils.installedNodePayload(installedPackage.packageName));
+
+	// @ts-ignore
+	executeCommand.mockImplementation(() => {
+		throw getNpmOutdatedError(installedPackage.packageName);
+	});
+
+	const response = await authOwnerAgent.get('/nodes').send();
+	expect(response.body.data[0].installedVersion).toBe(CURRENT_PACKAGE_VERSION);
+	expect(response.body.data[0].updateAvailable).toBe(UPDATED_PACKAGE_VERSION);
+});
+
+// TEST POST ENDPOINT
+
+test('POST /nodes package name should not be empty', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const response = await authOwnerAgent.post('/nodes').send();
+
+	expect(response.statusCode).toBe(400);
+});
+
+test('POST /nodes Should not install duplicate packages', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const requestBody = {
+		name: installedPackagePayload().packageName,
+	};
+	// @ts-ignore
+	searchInstalledPackage.mockImplementation(() => {
+		return true;
+	});
+	// @ts-ignore
+	hasPackageLoadedSuccessfully.mockImplementation(() => {
+		return true;
+	});
+
+	const response = await authOwnerAgent.post('/nodes').send(requestBody);
+	expect(response.status).toBe(400);
+	expect(response.body.message).toContain('already installed');
+});
+
+test('POST /nodes Should allow installing packages that could not be loaded', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const requestBody = {
+		name: installedPackagePayload().packageName,
+	};
+	// @ts-ignore
+	searchInstalledPackage.mockImplementation(() => {
+		return true;
+	});
+	// @ts-ignore
+	hasPackageLoadedSuccessfully.mockImplementation(() => {
+		return false;
+	});
+
+	// @ts-ignore
+	checkPackageStatus.mockImplementation(() => {
+		return {status:'OK'};
+	});
+
+	// @ts-ignore
+	LoadNodesAndCredentials.mockImplementation(() => {
+		return {
+			loadNpmModule: () => {
+				return {
+					installedNodes: [],
+				};
+			},
+		};
+	});
+
+	const response = await authOwnerAgent.post('/nodes').send(requestBody);
+
+	expect(removePackageFromMissingList).toHaveBeenCalled();
+	expect(response.status).toBe(200);
+});
+
+test('POST /nodes package should not install banned package', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const installedPackage = installedPackagePayload();
+	const requestBody = {
+		name: installedPackage.packageName,
+	};
+
+	// @ts-ignore
+	checkPackageStatus.mockImplementation(() => {
+		return {status:'Banned'};
+	});
+	const response = await authOwnerAgent.post('/nodes').send(requestBody);
+	expect(response.statusCode).toBe(400);
+	expect(response.body.message).toContain('banned');
+});
+
+// TEST DELETE ENDPOINT
+test('DELETE /nodes package name should not be empty', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const response = await authOwnerAgent.delete('/nodes').send();
+
+	expect(response.statusCode).toBe(400);
+});
+
+test('DELETE /nodes Should return error when package was not installed', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const requestBody = {
+		name: installedPackagePayload().packageName,
+	};
+
+	const response = await authOwnerAgent.delete('/nodes').send(requestBody);
+	expect(response.status).toBe(400);
+	expect(response.body.message).toContain('not installed');
+});
+
+// Useful test ?
+test('DELETE /nodes package should be uninstall all conditions are true', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const requestBody = {
+		name: installedPackagePayload().packageName,
+	};
+	// @ts-ignore
+	searchInstalledPackage.mockImplementation(() => {
+		return {
+			installedNodes: [],
+		};
+	});
+
+	const removeNpmModuleMock = jest.fn();
+	// @ts-ignore
+	LoadNodesAndCredentials.mockImplementation(() => {
+		return {
+			removeNpmModule: removeNpmModuleMock,
+		};
+	});
+
+	const response = await authOwnerAgent.delete('/nodes').send(requestBody);
+	expect(response.statusCode).toBe(200);
+	expect(removeNpmModuleMock).toHaveBeenCalledTimes(1);
+});
+
+// TEST PATCH ENDPOINT
+
+test('PATCH /nodes package name should not be empty', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const response = await authOwnerAgent.patch('/nodes').send();
+
+	expect(response.statusCode).toBe(400);
+});
+
+test('PATCH /nodes Should return error when package was not installed', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const requestBody = {
+		name: installedPackagePayload().packageName,
+	};
+
+	const response = await authOwnerAgent.patch('/nodes').send(requestBody);
+	expect(response.status).toBe(400);
+	expect(response.body.message).toContain('not installed');
+});
+
+test('PATCH /nodes package should be updated if all conditions are true', async () => {
+	const authOwnerAgent = utils.createAgent(app, { auth: true, user: ownerShell });
+	const requestBody = {
+		name: installedPackagePayload().packageName,
+	};
+	// @ts-ignore
+	searchInstalledPackage.mockImplementation(() => {
+		return {
+			installedNodes: [],
+		};
+	});
+
+	const updatedNpmModuleMock = jest.fn(() => ({
+		installedNodes: [],
+	}));
+
+	// @ts-ignore
+	LoadNodesAndCredentials.mockImplementation(() => {
+		return {
+			updateNpmModule: updatedNpmModuleMock,
+		};
+	});
+
+	const response = await authOwnerAgent.patch('/nodes').send(requestBody);
+	expect(updatedNpmModuleMock).toHaveBeenCalledTimes(1);
+});
+
+async function saveMockPackage(payload: InstalledPackagePayload) {
+	return await testDb.saveInstalledPackage(payload);
+}
+
+async function saveMockNode(payload: InstalledNodePayload) {
+	return await testDb.saveInstalledNode(payload);
+}
+
+function getNpmOutdatedError(packageName: string) {
+	const errorOutput = new Error('Something went wrong');
+	// @ts-ignore
+	errorOutput.code = 1;
+	// @ts-ignore
+	errorOutput.stdout = '{' +
+		`"${packageName}": {` +
+			`"current": "${CURRENT_PACKAGE_VERSION}",` +
+			`"wanted": "${CURRENT_PACKAGE_VERSION}",` +
+			`"latest": "${UPDATED_PACKAGE_VERSION}",` +
+			`"location": "node_modules/${packageName}"` +
+		'}' +
+	'}';
+
+	return errorOutput;
+}
--- a/packages/cli/test/integration/shared/constants.ts
+++ b/packages/cli/test/integration/shared/constants.ts
@@ -71,6 +71,17 @@ export const BOOTSTRAP_POSTGRES_CONNECTION_NAME: Readonly<string> = 'n8n_bs_post
 */
 export const BOOTSTRAP_MYSQL_CONNECTION_NAME: Readonly<string> = 'n8n_bs_mysql';

+/**
+ * Timeout (in milliseconds) to account for fake SMTP service being slow to respond.
+ */
+export const SMTP_TEST_TIMEOUT = 30_000;
+
+/**
+ * Nodes
+ */
+export const CURRENT_PACKAGE_VERSION = '0.1.0';
+export const UPDATED_PACKAGE_VERSION = '0.2.0';
+
 /**
 * Timeout (in milliseconds) to account for DB being slow to initialize.
 */
--- a/packages/cli/test/integration/shared/testDb.ts
+++ b/packages/cli/test/integration/shared/testDb.ts
@@ -24,8 +24,10 @@ import { categorize, getPostgresSchemaSection } from './utils';
 import { createCredentiasFromCredentialsEntity } from '../../../src/CredentialsHelper';

 import type { Role } from '../../../src/databases/entities/Role';
+import type { CollectionName, CredentialPayload, InstalledNodePayload, InstalledPackagePayload, MappingName } from './types';
+import { InstalledPackages } from '../../../src/databases/entities/InstalledPackages';
+import { InstalledNodes } from '../../../src/databases/entities/InstalledNodes';
 import { User } from '../../../src/databases/entities/User';
-import type { CollectionName, CredentialPayload, MappingName } from './types';
 import { WorkflowEntity } from '../../../src/databases/entities/WorkflowEntity';
 import { ExecutionEntity } from '../../../src/databases/entities/ExecutionEntity';
 import { TagEntity } from '../../../src/databases/entities/TagEntity';
@@ -258,6 +260,8 @@ function toTableName(sourceName: CollectionName | MappingName) {
 		SharedCredentials: 'shared_credentials',
 		SharedWorkflow: 'shared_workflow',
 		Settings: 'settings',
+		InstalledPackages: 'installed_packages',
+		InstalledNodes: 'installed_nodes',
 	}[sourceName];
 }

@@ -338,6 +342,29 @@ export function createUserShell(globalRole: Role): Promise<User> {
 	return Db.collections.User.save(shell);
 }

+// --------------------------------------
+// Installed nodes and packages creation
+// --------------------------------------
+
+export async function saveInstalledPackage(installedPackagePayload: InstalledPackagePayload): Promise<InstalledPackages> {
+	const newInstalledPackage = new InstalledPackages();
+
+	Object.assign(newInstalledPackage, installedPackagePayload);
+
+
+	const savedInstalledPackage = await Db.collections.InstalledPackages.save(newInstalledPackage);
+	return savedInstalledPackage;
+}
+
+export async function saveInstalledNode(installedNodePayload: InstalledNodePayload): Promise<InstalledNodes> {
+	const newInstalledNode = new InstalledNodes();
+
+	Object.assign(newInstalledNode, installedNodePayload);
+
+	const savedInstalledNode = await Db.collections.InstalledNodes.save(newInstalledNode);
+	return savedInstalledNode;
+}
+
 export function addApiKey(user: User): Promise<User> {
 	user.apiKey = randomApiKey();
 	return Db.collections.User.save(user);
--- a/packages/cli/test/integration/shared/types.d.ts
+++ b/packages/cli/test/integration/shared/types.d.ts
@@ -17,7 +17,8 @@ type EndpointGroup =
 	| 'owner'
 	| 'passwordReset'
 	| 'credentials'
-	| 'publicApi';
+	| 'publicApi'
+	| 'nodes';

 export type CredentialPayload = {
 	name: string;
@@ -43,3 +44,16 @@ export interface TriggerTime {
 	weekeday: number;
 	[key: string]: string | number;
 }
+
+export type InstalledPackagePayload = {
+	packageName: string;
+	installedVersion: string;
+}
+
+export type InstalledNodePayload = {
+	name: string;
+	type: string;
+	latestVersion: string;
+	package: string;
+}
+
--- a/packages/cli/test/integration/shared/utils.ts
+++ b/packages/cli/test/integration/shared/utils.ts
@@ -23,8 +23,8 @@ import {
 } from 'n8n-workflow';

 import config from '../../../config';
-import { AUTHLESS_ENDPOINTS, PUBLIC_API_REST_PATH_SEGMENT, REST_PATH_SEGMENT } from './constants';
-import { AUTH_COOKIE_NAME } from '../../../src/constants';
+import { AUTHLESS_ENDPOINTS, CURRENT_PACKAGE_VERSION, PUBLIC_API_REST_PATH_SEGMENT, REST_PATH_SEGMENT } from './constants';
+import { AUTH_COOKIE_NAME, NODE_PACKAGE_PREFIX } from '../../../src/constants';
 import { addRoutes as authMiddleware } from '../../../src/UserManagement/routes';
 import {
 	ActiveWorkflowRunner,
@@ -44,8 +44,17 @@ import { getLogger } from '../../../src/Logger';
 import { credentialsController } from '../../../src/api/credentials.api';
 import { loadPublicApiVersions } from '../../../src/PublicApi/';
 import type { User } from '../../../src/databases/entities/User';
-import type { ApiPath, EndpointGroup, PostgresSchemaSection, TriggerTime } from './types';
+import type {
+	ApiPath,
+	EndpointGroup,
+	InstalledNodePayload,
+	InstalledPackagePayload,
+	PostgresSchemaSection,
+	TriggerTime,
+} from './types';
 import type { N8nApp } from '../../../src/UserManagement/Interfaces';
+import { nodesController } from '../../../src/api/nodes.api';
+import { randomName } from './random';

 /**
 * Initialize a test server.
@@ -89,6 +98,7 @@ export async function initTestServer({
 		const { apiRouters } = await loadPublicApiVersions(testServer.publicApiEndpoint);
 		const map: Record<string, express.Router | express.Router[]> = {
 			credentials: credentialsController,
+			nodes: nodesController,
 			publicApi: apiRouters,
 		};

@@ -136,9 +146,7 @@ const classifyEndpointGroups = (endpointGroups: string[]) => {
 	const functionEndpoints: string[] = [];

 	endpointGroups.forEach((group) =>
-		(group === 'credentials' || group === 'publicApi' ? routerEndpoints : functionEndpoints).push(
-			group,
-		),
+		(['credentials', 'nodes', 'publicApi'].includes(group) ? routerEndpoints : functionEndpoints).push(group),
 	);

 	return [routerEndpoints, functionEndpoints];
@@ -879,3 +887,24 @@ export function getPostgresSchemaSection(

 	return null;
 }
+
+// ----------------------------------
+//              nodes
+// ----------------------------------
+
+export function installedPackagePayload(): InstalledPackagePayload {
+	return {
+		packageName: NODE_PACKAGE_PREFIX + randomName(),
+		installedVersion: CURRENT_PACKAGE_VERSION,
+	};
+}
+
+export function installedNodePayload(packageName: string): InstalledNodePayload {
+	const nodeName = randomName();
+	return {
+		name: nodeName,
+		type: nodeName,
+		latestVersion: CURRENT_PACKAGE_VERSION,
+		package: packageName,
+	};
+}
--- a/packages/cli/test/unit/CommunityNodeHelpers.test.ts
+++ b/packages/cli/test/unit/CommunityNodeHelpers.test.ts
@@ -0,0 +1,331 @@
+import { checkPackageStatus, matchPackagesWithUpdates, executeCommand, parsePackageName, matchMissingPackages, hasPackageLoadedSuccessfully, removePackageFromMissingList } from '../../src/CommunityNodes/helpers';
+import { NODE_PACKAGE_PREFIX, NPM_COMMAND_TOKENS, NPM_PACKAGE_STATUS_GOOD, RESPONSE_ERROR_MESSAGES } from '../../src/constants';
+
+jest.mock('fs/promises');
+import { access as fsAccess, mkdir as fsMkdir } from 'fs/promises';
+
+jest.mock('child_process');
+import { exec } from 'child_process';
+import { InstalledPackages } from '../../src/databases/entities/InstalledPackages';
+import { installedNodePayload, installedPackagePayload } from '../integration/shared/utils';
+import { InstalledNodes } from '../../src/databases/entities/InstalledNodes';
+import { NpmUpdatesAvailable } from '../../src/Interfaces';
+import { randomName } from '../integration/shared/random';
+
+import config from '../../config';
+
+jest.mock('axios');
+import axios from 'axios';
+
+describe('CommunityNodesHelper', () => {
+
+	describe('parsePackageName', () => {
+		it('Should fail with empty package name', () => {
+			expect(() => parsePackageName('')).toThrowError()
+		});
+
+		it('Should fail with invalid package prefix name', () => {
+			expect(() => parsePackageName('INVALID_PREFIX@123')).toThrowError()
+		});
+
+		it('Should parse valid package name', () => {
+			const validPackageName = NODE_PACKAGE_PREFIX + 'cool-package-name';
+			const parsedPackageName = parsePackageName(validPackageName);
+
+			expect(parsedPackageName.originalString).toBe(validPackageName);
+			expect(parsedPackageName.packageName).toBe(validPackageName);
+			expect(parsedPackageName.scope).toBeUndefined();
+			expect(parsedPackageName.version).toBeUndefined();
+		});
+
+		it('Should parse valid package name and version', () => {
+			const validPackageName = NODE_PACKAGE_PREFIX + 'cool-package-name';
+			const validPackageVersion = '0.1.1';
+			const fullPackageName = `${validPackageName}@${validPackageVersion}`;
+			const parsedPackageName = parsePackageName(fullPackageName);
+
+			expect(parsedPackageName.originalString).toBe(fullPackageName);
+			expect(parsedPackageName.packageName).toBe(validPackageName);
+			expect(parsedPackageName.scope).toBeUndefined();
+			expect(parsedPackageName.version).toBe(validPackageVersion);
+		});
+
+		it('Should parse valid package name, scope and version', () => {
+			const validPackageScope = '@n8n';
+			const validPackageName = NODE_PACKAGE_PREFIX + 'cool-package-name';
+			const validPackageVersion = '0.1.1';
+			const fullPackageName = `${validPackageScope}/${validPackageName}@${validPackageVersion}`;
+			const parsedPackageName = parsePackageName(fullPackageName);
+
+			expect(parsedPackageName.originalString).toBe(fullPackageName);
+			expect(parsedPackageName.packageName).toBe(`${validPackageScope}/${validPackageName}`);
+			expect(parsedPackageName.scope).toBe(validPackageScope);
+			expect(parsedPackageName.version).toBe(validPackageVersion);
+		});
+	});
+
+	describe('executeCommand', () => {
+
+		beforeEach(() => {
+			// @ts-ignore
+			fsAccess.mockReset();
+			// @ts-ignore
+			fsMkdir.mockReset();
+			// @ts-ignore
+			exec.mockReset();
+		});
+
+		it('Should call command with valid options', async () => {
+			// @ts-ignore
+			exec.mockImplementation((...args) => {
+				expect(args[1].cwd).toBeDefined();
+				expect(args[1].env).toBeDefined();
+				// PATH or NODE_PATH may be undefined depending on environment so we don't check for these keys.
+				const callbackFunction = args[args.length - 1];
+				callbackFunction(null, { stdout: 'Done' });
+			});
+
+			await executeCommand('ls');
+			expect(fsAccess).toHaveBeenCalled();
+			expect(exec).toHaveBeenCalled();
+			expect(fsMkdir).toBeCalledTimes(0);
+		});
+
+		it ('Should make sure folder exists', async () => {
+			// @ts-ignore
+			exec.mockImplementation((...args) => {
+				const callbackFunction = args[args.length - 1];
+				callbackFunction(null, { stdout: 'Done' });
+			});
+
+			await executeCommand('ls');
+			expect(fsAccess).toHaveBeenCalled();
+			expect(exec).toHaveBeenCalled();
+			expect(fsMkdir).toBeCalledTimes(0);
+		});
+
+		it ('Should try to create folder if it does not exist', async () => {
+			// @ts-ignore
+			exec.mockImplementation((...args) => {
+				const callbackFunction = args[args.length - 1];
+				callbackFunction(null, { stdout: 'Done' });
+			});
+
+			// @ts-ignore
+			fsAccess.mockImplementation(() => {
+				throw new Error('Folder does not exist.');
+			});
+
+			await executeCommand('ls');
+			expect(fsAccess).toHaveBeenCalled();
+			expect(exec).toHaveBeenCalled();
+			expect(fsMkdir).toHaveBeenCalled();
+		});
+
+		it('Should throw especial error when package is not found', async() => {
+			// @ts-ignore
+			exec.mockImplementation((...args) => {
+				const callbackFunction = args[args.length - 1];
+				callbackFunction(new Error('Something went wrong - ' + NPM_COMMAND_TOKENS.NPM_PACKAGE_NOT_FOUND_ERROR + '. Aborting.'));
+			});
+
+			await expect(async () => await executeCommand('ls')).rejects.toThrow(RESPONSE_ERROR_MESSAGES.PACKAGE_NOT_FOUND);
+
+			expect(fsAccess).toHaveBeenCalled();
+			expect(exec).toHaveBeenCalled();
+			expect(fsMkdir).toHaveBeenCalledTimes(0);
+		});
+	});
+
+
+	describe('crossInformationPackage', () => {
+
+		it('Should return same list if availableUpdates is undefined', () => {
+			const fakePackages = generateListOfFakeInstalledPackages();
+			const crossedData = matchPackagesWithUpdates(fakePackages);
+			expect(crossedData).toEqual(fakePackages);
+		});
+
+		it ('Should correctly match update versions for packages', () => {
+			const fakePackages = generateListOfFakeInstalledPackages();
+
+			const updates: NpmUpdatesAvailable = {
+				[fakePackages[0].packageName]: {
+					current: fakePackages[0].installedVersion,
+					wanted: fakePackages[0].installedVersion,
+					latest: '0.2.0',
+					location: fakePackages[0].packageName,
+				},
+				[fakePackages[1].packageName]: {
+					current: fakePackages[0].installedVersion,
+					wanted: fakePackages[0].installedVersion,
+					latest: '0.3.0',
+					location: fakePackages[0].packageName,
+				}
+			};
+
+			const crossedData = matchPackagesWithUpdates(fakePackages, updates);
+
+			// @ts-ignore
+			expect(crossedData[0].updateAvailable).toBe('0.2.0');
+			// @ts-ignore
+			expect(crossedData[1].updateAvailable).toBe('0.3.0');
+
+		});
+
+		it ('Should correctly match update versions for single package', () => {
+			const fakePackages = generateListOfFakeInstalledPackages();
+
+			const updates: NpmUpdatesAvailable = {
+				[fakePackages[1].packageName]: {
+					current: fakePackages[0].installedVersion,
+					wanted: fakePackages[0].installedVersion,
+					latest: '0.3.0',
+					location: fakePackages[0].packageName,
+				}
+			};
+
+			const crossedData = matchPackagesWithUpdates(fakePackages, updates);
+
+			// @ts-ignore
+			expect(crossedData[0].updateAvailable).toBeUndefined();
+			// @ts-ignore
+			expect(crossedData[1].updateAvailable).toBe('0.3.0');
+
+		});
+
+	});
+
+	describe('matchMissingPackages', () => {
+		it('Should not match failed packages that do not exist', () => {
+			const fakePackages = generateListOfFakeInstalledPackages();
+			const notFoundPackageList = `${NODE_PACKAGE_PREFIX}very-long-name-that-should-never-be-generated@1.0.0 ${NODE_PACKAGE_PREFIX}another-very-long-name-that-never-is-seen`;
+			const matchedPackages = matchMissingPackages(fakePackages, notFoundPackageList);
+
+			expect(matchedPackages).toEqual(fakePackages);
+			expect(matchedPackages[0].failedLoading).toBeUndefined();
+			expect(matchedPackages[1].failedLoading).toBeUndefined();
+		});
+
+		it('Should match failed packages that should be present', () => {
+			const fakePackages = generateListOfFakeInstalledPackages();
+			const notFoundPackageList = `${NODE_PACKAGE_PREFIX}very-long-name-that-should-never-be-generated@1.0.0 ${fakePackages[0].packageName}@${fakePackages[0].installedVersion}`;
+			const matchedPackages = matchMissingPackages(fakePackages, notFoundPackageList);
+
+			expect(matchedPackages[0].failedLoading).toBe(true);
+			expect(matchedPackages[1].failedLoading).toBeUndefined();
+		});
+
+		it('Should match failed packages even if version is wrong', () => {
+			const fakePackages = generateListOfFakeInstalledPackages();
+			const notFoundPackageList = `${NODE_PACKAGE_PREFIX}very-long-name-that-should-never-be-generated@1.0.0 ${fakePackages[0].packageName}@123.456.789`;
+			const matchedPackages = matchMissingPackages(fakePackages, notFoundPackageList);
+
+			expect(matchedPackages[0].failedLoading).toBe(true);
+			expect(matchedPackages[1].failedLoading).toBeUndefined();
+		});
+	});
+
+	describe('checkPackageStatus', () => {
+		it('Should call axios.post', async () => {
+			const packageName = NODE_PACKAGE_PREFIX + randomName();
+			await checkPackageStatus(packageName);
+			expect(axios.post).toHaveBeenCalled();
+		});
+
+		it('Should not fail if request fails', async () => {
+			const packageName = NODE_PACKAGE_PREFIX + randomName();
+			axios.post = jest.fn(() => {
+				throw new Error('Something went wrong');
+			});
+			const result = await checkPackageStatus(packageName);
+			expect(result.status).toBe(NPM_PACKAGE_STATUS_GOOD);
+		});
+
+		it('Should warn if package is banned', async () => {
+			const packageName = NODE_PACKAGE_PREFIX + randomName();
+			// @ts-ignore
+			axios.post = jest.fn(() => {
+				return { data: { status: 'Banned', reason: 'Not good' } };
+			});
+			const result = await checkPackageStatus(packageName);
+			expect(result.status).toBe('Banned');
+			expect(result.reason).toBe('Not good');
+		});
+	});
+
+	describe('hasPackageLoadedSuccessfully', () => {
+		it('Should return true when failed package list does not exist', () => {
+			config.set('nodes.packagesMissing', undefined);
+			const result = hasPackageLoadedSuccessfully('package');
+			expect(result).toBe(true);
+		});
+
+		it('Should return true when package is not in the list of missing packages', () => {
+			config.set('nodes.packagesMissing', 'packageA@0.1.0 packgeB@0.1.0');
+			const result = hasPackageLoadedSuccessfully('packageC');
+			expect(result).toBe(true);
+		});
+
+		it('Should return false when package is in the list of missing packages', () => {
+			config.set('nodes.packagesMissing', 'packageA@0.1.0 packgeB@0.1.0');
+			const result = hasPackageLoadedSuccessfully('packageA');
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('removePackageFromMissingList', () => {
+		it('Should do nothing if key does not exist', () => {
+			config.set('nodes.packagesMissing', undefined);
+
+			removePackageFromMissingList('packageA');
+
+			const packageList = config.get('nodes.packagesMissing');
+			expect(packageList).toBeUndefined();
+		});
+
+		it('Should remove only correct package from list', () => {
+			config.set('nodes.packagesMissing', 'packageA@0.1.0 packageB@0.2.0 packageBB@0.2.0');
+
+			removePackageFromMissingList('packageB');
+
+			const packageList = config.get('nodes.packagesMissing');
+			expect(packageList).toBe('packageA@0.1.0 packageBB@0.2.0');
+		});
+
+
+		it('Should not remove if package is not in the list', () => {
+			const failedToLoadList = 'packageA@0.1.0 packageB@0.2.0 packageBB@0.2.0';
+			config.set('nodes.packagesMissing', failedToLoadList);
+
+			removePackageFromMissingList('packageC');
+
+			const packageList = config.get('nodes.packagesMissing');
+			expect(packageList).toBe(failedToLoadList);
+		});
+
+	});
+});
+
+/**
+ * Generates a list with 2 packages, one with a single node and
+ * another with 2 nodes
+ * @returns
+ */
+function generateListOfFakeInstalledPackages(): InstalledPackages[] {
+	const fakeInstalledPackage1 = new InstalledPackages();
+	Object.assign(fakeInstalledPackage1, installedPackagePayload());
+	const fakeInstalledNode1 = new InstalledNodes();
+	Object.assign(fakeInstalledNode1, installedNodePayload(fakeInstalledPackage1.packageName));
+	fakeInstalledPackage1.installedNodes = [fakeInstalledNode1];
+
+	const fakeInstalledPackage2 = new InstalledPackages();
+	Object.assign(fakeInstalledPackage2, installedPackagePayload());
+	const fakeInstalledNode2 = new InstalledNodes();
+	Object.assign(fakeInstalledNode2, installedNodePayload(fakeInstalledPackage2.packageName));
+	const fakeInstalledNode3 = new InstalledNodes();
+	Object.assign(fakeInstalledNode3, installedNodePayload(fakeInstalledPackage2.packageName));
+	fakeInstalledPackage2.installedNodes = [fakeInstalledNode2, fakeInstalledNode3];
+
+	return [fakeInstalledPackage1, fakeInstalledPackage2];
+}