n8n 0.178.2 → 0.181.0

package/dist/test/integration/shared/utils.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.categorize = exports.skipSmtpTest = exports.isTestSmtpServiceAvailable = exports.configureSmtp = exports.isInstanceOwnerSetUp = exports.getAuthToken = exports.prefix = exports.createAgent = exports.initConfigFile = exports.initTestLogger = exports.initTestTelemetry = exports.initTestServer = void 0;
+exports.getPostgresSchemaSection = exports.categorize = exports.skipSmtpTest = exports.isTestSmtpServiceAvailable = exports.configureSmtp = exports.isInstanceOwnerSetUp = exports.getAuthToken = exports.prefix = exports.createAgent = exports.initConfigFile = exports.initBinaryManager = exports.initTestLogger = exports.initNodeTypes = exports.initCredentialsTypes = exports.gitHubCredentialType = exports.initActiveWorkflowRunner = exports.initTestTelemetry = exports.initTestServer = void 0;
 const crypto_1 = require("crypto");
 const fs_1 = require("fs");
 const express_1 = __importDefault(require("express"));
@@ -37,7 +37,8 @@ const util_1 = __importDefault(require("util"));
 const nodemailer_1 = require("nodemailer");
 const n8n_workflow_1 = require("n8n-workflow");
 const n8n_core_1 = require("n8n-core");
-const config_1 = __importDefault(require("../../../config"));
+const cron_1 = require("cron");
+const config = require("../../../config");
 const constants_1 = require("./constants");
 const constants_2 = require("../../../src/constants");
 const routes_1 = require("../../../src/UserManagement/routes");
@@ -50,13 +51,15 @@ const passwordReset_1 = require("../../../src/UserManagement/routes/passwordRese
 const jwt_1 = require("../../../src/UserManagement/auth/jwt");
 const Logger_1 = require("../../../src/Logger");
 const credentials_api_1 = require("../../../src/api/credentials.api");
+const PublicApi_1 = require("../../../src/PublicApi/");
+const lodash_1 = require("lodash");
 const UserManagementMailer = __importStar(require("../../../src/UserManagement/email/UserManagementMailer"));
-function initTestServer({ applyAuth, endpointGroups, }) {
-    const testServer = Object.assign({ app: (0, express_1.default)(), restEndpoint: constants_1.REST_PATH_SEGMENT }, ((endpointGroups === null || endpointGroups === void 0 ? void 0 : endpointGroups.includes('credentials')) ? { externalHooks: (0, src_1.ExternalHooks)() } : {}));
+async function initTestServer({ applyAuth, endpointGroups, }) {
+    const testServer = Object.assign({ app: (0, express_1.default)(), restEndpoint: constants_1.REST_PATH_SEGMENT, publicApiEndpoint: constants_1.PUBLIC_API_REST_PATH_SEGMENT }, ((endpointGroups === null || endpointGroups === void 0 ? void 0 : endpointGroups.includes('credentials')) ? { externalHooks: (0, src_1.ExternalHooks)() } : {}));
     testServer.app.use(body_parser_1.default.json());
     testServer.app.use(body_parser_1.default.urlencoded({ extended: true }));
-    config_1.default.set('userManagement.jwtSecret', 'My JWT secret');
-    config_1.default.set('userManagement.isInstanceOwnerSetUp', false);
+    config.set('userManagement.jwtSecret', 'My JWT secret');
+    config.set('userManagement.isInstanceOwnerSetUp', false);
     if (applyAuth) {
         routes_1.addRoutes.apply(testServer, [constants_1.AUTHLESS_ENDPOINTS, constants_1.REST_PATH_SEGMENT]);
     }
@@ -64,11 +67,18 @@ function initTestServer({ applyAuth, endpointGroups, }) {
         return testServer.app;
     const [routerEndpoints, functionEndpoints] = classifyEndpointGroups(endpointGroups);
     if (routerEndpoints.length) {
+        const { apiRouters } = await (0, PublicApi_1.loadPublicApiVersions)(testServer.publicApiEndpoint);
         const map = {
             credentials: credentials_api_1.credentialsController,
+            publicApi: apiRouters
         };
         for (const group of routerEndpoints) {
-            testServer.app.use(`/${testServer.restEndpoint}/${group}`, map[group]);
+            if (group === 'publicApi') {
+                testServer.app.use(...map[group]);
+            }
+            else {
+                testServer.app.use(`/${testServer.restEndpoint}/${group}`, map[group]);
+            }
         }
     }
     if (functionEndpoints.length) {
@@ -94,13 +104,550 @@ exports.initTestTelemetry = initTestTelemetry;
 const classifyEndpointGroups = (endpointGroups) => {
     const routerEndpoints = [];
     const functionEndpoints = [];
-    endpointGroups.forEach((group) => (group === 'credentials' ? routerEndpoints : functionEndpoints).push(group));
+    endpointGroups.forEach((group) => (group === 'credentials' || group === 'publicApi' ? routerEndpoints : functionEndpoints).push(group));
     return [routerEndpoints, functionEndpoints];
 };
+async function initActiveWorkflowRunner() {
+    const workflowRunner = src_1.ActiveWorkflowRunner.getInstance();
+    workflowRunner.init();
+    return workflowRunner;
+}
+exports.initActiveWorkflowRunner = initActiveWorkflowRunner;
+function gitHubCredentialType() {
+    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: '',
+            },
+        ],
+    };
+}
+exports.gitHubCredentialType = gitHubCredentialType;
+async function initCredentialsTypes() {
+    const credentialTypes = (0, src_1.CredentialTypes)();
+    await credentialTypes.init({
+        githubApi: {
+            type: gitHubCredentialType(),
+            sourcePath: '',
+        },
+    });
+}
+exports.initCredentialsTypes = initCredentialsTypes;
+async function initNodeTypes() {
+    const types = {
+        '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() {
+                    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() {
+                    const triggerTimes = this.getNodeParameter('triggerTimes');
+                    const parameterOrder = [
+                        'second',
+                        'minute',
+                        'hour',
+                        'dayOfMonth',
+                        'month',
+                        'weekday',
+                    ];
+                    const cronTimes = [];
+                    let cronTime;
+                    let parameterName;
+                    if (triggerTimes.item !== undefined) {
+                        for (const item of triggerTimes.item) {
+                            cronTime = [];
+                            if (item.mode === 'custom') {
+                                cronTimes.push(item.cronExpression);
+                                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) {
+                                    cronTime.push(item[parameterName]);
+                                }
+                                else if (parameterName === 'second') {
+                                    cronTime.push(Math.floor(Math.random() * 60).toString());
+                                }
+                                else {
+                                    cronTime.push('*');
+                                }
+                            }
+                            cronTimes.push(cronTime.join(' '));
+                        }
+                    }
+                    const executeTrigger = () => {
+                        this.emit([this.helpers.returnJsonArray([{}])]);
+                    };
+                    const timezone = this.getTimezone();
+                    const cronJobs = [];
+                    for (const cronTime of cronTimes) {
+                        cronJobs.push(new cron_1.CronJob(cronTime, executeTrigger, undefined, true, timezone));
+                    }
+                    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() {
+                    const items = this.getInputData();
+                    if (items.length === 0) {
+                        items.push({ json: {} });
+                    }
+                    const returnData = [];
+                    let item;
+                    let keepOnlySet;
+                    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+                        keepOnlySet = this.getNodeParameter('keepOnlySet', itemIndex, false);
+                        item = items[itemIndex];
+                        const options = this.getNodeParameter('options', itemIndex, {});
+                        const newItem = {
+                            json: {},
+                        };
+                        if (keepOnlySet !== true) {
+                            if (item.binary !== undefined) {
+                                newItem.binary = {};
+                                Object.assign(newItem.binary, item.binary);
+                            }
+                            newItem.json = JSON.parse(JSON.stringify(item.json));
+                        }
+                        this.getNodeParameter('values.boolean', itemIndex, []).forEach((setItem) => {
+                            if (options.dotNotation === false) {
+                                newItem.json[setItem.name] = !!setItem.value;
+                            }
+                            else {
+                                (0, lodash_1.set)(newItem.json, setItem.name, !!setItem.value);
+                            }
+                        });
+                        this.getNodeParameter('values.number', itemIndex, []).forEach((setItem) => {
+                            if (options.dotNotation === false) {
+                                newItem.json[setItem.name] = setItem.value;
+                            }
+                            else {
+                                (0, lodash_1.set)(newItem.json, setItem.name, setItem.value);
+                            }
+                        });
+                        this.getNodeParameter('values.string', itemIndex, []).forEach((setItem) => {
+                            if (options.dotNotation === false) {
+                                newItem.json[setItem.name] = setItem.value;
+                            }
+                            else {
+                                (0, lodash_1.set)(newItem.json, setItem.name, setItem.value);
+                            }
+                        });
+                        returnData.push(newItem);
+                    }
+                    return this.prepareOutputData(returnData);
+                },
+            },
+        },
+    };
+    const nodeTypes = (0, src_1.NodeTypes)();
+    await nodeTypes.init(types);
+}
+exports.initNodeTypes = initNodeTypes;
 function initTestLogger() {
     n8n_workflow_1.LoggerProxy.init((0, Logger_1.getLogger)());
 }
 exports.initTestLogger = initTestLogger;
+async function initBinaryManager() {
+    const binaryDataConfig = config.getEnv('binaryDataManager');
+    await n8n_core_1.BinaryDataManager.init(binaryDataConfig, true);
+}
+exports.initBinaryManager = initBinaryManager;
 function initConfigFile() {
     const settingsPath = n8n_core_1.UserSettings.getUserSettingsPath();
     if (!(0, fs_1.existsSync)(settingsPath)) {
@@ -111,10 +658,18 @@ function initConfigFile() {
 exports.initConfigFile = initConfigFile;
 function createAgent(app, options) {
     const agent = supertest_1.default.agent(app);
-    agent.use(prefix(constants_1.REST_PATH_SEGMENT));
-    if ((options === null || options === void 0 ? void 0 : options.auth) && (options === null || options === void 0 ? void 0 : options.user)) {
-        const { token } = (0, jwt_1.issueJWT)(options.user);
-        agent.jar.setCookie(`${constants_2.AUTH_COOKIE_NAME}=${token}`);
+    if ((options === null || options === void 0 ? void 0 : options.apiPath) === undefined || (options === null || options === void 0 ? void 0 : options.apiPath) === 'internal') {
+        agent.use(prefix(constants_1.REST_PATH_SEGMENT));
+        if ((options === null || options === void 0 ? void 0 : options.auth) && (options === null || options === void 0 ? void 0 : options.user)) {
+            const { token } = (0, jwt_1.issueJWT)(options.user);
+            agent.jar.setCookie(`${constants_2.AUTH_COOKIE_NAME}=${token}`);
+        }
+    }
+    if ((options === null || options === void 0 ? void 0 : options.apiPath) === 'public') {
+        agent.use(prefix(`${constants_1.PUBLIC_API_REST_PATH_SEGMENT}/v${options === null || options === void 0 ? void 0 : options.version}`));
+        if ((options === null || options === void 0 ? void 0 : options.auth) && (options === null || options === void 0 ? void 0 : options.user.apiKey)) {
+            agent.set({ 'X-N8N-API-KEY': options.user.apiKey });
+        }
     }
     return agent;
 }
@@ -154,12 +709,12 @@ exports.isInstanceOwnerSetUp = isInstanceOwnerSetUp;
 const getSmtpTestAccount = util_1.default.promisify(nodemailer_1.createTestAccount);
 async function configureSmtp() {
     const { user, pass, smtp: { host, port, secure }, } = await getSmtpTestAccount();
-    config_1.default.set('userManagement.emails.mode', 'smtp');
-    config_1.default.set('userManagement.emails.smtp.host', host);
-    config_1.default.set('userManagement.emails.smtp.port', port);
-    config_1.default.set('userManagement.emails.smtp.secure', secure);
-    config_1.default.set('userManagement.emails.smtp.auth.user', user);
-    config_1.default.set('userManagement.emails.smtp.auth.pass', pass);
+    config.set('userManagement.emails.mode', 'smtp');
+    config.set('userManagement.emails.smtp.host', host);
+    config.set('userManagement.emails.smtp.port', port);
+    config.set('userManagement.emails.smtp.secure', secure);
+    config.set('userManagement.emails.smtp.auth.user', user);
+    config.set('userManagement.emails.smtp.auth.pass', pass);
 }
 exports.configureSmtp = configureSmtp;
 async function isTestSmtpServiceAvailable() {
@@ -185,4 +740,13 @@ const categorize = (arr, test) => {
     }, { pass: [], fail: [] });
 };
 exports.categorize = categorize;
+function getPostgresSchemaSection(schema = config.getSchema()) {
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'postgresdb') {
+            return value._cvtProperties;
+        }
+    }
+    return null;
+}
+exports.getPostgresSchemaSection = getPostgresSchemaSection;
 //# sourceMappingURL=utils.js.map