admin/n8n-enterprise-unlocked
1
0
Fork 0
mirror of https://github.com/Abdulazizzn/n8n-enterprise-unlocked.git synced 2025-12-18 10:31:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Add n8n Public API (#3064)

Browse Source 
* ✨ 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>
This commit is contained in:
Ricardo Espinoza
2022-06-08 14:53:12 -04:00
committed by GitHub
parent 1999f4b066
commit a18081d749
112 changed files with 7182 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

683
packages/cli/test/integration/shared/utils.ts
View File

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