feat: Add n8n Public API (#3064)

* ✨ Inicial setup * ⚡ Add authentication handler * ⚡ Add GET /users route * ⚡ Improvements * 👕 Fix linting issues * ⚡ Add GET /users/:identifier endpoint * ⚡ Add POST /users endpoint * ⚡ Add DELETE /users/:identifier endpoint * ⚡ Return error using express native functions * 👕 Fix linting issue * ⚡ Possibility to add custom middleware * ⚡ Refactor POST /users * ⚡ Refactor DELETE /users * ⚡ Improve cleaning function * ⚡ Refactor GET /users and /users/:identifier * ⚡ Add API spec to route * ⚡ Add raw option to response helper * 🐛 Fix issue adding custom middleware * ⚡ Enable includeRole parameter in GET /users/:identifier * ⚡ Fix linting issues after merge * ⚡ Add missing config variable * ⚡ General improvements ⚡ asasas * ⚡ Add POST /users tests * Debug public API tests * Fix both sets of tests * ⚡ Improvements * ⚡ Load api versions dynamically * ⚡ Add endpoints to UM to create/delete an API Key * ⚡ Add index to apiKey column * 👕 Fix linting issue * ⚡ Clean open api spec * ⚡ Improvements * ⚡ Skip tests * 🐛 Fix bug with test * ⚡ Fix issue with the open api spec * ⚡ Fix merge issue * ⚡ Move token enpoints from /users to /me * ⚡ Apply feedback to openapi.yml * ⚡ Improvements to api-key endpoints * 🐛 Fix test to suport API dynamic loading * ⚡ Expose swagger ui in GET /{version}/docs * ⚡ Allow to disable public api via env variable * ⚡ Change handlers structure * 🚧 WIP create credential, delete credential complete * 🐛 fix route for creating api key * ⚡ return api key of authenticated user * ⚡ Expose public api activation to the settings * ⬆️ Update package-lock.json file * ⚡ Add execution resource * ⚡ Fix linting issues * 🛠 conditional public api endpoints excluding * ⚡️ create credential complete * ✨ Added n8n-card component. Added spacing utility classes. * ♻️ Made use of n8n-card in existing components. * ✨ Added api key setup view. * ✨ Added api keys get/create/delete actions. * ✨ Added public api permissions handling. * ♻️ Temporarily disabling card tests. * ♻️ Changed translations. Storing api key only in component. * ✨ Added utilities storybook entry * ♻️ Changed default value for generic copy input. * 🧹 clean up createCredential * ⚡ Add workflow resource to openapi spec * 🐛 Fix naming with env variable * ⚡ Allow multifile openapi spec * ⚡ Add POST /workflows/:workflowId/activate * fix up view, fix issues * remove delete api key modal * remove unused prop * clean up store api * remove getter * remove unused dispatch * fix component size to match * use existing components * match figma closely * fix bug when um is disabled in sidebar * set copy input color * remove unused import * ⚡ Remove css path * ⚡ Add POST /workflows/:workflowId/desactivate * ⚡ Add POST /workflows * Revert "⚡ Remove css path" a3d0a71719834ef37c88c23c83dfe662e96185aa * attempt to fix docker image issue * revert dockerfile test * disable public api * disable api differently * Revert "disable api differently" b70e29433e45934975e41ffdc32e288988aba9b0 * Revert "disable public api" 886e5164fb4135c164f77561bdb4427e5cd44ac1 * remove unused box * ⚡ PUT /workflows/:workflowId * ⚡ Refactor workflow endpoints * ⚡ Refactor executions endpoints * ⚡ Fix typo * ✅ add credentials tests * ✅ adjust users tests * update text * add try it out link * ⚡ Add delete, getAll and get to the workflow resource * address spacing comments * ⚡️ apply correct structure * ⚡ Add missing test to user resource and fix some issues * ⚡ Add workflow tests * ⚡ Add missing workflow tests and fix some issues * ⚡ Executions tests * ⚡ finish execution tests * ⚡ Validate credentials data depending on type * ⚡️ implement review comments * 👕 fix lint issues * ⚡ Add apiKey to sanatizeUser * ⚡ Fix issues with spec and tests * ⚡ Add new structure * ⚡ Validate credentials type and properties * ⚡ Make all endpoints except /users independent on UM * ⚡ Add instance base path to swagger UI * ⚡ Remove testing endpoints * ⚡ Fix issue with openapi tags * ⚡ Add endpoint GET /credentialTypes/:id/schema * 🐛 Fix issue adding json middleware to public api * ⚡ Add API playground path to FE * ⚡ Add telemetry and external hooks * 🐛 Fix issue with user tests * ⚡ Move /credentialTypes under /credentials * ⚡ Add test to GET /credentials/schema/:id * 🛠 refactor schema naming * ⚡ Add DB migrations asas * ✅ add tests for crd apiKey * ✨ Added API View telemetry events. * ⚡ Remove rsync from the building process as it is missing on alpine base image * ⚡ add missing BE telemetry events * 🐛 Fix credential tests * ⚡ address outstanding feedback * 🔨 Remove move:openapi script * ⬆️ update dependency * ⬆️ update package-lock.json * 👕 Fix linting issue * 🐛 Fix package.json issue * 🐛 fix migrations and tests * 🐛 fix typos + naming * 🚧 WIP fixing tests * ⚡ Add json schema validation * ⚡ Add missing fields to node schema * ⚡ Add limit max upper limit * ⚡ Rename id paths * 🐛 Fix tests * Add package-lock.jsonto custom dockerfile * ⬆️ Update package-lock.json * 🐛 Fix issue with build * ✏️ add beta label to api view * 🔥 Remove user endpoints * ⚡ Add schema examples to GET /credentials/schema/:id * 🔥 Remove user endpoints tests * 🐛 Fix tests * 🎨 adapt points from design review * 🔥 remove unnecessary text-align * ⚡️ update UI * 🐛 Fix issue with executions filter * ⚡ Add tags filter to GET /workflows * ⚡ Add missing error messages * ✅ add and update public api tests * ✅ add tests for owner activiating/deactivating non-owned wfs * 🧪 add tests for filter for tags * 🧪 add tests for more filter params * 🐛 fix inclusion of tags * 🛠 enhance readability * ⚡️ small refactorings * 💄 improving readability/naming * ⚡ Set API latest version dinamically * Add comments to toJsonSchema function * ⚡ Fix issue * ⚡ Make execution data usable * ⚡ Fix validation issue * ⚡ Rename data field and change parameter and options * 🐛 Fix issue parameter "detailsFieldFormat" not resolving correctly * Skip executions tests * skip workflow failing test * Rename details property to data * ⚡ Add includeData parameter * 🐛 Fix issue with openapi spec * 🐛 Fix linting issue * ⚡ Fix execution schema Co-authored-by: Iván Ovejero <ivov.src@gmail.com> Co-authored-by: Ben Hesseldieck <b.hesseldieck@gmail.com> Co-authored-by: Alex Grozav <alex@grozav.com> Co-authored-by: Mutasem <mutdmour@gmail.com> Co-authored-by: Jan Oberhauser <jan.oberhauser@gmail.com>
2025-12-18 02:21:13 +00:00 · 2022-06-08 14:53:12 -04:00
parent 1999f4b066
commit a18081d749
112 changed files with 7182 additions and 139 deletions
--- a/packages/cli/test/integration/shared/constants.ts
+++ b/packages/cli/test/integration/shared/constants.ts
@@ -2,6 +2,8 @@ import config from '../../../config';

 export const REST_PATH_SEGMENT = config.getEnv('endpoints.rest') as Readonly<string>;

+export const PUBLIC_API_REST_PATH_SEGMENT = config.getEnv('publicApi.path') as Readonly<string>;
+
 export const AUTHLESS_ENDPOINTS: Readonly<string[]> = [
 	'healthz',
 	'metrics',
--- a/packages/cli/test/integration/shared/random.ts
+++ b/packages/cli/test/integration/shared/random.ts
@@ -10,6 +10,10 @@ export function randomString(min: number, max: number) {
 	return randomBytes(randomInteger / 2).toString('hex');
 }

+export function randomApiKey() {
+	return `n8n_api_${randomBytes(20).toString('hex')}`;
+}
+
 const chooseRandomly = <T>(array: T[]) => array[Math.floor(Math.random() * array.length)];

 const randomDigit = () => Math.floor(Math.random() * 10);
@@ -17,7 +21,9 @@ const randomDigit = () => Math.floor(Math.random() * 10);
 const randomUppercaseLetter = () => chooseRandomly('ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''));

 export const randomValidPassword = () =>
-	randomString(MIN_PASSWORD_LENGTH, MAX_PASSWORD_LENGTH - 2) + randomUppercaseLetter() + randomDigit();
+	randomString(MIN_PASSWORD_LENGTH, MAX_PASSWORD_LENGTH - 2) +
+	randomUppercaseLetter() +
+	randomDigit();

 export const randomInvalidPassword = () =>
 	chooseRandomly([
--- a/packages/cli/test/integration/shared/testDb.ts
+++ b/packages/cli/test/integration/shared/testDb.ts
@@ -6,11 +6,10 @@ import { Credentials, UserSettings } from 'n8n-core';

 import config from '../../../config';
 import { BOOTSTRAP_MYSQL_CONNECTION_NAME, BOOTSTRAP_POSTGRES_CONNECTION_NAME } from './constants';
-import { DatabaseType, Db, ICredentialsDb, IDatabaseCollections } from '../../../src';
-import { randomEmail, randomName, randomString, randomValidPassword } from './random';
+import { Db, ICredentialsDb, IDatabaseCollections } from '../../../src';
+import { randomApiKey, randomEmail, randomName, randomString, randomValidPassword } from './random';
 import { CredentialsEntity } from '../../../src/databases/entities/CredentialsEntity';
 import { hashPassword } from '../../../src/UserManagement/UserManagementHelper';
-import { RESPONSE_ERROR_MESSAGES } from '../../../src/constants';
 import { entities } from '../../../src/databases/entities';
 import { mysqlMigrations } from '../../../src/databases/mysqldb/migrations';
 import { postgresMigrations } from '../../../src/databases/postgresdb/migrations';
@@ -19,8 +18,11 @@ import { categorize, getPostgresSchemaSection } from './utils';
 import { createCredentiasFromCredentialsEntity } from '../../../src/CredentialsHelper';

 import type { Role } from '../../../src/databases/entities/Role';
-import type { User } from '../../../src/databases/entities/User';
+import { User } from '../../../src/databases/entities/User';
 import type { CollectionName, CredentialPayload } from './types';
+import { WorkflowEntity } from '../../../src/databases/entities/WorkflowEntity';
+import { ExecutionEntity } from '../../../src/databases/entities/ExecutionEntity';
+import { TagEntity } from '../../../src/databases/entities/TagEntity';

 const exec = promisify(callbackExec);

@@ -56,7 +58,7 @@ export async function init() {
 				`host: ${pgOptions.host} | port: ${pgOptions.port} | schema: ${pgOptions.schema} | username: ${pgOptions.username} | password: ${pgOptions.password}`,
 				'Fix by setting correct values via environment variables:',
 				`${pgConfig.host.env} | ${pgConfig.port.env} | ${pgConfig.schema.env} | ${pgConfig.user.env} | ${pgConfig.password.env}`,
-				'Otherwise, make sure your Postgres server is running.'
+				'Otherwise, make sure your Postgres server is running.',
 			].join('\n');

 			console.error(message);
@@ -72,7 +74,9 @@ export async function init() {
 			await exec(`psql -d ${testDbName} -c "CREATE SCHEMA IF NOT EXISTS ${schema}";`);
 		} catch (error) {
 			if (error instanceof Error && error.message.includes('command not found')) {
-				console.error('psql command not found. Make sure psql is installed and added to your PATH.');
+				console.error(
+					'psql command not found. Make sure psql is installed and added to your PATH.',
+				);
 			}
 			process.exit(1);
 		}
@@ -228,15 +232,17 @@ export async function saveCredential(
 //           user creation
 // ----------------------------------

-export async function createUser(attributes: Partial<User> & { globalRole: Role }): Promise<User> {
+/**
+ * Store a user in the DB, defaulting to a `member`.
+ */
+export async function createUser(attributes: Partial<User> = {}): Promise<User> {
 	const { email, password, firstName, lastName, globalRole, ...rest } = attributes;
-
 	const user = {
 		email: email ?? randomEmail(),
 		password: await hashPassword(password ?? randomValidPassword()),
 		firstName: firstName ?? randomName(),
 		lastName: lastName ?? randomName(),
-		globalRole,
+		globalRole: globalRole ?? (await getGlobalMemberRole()),
 		...rest,
 	};

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

+export function addApiKey(user: User): Promise<User> {
+	user.apiKey = randomApiKey();
+	return Db.collections.User.save(user);
+}
+
 // ----------------------------------
 //          role fetchers
 // ----------------------------------
@@ -298,6 +309,187 @@ export function getAllRoles() {
 	]);
 }

+// ----------------------------------
+//          Execution helpers
+// ----------------------------------
+
+export async function createManyExecutions(
+	amount: number,
+	workflow: WorkflowEntity,
+	callback: (workflow: WorkflowEntity) => Promise<ExecutionEntity>,
+) {
+	const executionsRequests = [...Array(amount)].map((_) => callback(workflow));
+	return Promise.all(executionsRequests);
+}
+
+/**
+ * Store a execution in the DB and assigns it to a workflow.
+ * @param user user to assign the workflow to
+ */
+export async function createExecution(
+	attributes: Partial<ExecutionEntity> = {},
+	workflow: WorkflowEntity,
+) {
+	const { data, finished, mode, startedAt, stoppedAt, waitTill } = attributes;
+
+	const execution = await Db.collections.Execution.save({
+		data: data ?? '[]',
+		finished: finished ?? true,
+		mode: mode ?? 'manual',
+		startedAt: startedAt ?? new Date(),
+		...(workflow !== undefined && { workflowData: workflow, workflowId: workflow.id.toString() }),
+		stoppedAt: stoppedAt ?? new Date(),
+		waitTill: waitTill ?? null,
+	});
+
+	return execution;
+}
+
+/**
+ * Store a execution in the DB and assigns it to a workflow.
+ * @param user user to assign the workflow to
+ */
+export async function createSuccessfullExecution(workflow: WorkflowEntity) {
+	const execution = await createExecution(
+		{
+			finished: true,
+		},
+		workflow,
+	);
+
+	return execution;
+}
+
+/**
+ * Store a execution in the DB and assigns it to a workflow.
+ * @param user user to assign the workflow to
+ */
+export async function createErrorExecution(workflow: WorkflowEntity) {
+	const execution = await createExecution(
+		{
+			finished: false,
+			stoppedAt: new Date(),
+		},
+		workflow,
+	);
+	return execution;
+}
+
+/**
+ * Store a execution in the DB and assigns it to a workflow.
+ * @param user user to assign the workflow to
+ */
+export async function createWaitingExecution(workflow: WorkflowEntity) {
+	const execution = await createExecution(
+		{
+			finished: false,
+			waitTill: new Date(),
+		},
+		workflow,
+	);
+	return execution;
+}
+
+// ----------------------------------
+//          Tags
+// ----------------------------------
+
+export async function createTag(attributes: Partial<TagEntity> = {}) {
+	const { name } = attributes;
+
+	return await Db.collections.Tag.save({
+		name: name ?? randomName(),
+		...attributes,
+	});
+}
+
+// ----------------------------------
+//          Workflow helpers
+// ----------------------------------
+
+export async function createManyWorkflows(
+	amount: number,
+	attributes: Partial<WorkflowEntity> = {},
+	user?: User,
+) {
+	const workflowRequests = [...Array(amount)].map((_) => createWorkflow(attributes, user));
+	return Promise.all(workflowRequests);
+}
+
+/**
+ * Store a workflow in the DB (without a trigger) and optionally assigns it to a user.
+ * @param user user to assign the workflow to
+ */
+export async function createWorkflow(attributes: Partial<WorkflowEntity> = {}, user?: User) {
+	const { active, name, nodes, connections } = attributes;
+
+	const workflow = await Db.collections.Workflow.save({
+		active: active ?? false,
+		name: name ?? 'test workflow',
+		nodes: nodes ?? [
+			{
+				name: 'Start',
+				parameters: {},
+				position: [-20, 260],
+				type: 'n8n-nodes-base.start',
+				typeVersion: 1,
+			},
+		],
+		connections: connections ?? {},
+		...attributes,
+	});
+
+	if (user) {
+		await Db.collections.SharedWorkflow.save({
+			user,
+			workflow,
+			role: await getWorkflowOwnerRole(),
+		});
+	}
+	return workflow;
+}
+
+/**
+ * Store a workflow in the DB (with a trigger) and optionally assigns it to a user.
+ * @param user user to assign the workflow to
+ */
+export async function createWorkflowWithTrigger(
+	attributes: Partial<WorkflowEntity> = {},
+	user?: User,
+) {
+	const workflow = await createWorkflow(
+		{
+			nodes: [
+				{
+					parameters: {},
+					name: 'Start',
+					type: 'n8n-nodes-base.start',
+					typeVersion: 1,
+					position: [240, 300],
+				},
+				{
+					parameters: { triggerTimes: { item: [{ mode: 'everyMinute' }] } },
+					name: 'Cron',
+					type: 'n8n-nodes-base.cron',
+					typeVersion: 1,
+					position: [500, 300],
+				},
+				{
+					parameters: { options: {} },
+					name: 'Set',
+					type: 'n8n-nodes-base.set',
+					typeVersion: 1,
+					position: [780, 300],
+				},
+			],
+			connections: { Cron: { main: [[{ node: 'Set', type: 'main', index: 0 }]] } },
+			...attributes,
+		},
+		user,
+	);
+	return workflow;
+}
+
 // ----------------------------------
 //        connection options
 // ----------------------------------
--- a/packages/cli/test/integration/shared/types.d.ts
+++ b/packages/cli/test/integration/shared/types.d.ts
@@ -15,12 +15,14 @@ export type SmtpTestAccount = {
 	};
 };

-type EndpointGroup = 'me' | 'users' | 'auth' | 'owner' | 'passwordReset' | 'credentials';
+export type ApiPath = 'internal' | 'public';
+
+type EndpointGroup = 'me' | 'users' | 'auth' | 'owner' | 'passwordReset' | 'credentials' | 'publicApi';

 export type CredentialPayload = {
 	name: string;
 	type: string;
-	nodesAccess: ICredentialNodeAccess[];
+	nodesAccess?: ICredentialNodeAccess[];
 	data: ICredentialDataDecryptedObject;
 };

--- a/packages/cli/test/integration/shared/utils.ts
+++ b/packages/cli/test/integration/shared/utils.ts
@@ -7,14 +7,33 @@ import { URL } from 'url';
 import bodyParser from 'body-parser';
 import util from 'util';
 import { createTestAccount } from 'nodemailer';
-import { INodeTypes, LoggerProxy } from 'n8n-workflow';
-import { UserSettings } from 'n8n-core';
+import {
+	ICredentialType,
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeParameters,
+	INodeTypeData,
+	INodeTypes,
+	ITriggerFunctions,
+	ITriggerResponse,
+	LoggerProxy,
+} from 'n8n-workflow';
+import { BinaryDataManager, UserSettings } from 'n8n-core';
+import { CronJob } from 'cron';

-import config from '../../../config';
-import { AUTHLESS_ENDPOINTS, REST_PATH_SEGMENT } from './constants';
+import config = require('../../../config');
+import { AUTHLESS_ENDPOINTS, PUBLIC_API_REST_PATH_SEGMENT, REST_PATH_SEGMENT } from './constants';
 import { AUTH_COOKIE_NAME } from '../../../src/constants';
 import { addRoutes as authMiddleware } from '../../../src/UserManagement/routes';
-import { Db, ExternalHooks, InternalHooksManager } from '../../../src';
+import {
+	ActiveWorkflowRunner,
+	CredentialTypes,
+	Db,
+	ExternalHooks,
+	InternalHooksManager,
+	NodeTypes,
+} from '../../../src';
 import { meNamespace as meEndpoints } from '../../../src/UserManagement/routes/me';
 import { usersNamespace as usersEndpoints } from '../../../src/UserManagement/routes/users';
 import { authenticationMethods as authEndpoints } from '../../../src/UserManagement/routes/auth';
@@ -23,9 +42,20 @@ import { passwordResetNamespace as passwordResetEndpoints } from '../../../src/U
 import { issueJWT } from '../../../src/UserManagement/auth/jwt';
 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 { EndpointGroup, PostgresSchemaSection, SmtpTestAccount } from './types';
+import type { ApiPath, EndpointGroup, PostgresSchemaSection, SmtpTestAccount } from './types';
+import { Telemetry } from '../../../src/telemetry';
 import type { N8nApp } from '../../../src/UserManagement/Interfaces';
+import { set } from 'lodash';
+interface TriggerTime {
+	mode: string;
+	hour: number;
+	minute: number;
+	dayOfMonth: number;
+	weekeday: number;
+	[key: string]: string | number;
+}
 import * as UserManagementMailer from '../../../src/UserManagement/email/UserManagementMailer';

 /**
@@ -34,7 +64,7 @@ import * as UserManagementMailer from '../../../src/UserManagement/email/UserMan
 * @param applyAuth Whether to apply auth middleware to test server.
 * @param endpointGroups Groups of endpoints to apply to test server.
 */
-export function initTestServer({
+export async function initTestServer({
 	applyAuth,
 	endpointGroups,
 }: {
@@ -44,6 +74,7 @@ export function initTestServer({
 	const testServer = {
 		app: express(),
 		restEndpoint: REST_PATH_SEGMENT,
+		publicApiEndpoint: PUBLIC_API_REST_PATH_SEGMENT,
 		...(endpointGroups?.includes('credentials') ? { externalHooks: ExternalHooks() } : {}),
 	};

@@ -62,12 +93,18 @@ export function initTestServer({
 	const [routerEndpoints, functionEndpoints] = classifyEndpointGroups(endpointGroups);

 	if (routerEndpoints.length) {
-		const map: Record<string, express.Router> = {
+		const { apiRouters } = await loadPublicApiVersions(testServer.publicApiEndpoint);
+		const map: Record<string, express.Router | express.Router[]> = {
 			credentials: credentialsController,
+			publicApi: apiRouters
 		};

 		for (const group of routerEndpoints) {
-			testServer.app.use(`/${testServer.restEndpoint}/${group}`, map[group]);
+			if (group === 'publicApi') {
+				testServer.app.use(...(map[group] as express.Router[]));
+			} else {
+				testServer.app.use(`/${testServer.restEndpoint}/${group}`, map[group]);
+			}
 		}
 	}

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

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

 	return [routerEndpoints, functionEndpoints];
@@ -116,6 +155,598 @@ const classifyEndpointGroups = (endpointGroups: string[]) => {
 //          initializers
 // ----------------------------------

+/**
+ * Initialize node types.
+ */
+export async function initActiveWorkflowRunner(): Promise<ActiveWorkflowRunner.ActiveWorkflowRunner> {
+	const workflowRunner = ActiveWorkflowRunner.getInstance();
+	workflowRunner.init();
+	return workflowRunner;
+}
+
+export function gitHubCredentialType(): ICredentialType {
+	return {
+		name: 'githubApi',
+		displayName: 'Github API',
+		documentationUrl: 'github',
+		properties: [
+			{
+				displayName: 'Github Server',
+				name: 'server',
+				type: 'string',
+				default: 'https://api.github.com',
+				description: 'The server to connect to. Only has to be set if Github Enterprise is used.',
+			},
+			{
+				displayName: 'User',
+				name: 'user',
+				type: 'string',
+				default: '',
+			},
+			{
+				displayName: 'Access Token',
+				name: 'accessToken',
+				type: 'string',
+				default: '',
+			},
+		],
+	};
+}
+
+/**
+ * Initialize node types.
+ */
+export async function initCredentialsTypes(): Promise<void> {
+	const credentialTypes = CredentialTypes();
+	await credentialTypes.init({
+		githubApi: {
+			type: gitHubCredentialType(),
+			sourcePath: '',
+		},
+	});
+}
+
+/**
+ * Initialize node types.
+ */
+export async function initNodeTypes() {
+	const types: INodeTypeData = {
+		'n8n-nodes-base.start': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'Start',
+					name: 'start',
+					group: ['input'],
+					version: 1,
+					description: 'Starts the workflow execution from this node',
+					defaults: {
+						name: 'Start',
+						color: '#553399',
+					},
+					inputs: [],
+					outputs: ['main'],
+					properties: [],
+				},
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const items = this.getInputData();
+
+					return this.prepareOutputData(items);
+				},
+			},
+		},
+		'n8n-nodes-base.cron': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'Cron',
+					name: 'cron',
+					icon: 'fa:calendar',
+					group: ['trigger', 'schedule'],
+					version: 1,
+					description: 'Triggers the workflow at a specific time',
+					eventTriggerDescription: '',
+					activationMessage:
+						'Your cron trigger will now trigger executions on the schedule you have defined.',
+					defaults: {
+						name: 'Cron',
+						color: '#00FF00',
+					},
+					inputs: [],
+					outputs: ['main'],
+					properties: [
+						{
+							displayName: 'Trigger Times',
+							name: 'triggerTimes',
+							type: 'fixedCollection',
+							typeOptions: {
+								multipleValues: true,
+								multipleValueButtonText: 'Add Time',
+							},
+							default: {},
+							description: 'Triggers for the workflow',
+							placeholder: 'Add Cron Time',
+							options: [
+								{
+									name: 'item',
+									displayName: 'Item',
+									values: [
+										{
+											displayName: 'Mode',
+											name: 'mode',
+											type: 'options',
+											options: [
+												{
+													name: 'Every Minute',
+													value: 'everyMinute',
+												},
+												{
+													name: 'Every Hour',
+													value: 'everyHour',
+												},
+												{
+													name: 'Every Day',
+													value: 'everyDay',
+												},
+												{
+													name: 'Every Week',
+													value: 'everyWeek',
+												},
+												{
+													name: 'Every Month',
+													value: 'everyMonth',
+												},
+												{
+													name: 'Every X',
+													value: 'everyX',
+												},
+												{
+													name: 'Custom',
+													value: 'custom',
+												},
+											],
+											default: 'everyDay',
+											description: 'How often to trigger.',
+										},
+										{
+											displayName: 'Hour',
+											name: 'hour',
+											type: 'number',
+											typeOptions: {
+												minValue: 0,
+												maxValue: 23,
+											},
+											displayOptions: {
+												hide: {
+													mode: ['custom', 'everyHour', 'everyMinute', 'everyX'],
+												},
+											},
+											default: 14,
+											description: 'The hour of the day to trigger (24h format).',
+										},
+										{
+											displayName: 'Minute',
+											name: 'minute',
+											type: 'number',
+											typeOptions: {
+												minValue: 0,
+												maxValue: 59,
+											},
+											displayOptions: {
+												hide: {
+													mode: ['custom', 'everyMinute', 'everyX'],
+												},
+											},
+											default: 0,
+											description: 'The minute of the day to trigger.',
+										},
+										{
+											displayName: 'Day of Month',
+											name: 'dayOfMonth',
+											type: 'number',
+											displayOptions: {
+												show: {
+													mode: ['everyMonth'],
+												},
+											},
+											typeOptions: {
+												minValue: 1,
+												maxValue: 31,
+											},
+											default: 1,
+											description: 'The day of the month to trigger.',
+										},
+										{
+											displayName: 'Weekday',
+											name: 'weekday',
+											type: 'options',
+											displayOptions: {
+												show: {
+													mode: ['everyWeek'],
+												},
+											},
+											options: [
+												{
+													name: 'Monday',
+													value: '1',
+												},
+												{
+													name: 'Tuesday',
+													value: '2',
+												},
+												{
+													name: 'Wednesday',
+													value: '3',
+												},
+												{
+													name: 'Thursday',
+													value: '4',
+												},
+												{
+													name: 'Friday',
+													value: '5',
+												},
+												{
+													name: 'Saturday',
+													value: '6',
+												},
+												{
+													name: 'Sunday',
+													value: '0',
+												},
+											],
+											default: '1',
+											description: 'The weekday to trigger.',
+										},
+										{
+											displayName: 'Cron Expression',
+											name: 'cronExpression',
+											type: 'string',
+											displayOptions: {
+												show: {
+													mode: ['custom'],
+												},
+											},
+											default: '* * * * * *',
+											description:
+												'Use custom cron expression. Values and ranges as follows:<ul><li>Seconds: 0-59</li><li>Minutes: 0 - 59</li><li>Hours: 0 - 23</li><li>Day of Month: 1 - 31</li><li>Months: 0 - 11 (Jan - Dec)</li><li>Day of Week: 0 - 6 (Sun - Sat)</li></ul>.',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'number',
+											typeOptions: {
+												minValue: 0,
+												maxValue: 1000,
+											},
+											displayOptions: {
+												show: {
+													mode: ['everyX'],
+												},
+											},
+											default: 2,
+											description: 'All how many X minutes/hours it should trigger.',
+										},
+										{
+											displayName: 'Unit',
+											name: 'unit',
+											type: 'options',
+											displayOptions: {
+												show: {
+													mode: ['everyX'],
+												},
+											},
+											options: [
+												{
+													name: 'Minutes',
+													value: 'minutes',
+												},
+												{
+													name: 'Hours',
+													value: 'hours',
+												},
+											],
+											default: 'hours',
+											description: 'If it should trigger all X minutes or hours.',
+										},
+									],
+								},
+							],
+						},
+					],
+				},
+				async trigger(this: ITriggerFunctions): Promise<ITriggerResponse> {
+					const triggerTimes = this.getNodeParameter('triggerTimes') as unknown as {
+						item: TriggerTime[];
+					};
+
+					// Define the order the cron-time-parameter appear
+					const parameterOrder = [
+						'second', // 0 - 59
+						'minute', // 0 - 59
+						'hour', // 0 - 23
+						'dayOfMonth', // 1 - 31
+						'month', // 0 - 11(Jan - Dec)
+						'weekday', // 0 - 6(Sun - Sat)
+					];
+
+					// Get all the trigger times
+					const cronTimes: string[] = [];
+					let cronTime: string[];
+					let parameterName: string;
+					if (triggerTimes.item !== undefined) {
+						for (const item of triggerTimes.item) {
+							cronTime = [];
+							if (item.mode === 'custom') {
+								cronTimes.push(item.cronExpression as string);
+								continue;
+							}
+							if (item.mode === 'everyMinute') {
+								cronTimes.push(`${Math.floor(Math.random() * 60).toString()} * * * * *`);
+								continue;
+							}
+							if (item.mode === 'everyX') {
+								if (item.unit === 'minutes') {
+									cronTimes.push(
+										`${Math.floor(Math.random() * 60).toString()} */${item.value} * * * *`,
+									);
+								} else if (item.unit === 'hours') {
+									cronTimes.push(
+										`${Math.floor(Math.random() * 60).toString()} 0 */${item.value} * * *`,
+									);
+								}
+								continue;
+							}
+
+							for (parameterName of parameterOrder) {
+								if (item[parameterName] !== undefined) {
+									// Value is set so use it
+									cronTime.push(item[parameterName] as string);
+								} else if (parameterName === 'second') {
+									// For seconds we use by default a random one to make sure to
+									// balance the load a little bit over time
+									cronTime.push(Math.floor(Math.random() * 60).toString());
+								} else {
+									// For all others set "any"
+									cronTime.push('*');
+								}
+							}
+
+							cronTimes.push(cronTime.join(' '));
+						}
+					}
+
+					// The trigger function to execute when the cron-time got reached
+					// or when manually triggered
+					const executeTrigger = () => {
+						this.emit([this.helpers.returnJsonArray([{}])]);
+					};
+
+					const timezone = this.getTimezone();
+
+					// Start the cron-jobs
+					const cronJobs: CronJob[] = [];
+					for (const cronTime of cronTimes) {
+						cronJobs.push(new CronJob(cronTime, executeTrigger, undefined, true, timezone));
+					}
+
+					// Stop the cron-jobs
+					async function closeFunction() {
+						for (const cronJob of cronJobs) {
+							cronJob.stop();
+						}
+					}
+
+					async function manualTriggerFunction() {
+						executeTrigger();
+					}
+
+					return {
+						closeFunction,
+						manualTriggerFunction,
+					};
+				},
+			},
+		},
+		'n8n-nodes-base.set': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'Set',
+					name: 'set',
+					icon: 'fa:pen',
+					group: ['input'],
+					version: 1,
+					description: 'Sets values on items and optionally remove other values',
+					defaults: {
+						name: 'Set',
+						color: '#0000FF',
+					},
+					inputs: ['main'],
+					outputs: ['main'],
+					properties: [
+						{
+							displayName: 'Keep Only Set',
+							name: 'keepOnlySet',
+							type: 'boolean',
+							default: false,
+							description:
+								'If only the values set on this node should be kept and all others removed.',
+						},
+						{
+							displayName: 'Values to Set',
+							name: 'values',
+							placeholder: 'Add Value',
+							type: 'fixedCollection',
+							typeOptions: {
+								multipleValues: true,
+								sortable: true,
+							},
+							description: 'The value to set.',
+							default: {},
+							options: [
+								{
+									name: 'boolean',
+									displayName: 'Boolean',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description:
+												'Name of the property to write data to. Supports dot-notation. Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'boolean',
+											default: false,
+											description: 'The boolean value to write in the property.',
+										},
+									],
+								},
+								{
+									name: 'number',
+									displayName: 'Number',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description:
+												'Name of the property to write data to. Supports dot-notation. Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'number',
+											default: 0,
+											description: 'The number value to write in the property.',
+										},
+									],
+								},
+								{
+									name: 'string',
+									displayName: 'String',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description:
+												'Name of the property to write data to. Supports dot-notation. Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'string',
+											default: '',
+											description: 'The string value to write in the property.',
+										},
+									],
+								},
+							],
+						},
+
+						{
+							displayName: 'Options',
+							name: 'options',
+							type: 'collection',
+							placeholder: 'Add Option',
+							default: {},
+							options: [
+								{
+									displayName: 'Dot Notation',
+									name: 'dotNotation',
+									type: 'boolean',
+									default: true,
+									description: `<p>By default, dot-notation is used in property names. This means that "a.b" will set the property "b" underneath "a" so { "a": { "b": value} }.<p></p>If that is not intended this can be deactivated, it will then set { "a.b": value } instead.</p>
+									`,
+								},
+							],
+						},
+					],
+				},
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const items = this.getInputData();
+
+					if (items.length === 0) {
+						items.push({ json: {} });
+					}
+
+					const returnData: INodeExecutionData[] = [];
+
+					let item: INodeExecutionData;
+					let keepOnlySet: boolean;
+					for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+						keepOnlySet = this.getNodeParameter('keepOnlySet', itemIndex, false) as boolean;
+						item = items[itemIndex];
+						const options = this.getNodeParameter('options', itemIndex, {}) as IDataObject;
+
+						const newItem: INodeExecutionData = {
+							json: {},
+						};
+
+						if (keepOnlySet !== true) {
+							if (item.binary !== undefined) {
+								// Create a shallow copy of the binary data so that the old
+								// data references which do not get changed still stay behind
+								// but the incoming data does not get changed.
+								newItem.binary = {};
+								Object.assign(newItem.binary, item.binary);
+							}
+
+							newItem.json = JSON.parse(JSON.stringify(item.json));
+						}
+
+						// Add boolean values
+						(this.getNodeParameter('values.boolean', itemIndex, []) as INodeParameters[]).forEach(
+							(setItem) => {
+								if (options.dotNotation === false) {
+									newItem.json[setItem.name as string] = !!setItem.value;
+								} else {
+									set(newItem.json, setItem.name as string, !!setItem.value);
+								}
+							},
+						);
+
+						// Add number values
+						(this.getNodeParameter('values.number', itemIndex, []) as INodeParameters[]).forEach(
+							(setItem) => {
+								if (options.dotNotation === false) {
+									newItem.json[setItem.name as string] = setItem.value;
+								} else {
+									set(newItem.json, setItem.name as string, setItem.value);
+								}
+							},
+						);
+
+						// Add string values
+						(this.getNodeParameter('values.string', itemIndex, []) as INodeParameters[]).forEach(
+							(setItem) => {
+								if (options.dotNotation === false) {
+									newItem.json[setItem.name as string] = setItem.value;
+								} else {
+									set(newItem.json, setItem.name as string, setItem.value);
+								}
+							},
+						);
+
+						returnData.push(newItem);
+					}
+
+					return this.prepareOutputData(returnData);
+				},
+			},
+		},
+	};
+	const nodeTypes = NodeTypes();
+	await nodeTypes.init(types);
+}
+
 /**
 * Initialize a logger for test runs.
 */
@@ -123,6 +754,14 @@ export function initTestLogger() {
 	LoggerProxy.init(getLogger());
 }

+/**
+ * Initialize a BinaryManager for test runs.
+ */
+export async function initBinaryManager() {
+	const binaryDataConfig = config.getEnv('binaryDataManager');
+	await BinaryDataManager.init(binaryDataConfig, true);
+}
+
 /**
 * Initialize a user settings config file if non-existent.
 */
@@ -142,13 +781,26 @@ export function initConfigFile() {
 /**
 * Create a request agent, optionally with an auth cookie.
 */
-export function createAgent(app: express.Application, options?: { auth: true; user: User }) {
+export function createAgent(
+	app: express.Application,
+	options?: { apiPath?: ApiPath; version?: string | number; auth: boolean; user: User },
+) {
 	const agent = request.agent(app);
-	agent.use(prefix(REST_PATH_SEGMENT));

-	if (options?.auth && options?.user) {
-		const { token } = issueJWT(options.user);
-		agent.jar.setCookie(`${AUTH_COOKIE_NAME}=${token}`);
+	if (options?.apiPath === undefined || options?.apiPath === 'internal') {
+		agent.use(prefix(REST_PATH_SEGMENT));
+		if (options?.auth && options?.user) {
+			const { token } = issueJWT(options.user);
+			agent.jar.setCookie(`${AUTH_COOKIE_NAME}=${token}`);
+		}
+	}
+
+	if (options?.apiPath === 'public') {
+		agent.use(prefix(`${PUBLIC_API_REST_PATH_SEGMENT}/v${options?.version}`));
+
+		if (options?.auth && options?.user.apiKey) {
+			agent.set({ 'X-N8N-API-KEY': options.user.apiKey });
+		}
 	}

 	return agent;
@@ -170,7 +822,6 @@ export function prefix(pathSegment: string) {

 		url.pathname = pathSegment + url.pathname;
 		request.url = url.toString();
-
 		return request;
 	};
 }