feat(airbrake): add new errors trigger

feat: put favicon and notifications page behind feature flags

.devcontainer/devcontainer.json

@@ -8,7 +8,7 @@
       "version": "latest"
     },
     "ghcr.io/devcontainers/features/node:1": {
-      "version": 16
+      "version": 20
     },
     "ghcr.io/devcontainers/features/common-utils:1": {
       "username": "vscode",

package.json

@@ -6,8 +6,7 @@
     "start": "lerna run --stream --parallel --scope=@*/{web,backend} dev",
     "start:web": "lerna run --stream --scope=@*/web dev",
     "start:backend": "lerna run --stream --scope=@*/backend dev",
-    "lint": "lerna run --no-bail --stream --parallel --scope=@*/{web,backend,cli} lint",
-    "build:watch": "lerna run --no-bail --stream --parallel --scope=@*/{web,backend,cli} build:watch",
+    "lint": "lerna run --no-bail --stream --parallel --scope=@*/{web,backend} lint",
     "build:docs": "cd ./packages/docs && yarn install && yarn build"
   },
   "workspaces": {

packages/backend/src/apps/airbrake/assets/favicon.svg

@@ -0,0 +1 @@
+<svg height="255" preserveAspectRatio="xMidYMid" viewBox="0 0 256 255" width="256" xmlns="http://www.w3.org/2000/svg"><path d="m128.636514 155.746615v-155.23361889h-3.522242v.06873152l-124.60824865 64.03287157v60.8642488h.00597665v3.234366h-.00597665v60.868233l124.60824865 64.747082h3.842989v-98.581914z" fill="#ff8e4a"/><path d="m129.941416 254.328529 125.568498-64.747082v-124.9668478l-125.887253-64.10160309h-2.243237v253.81055289h2.243237" fill="#f48746"/><path d="m109.097837 87.2551595h36.19561v59.2077195h-36.19561z" fill="#ff8e4a"/><path d="m66.1735097 188.397074h14.8639378c9.4102412 0 12.6087471-2.238257 15.6189883-9.988981l8.2796572-21.353587h45.159596l8.280653 21.353587c3.011238 7.750724 6.396016 9.988981 15.805261 9.988981h14.677665v-19.114335h-3.011237c-3.19751 0-4.704622-.689307-5.831222-3.790194l-39.516638-99.3658524h-25.779299l-39.703907 99.3658524c-1.1285915 3.100887-2.632716 3.790194-5.833214 3.790194h-3.0102413zm44.4075333-49.939922 11.478163-30.655253c2.445448-6.714771 5.269417-18.2556889 5.269417-18.2556889h.375533s2.822972 11.5409179 5.269416 18.2556889l11.478163 30.655253z" fill="#fff"/><path d="m231.204856 150.082739v-51.8086223c.235082 4.5233303 2.970397 16.8432063 24.305058 27.8512063v11.653479zm0-53.1623343v1.353712c-.029883-.5926848-.01793-1.0479066 0-1.353712zm.041837-.4392841s-.022911.1534008-.041837.4392841v-.4392841z" fill="#d4763c"/><path d="m231.155051 94.3016342c-.013946.9931207.05877 1.8945993.049805 2.0460078-.01793.2480312-2.220327 16.094132 24.305058 29.777681v-60.863253c-23.325883 12.0349884-24.449494 25.7414475-24.354863 29.0395642" fill="#ff8e4a"/></svg>

packages/backend/src/apps/airbrake/auth/index.js

@@ -0,0 +1,44 @@
+import verifyCredentials from './verify-credentials.js';
+import isStillVerified from './is-still-verified.js';
+
+export default {
+  fields: [
+    {
+      key: 'screenName',
+      label: 'Screen Name',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description:
+        'Screen name of your connection to be used on Automatisch UI.',
+      clickToCopy: false,
+    },
+    {
+      key: 'instanceUrl',
+      label: 'Instance URL',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: 'Your subdomain as https://{yoursubdomain}.airbrake.io',
+      clickToCopy: false,
+    },
+    {
+      key: 'authToken',
+      label: 'Auth Token',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: 'Airbrake Auth Token of your account.',
+      clickToCopy: false,
+    },
+  ],
+
+  verifyCredentials,
+  isStillVerified,
+};

packages/backend/src/apps/airbrake/auth/is-still-verified.js

@@ -0,0 +1,8 @@
+import verifyCredentials from './verify-credentials.js';
+
+const isStillVerified = async ($) => {
+  await verifyCredentials($);
+  return true;
+};
+
+export default isStillVerified;

packages/backend/src/apps/airbrake/auth/verify-credentials.js

@@ -0,0 +1,14 @@
+const verifyCredentials = async ($) => {
+  await $.http.get(`/api/v4/projects?key=${$.auth.data.authToken}`, {
+    additionalProperties: {
+      skipAddingAuthToken: true,
+    },
+  });
+
+  await $.auth.set({
+    screenName: $.auth.data.screenName,
+    authToken: $.auth.data.authToken,
+  });
+};
+
+export default verifyCredentials;

packages/backend/src/apps/airbrake/common/add-auth-token.js

@@ -0,0 +1,10 @@
+const addAuthToken = ($, requestConfig) => {
+  if (requestConfig.additionalProperties?.skipAddingAuthToken)
+    return requestConfig;
+
+  requestConfig.url = requestConfig.url + `?key=${$.auth.data.authToken}`;
+
+  return requestConfig;
+};
+
+export default addAuthToken;

packages/backend/src/apps/airbrake/common/set-base-url.js

@@ -0,0 +1,11 @@
+const setBaseUrl = ($, requestConfig) => {
+  const subdomain = $.auth.data.instanceUrl;
+
+  if (subdomain) {
+    requestConfig.baseURL = `https://${subdomain}.airbrake.io`;
+  }
+
+  return requestConfig;
+};
+
+export default setBaseUrl;

packages/backend/src/apps/airbrake/dynamic-data/index.js

@@ -0,0 +1,3 @@
+import listProjects from './list-projects/index.js';
+
+export default [listProjects];

packages/backend/src/apps/airbrake/dynamic-data/list-projects/index.js

@@ -0,0 +1,23 @@
+export default {
+  name: 'List projects',
+  key: 'listProjects',
+
+  async run($) {
+    const projects = {
+      data: [],
+    };
+
+    const { data } = await $.http.get('/api/v4/projects');
+
+    if (data.projects.length) {
+      for (const project of data.projects) {
+        projects.data.push({
+          value: project.id,
+          name: project.name,
+        });
+      }
+    }
+
+    return projects;
+  },
+};

packages/backend/src/apps/airbrake/index.js

@@ -0,0 +1,21 @@
+import defineApp from '../../helpers/define-app.js';
+import setBaseUrl from './common/set-base-url.js';
+import auth from './auth/index.js';
+import addAuthToken from './common/add-auth-token.js';
+import triggers from './triggers/index.js';
+import dynamicData from './dynamic-data/index.js';
+
+export default defineApp({
+  name: 'Airbrake',
+  key: 'airbrake',
+  iconUrl: '{BASE_URL}/apps/airbrake/assets/favicon.svg',
+  authDocUrl: 'https://automatisch.io/docs/apps/airbrake/connection',
+  supportsConnections: true,
+  baseUrl: 'https://www.airbrake.io',
+  apiBaseUrl: '',
+  primaryColor: 'f58c54',
+  beforeRequest: [setBaseUrl, addAuthToken],
+  auth,
+  triggers,
+  dynamicData,
+});

packages/backend/src/apps/airbrake/triggers/index.js

@@ -0,0 +1,3 @@
+import newErrors from './new-errors/index.js';
+
+export default [newErrors];

packages/backend/src/apps/airbrake/triggers/new-errors/index.js

@@ -0,0 +1,66 @@
+//import { URLSearchParams } from 'node:url';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New errors',
+  key: 'newErrors',
+  pollInterval: 15,
+  description: 'Triggers when a new error occurs.',
+  arguments: [
+    {
+      label: 'Project',
+      key: 'projectId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listProjects',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const projectId = $.step.parameters.projectId;
+
+    const params = {
+      limit: 100,
+      page: 1,
+    };
+
+    let next = false;
+    do {
+      const { data } = await $.http.get(
+        `/api/v4/projects/${projectId}/groups`,
+        { params }
+      );
+
+      if (data.count > params.limit) {
+        params.page = params.page + 1;
+        next = true;
+      } else {
+        next = false;
+      }
+
+      if (!data?.groups?.length) {
+        return;
+      }
+
+      for (const group of data.groups) {
+        $.pushTriggerItem({
+          raw: group,
+          meta: {
+            internalId: group.id,
+          },
+        });
+      }
+    } while (next);
+  },
+});

packages/backend/src/apps/formatter/actions/text/index.js

@@ -1,5 +1,6 @@
 import defineAction from '../../../../helpers/define-action.js';
 
+import base64ToString from './transformers/base64-to-string.js';
 import capitalize from './transformers/capitalize.js';
 import extractEmailAddress from './transformers/extract-email-address.js';
 import extractNumber from './transformers/extract-number.js';
@@ -8,10 +9,12 @@ import lowercase from './transformers/lowercase.js';
 import markdownToHtml from './transformers/markdown-to-html.js';
 import pluralize from './transformers/pluralize.js';
 import replace from './transformers/replace.js';
+import stringToBase64 from './transformers/string-to-base64.js';
 import trimWhitespace from './transformers/trim-whitespace.js';
 import useDefaultValue from './transformers/use-default-value.js';
 
 const transformers = {
+  base64ToString,
   capitalize,
   extractEmailAddress,
   extractNumber,
@@ -20,6 +23,7 @@ const transformers = {
   markdownToHtml,
   pluralize,
   replace,
+  stringToBase64,
   trimWhitespace,
   useDefaultValue,
 };
@@ -37,6 +41,7 @@ export default defineAction({
       required: true,
       variables: true,
       options: [
+        { label: 'Base64 to String', value: 'base64ToString' },
         { label: 'Capitalize', value: 'capitalize' },
         { label: 'Convert HTML to Markdown', value: 'htmlToMarkdown' },
         { label: 'Convert Markdown to HTML', value: 'markdownToHtml' },
@@ -45,6 +50,7 @@ export default defineAction({
         { label: 'Lowercase', value: 'lowercase' },
         { label: 'Pluralize', value: 'pluralize' },
         { label: 'Replace', value: 'replace' },
+        { label: 'String to Base64', value: 'stringToBase64' },
         { label: 'Trim Whitespace', value: 'trimWhitespace' },
         { label: 'Use Default Value', value: 'useDefaultValue' },
       ],

packages/backend/src/apps/formatter/actions/text/transformers/base64-to-string.js

@@ -0,0 +1,8 @@
+const base64ToString = ($) => {
+  const input = $.step.parameters.input;
+  const decodedString = Buffer.from(input, 'base64').toString('utf8');
+
+  return decodedString;
+};
+
+export default base64ToString;

packages/backend/src/apps/formatter/actions/text/transformers/string-to-base64.js

@@ -0,0 +1,8 @@
+const stringtoBase64 = ($) => {
+  const input = $.step.parameters.input;
+  const base64String = Buffer.from(input).toString('base64');
+
+  return base64String;
+};
+
+export default stringtoBase64;

packages/backend/src/apps/formatter/dynamic-fields/list-transform-options/index.js

@@ -1,3 +1,4 @@
+import base64ToString from './text/base64-to-string.js';
 import capitalize from './text/capitalize.js';
 import extractEmailAddress from './text/extract-email-address.js';
 import extractNumber from './text/extract-number.js';
@@ -6,6 +7,7 @@ import lowercase from './text/lowercase.js';
 import markdownToHtml from './text/markdown-to-html.js';
 import pluralize from './text/pluralize.js';
 import replace from './text/replace.js';
+import stringToBase64 from './text/string-to-base64.js';
 import trimWhitespace from './text/trim-whitespace.js';
 import useDefaultValue from './text/use-default-value.js';
 import performMathOperation from './numbers/perform-math-operation.js';
@@ -15,6 +17,7 @@ import formatPhoneNumber from './numbers/format-phone-number.js';
 import formatDateTime from './date-time/format-date-time.js';
 
 const options = {
+  base64ToString,
   capitalize,
   extractEmailAddress,
   extractNumber,
@@ -23,6 +26,7 @@ const options = {
   markdownToHtml,
   pluralize,
   replace,
+  stringToBase64,
   trimWhitespace,
   useDefaultValue,
   performMathOperation,

packages/backend/src/apps/formatter/dynamic-fields/list-transform-options/text/base64-to-string.js

@@ -0,0 +1,12 @@
+const base64ToString = [
+  {
+    label: 'Input',
+    key: 'input',
+    type: 'string',
+    required: true,
+    description: 'Text that will be converted from Base64 to string.',
+    variables: true,
+  },
+];
+
+export default base64ToString;

packages/backend/src/apps/formatter/dynamic-fields/list-transform-options/text/string-to-base64.js

@@ -0,0 +1,12 @@
+const stringToBase64 = [
+  {
+    label: 'Input',
+    key: 'input',
+    type: 'string',
+    required: true,
+    description: 'Text that will be converted to Base64.',
+    variables: true,
+  },
+];
+
+export default stringToBase64;

packages/backend/src/config/app.js

@@ -18,7 +18,9 @@ const port = process.env.PORT || '3000';
 const serveWebAppSeparately =
   process.env.SERVE_WEB_APP_SEPARATELY === 'true' ? true : false;
 
-let apiUrl = new URL(`${protocol}://${host}:${port}`).toString();
+let apiUrl = new URL(
+  process.env.API_URL || `${protocol}://${host}:${port}`
+).toString();
 apiUrl = apiUrl.substring(0, apiUrl.length - 1);
 
 // use apiUrl by default, which has less priority over the following cases
@@ -88,6 +90,10 @@ const appConfig = {
   licenseKey: process.env.LICENSE_KEY,
   sentryDsn: process.env.SENTRY_DSN,
   CI: process.env.CI === 'true',
+  disableNotificationsPage: process.env.DISABLE_NOTIFICATIONS_PAGE === 'true',
+  disableFavicon: process.env.DISABLE_FAVICON === 'true',
+  additionalDrawerLink: process.env.ADDITIONAL_DRAWER_LINK,
+  additionalDrawerLinkText: process.env.ADDITIONAL_DRAWER_LINK_TEXT,
 };
 
 if (!appConfig.encryptionKey) {

packages/backend/src/graphql/mutations/register-user.ee.js

@@ -1,7 +1,10 @@
+import appConfig from '../../config/app.js';
 import User from '../../models/user.js';
 import Role from '../../models/role.js';
 
 const registerUser = async (_parent, params) => {
+  if (!appConfig.isCloud) return;
+
   const { fullName, email, password } = params.input;
 
   const existingUser = await User.query().findOne({

packages/backend/src/graphql/queries/get-config.ee.js

@@ -1,9 +1,17 @@
+import appConfig from '../../config/app.js';
 import { hasValidLicense } from '../../helpers/license.ee.js';
 import Config from '../../models/config.js';
 
 const getConfig = async (_parent, params) => {
   if (!(await hasValidLicense())) return {};
 
+  const defaultConfig = {
+    disableNotificationsPage: appConfig.disableNotificationsPage,
+    disableFavicon: appConfig.disableFavicon,
+    additionalDrawerLink: appConfig.additionalDrawerLink,
+    additionalDrawerLinkText: appConfig.additionalDrawerLinkText,
+  };
+
   const configQuery = Config.query();
 
   if (Array.isArray(params.keys)) {
@@ -18,7 +26,7 @@ const getConfig = async (_parent, params) => {
     computedConfig[key] = value?.data;
 
     return computedConfig;
-  }, {});
+  }, defaultConfig);
 };
 
 export default getConfig;

packages/backend/src/graphql/queries/get-config.ee.test.js

@@ -2,6 +2,7 @@ import { vi, describe, it, expect, beforeEach } from 'vitest';
 import request from 'supertest';
 import app from '../../app';
 import { createConfig } from '../../../test/factories/config';
+import appConfig from '../../config/app';
 import * as license from '../../helpers/license.ee';
 
 describe('graphQL getConfig query', () => {
@@ -56,6 +57,10 @@ describe('graphQL getConfig query', () => {
               [configOne.key]: configOne.value.data,
               [configTwo.key]: configTwo.value.data,
               [configThree.key]: configThree.value.data,
+              disableNotificationsPage: false,
+              disableFavicon: false,
+              additionalDrawerLink: undefined,
+              additionalDrawerLinkText: undefined,
             },
           },
         };
@@ -82,6 +87,48 @@ describe('graphQL getConfig query', () => {
             getConfig: {
               [configOne.key]: configOne.value.data,
               [configTwo.key]: configTwo.value.data,
+              disableNotificationsPage: false,
+              disableFavicon: false,
+              additionalDrawerLink: undefined,
+              additionalDrawerLinkText: undefined,
+            },
+          },
+        };
+
+        expect(response.body).toEqual(expectedResponsePayload);
+      });
+    });
+
+    describe('and with different defaults', () => {
+      beforeEach(async () => {
+        vi.spyOn(appConfig, 'disableNotificationsPage', 'get').mockReturnValue(
+          true
+        );
+        vi.spyOn(appConfig, 'disableFavicon', 'get').mockReturnValue(true);
+        vi.spyOn(appConfig, 'additionalDrawerLink', 'get').mockReturnValue(
+          'https://automatisch.io'
+        );
+        vi.spyOn(appConfig, 'additionalDrawerLinkText', 'get').mockReturnValue(
+          'Automatisch'
+        );
+      });
+
+      it('should return custom config', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .send({ query })
+          .expect(200);
+
+        const expectedResponsePayload = {
+          data: {
+            getConfig: {
+              [configOne.key]: configOne.value.data,
+              [configTwo.key]: configTwo.value.data,
+              [configThree.key]: configThree.value.data,
+              disableNotificationsPage: true,
+              disableFavicon: true,
+              additionalDrawerLink: 'https://automatisch.io',
+              additionalDrawerLinkText: 'Automatisch',
             },
           },
         };

packages/backend/src/graphql/queries/get-current-user.test.js

@@ -6,100 +6,74 @@ import { createRole } from '../../../test/factories/role';
 import { createUser } from '../../../test/factories/user';
 
 describe('graphQL getCurrentUser query', () => {
-  describe('with unauthenticated user', () => {
-    it('should throw not authorized error', async () => {
-      const invalidUserToken = 'invalid-token';
+  let role, currentUser, token, requestObject;
 
-      const query = `
-        query {
-          getCurrentUser {
-            id
-            email
-          }
-        }
-      `;
-
-      const response = await request(app)
-        .post('/graphql')
-        .set('Authorization', invalidUserToken)
-        .send({ query })
-        .expect(200);
-
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+  beforeEach(async () => {
+    role = await createRole({
+      key: 'sample',
+      name: 'sample',
     });
+
+    currentUser = await createUser({
+      roleId: role.id,
+    });
+
+    token = createAuthTokenByUserId(currentUser.id);
+    requestObject = request(app).post('/graphql').set('Authorization', token);
   });
 
-  describe('with authenticated user', () => {
-    let role, currentUser, token, requestObject;
-
-    beforeEach(async () => {
-      role = await createRole({
-        key: 'sample',
-        name: 'sample',
-      });
-
-      currentUser = await createUser({
-        roleId: role.id,
-      });
-
-      token = createAuthTokenByUserId(currentUser.id);
-      requestObject = request(app).post('/graphql').set('Authorization', token);
-    });
-
-    it('should return user data', async () => {
-      const query = `
-        query {
-          getCurrentUser {
+  it('should return user data', async () => {
+    const query = `
+      query {
+        getCurrentUser {
+          id
+          email
+          fullName
+          email
+          createdAt
+          updatedAt
+          role {
             id
-            email
-            fullName
-            email
-            createdAt
-            updatedAt
-            role {
-              id
-              name
-            }
+            name
           }
         }
-      `;
+      }
+    `;
 
-      const response = await requestObject.send({ query }).expect(200);
+    const response = await requestObject.send({ query }).expect(200);
 
-      const expectedResponsePayload = {
-        data: {
-          getCurrentUser: {
-            createdAt: currentUser.createdAt.getTime().toString(),
-            email: currentUser.email,
-            fullName: currentUser.fullName,
-            id: currentUser.id,
-            role: { id: role.id, name: role.name },
-            updatedAt: currentUser.updatedAt.getTime().toString(),
-          },
+    const expectedResponsePayload = {
+      data: {
+        getCurrentUser: {
+          createdAt: currentUser.createdAt.getTime().toString(),
+          email: currentUser.email,
+          fullName: currentUser.fullName,
+          id: currentUser.id,
+          role: { id: role.id, name: role.name },
+          updatedAt: currentUser.updatedAt.getTime().toString(),
         },
-      };
+      },
+    };
 
-      expect(response.body).toEqual(expectedResponsePayload);
-    });
+    expect(response.body).toEqual(expectedResponsePayload);
+  });
 
-    it('should not return user password', async () => {
-      const query = `
-        query {
-          getCurrentUser {
-            id
-            email
-            password
-          }
+  it('should not return user password', async () => {
+    const query = `
+      query {
+        getCurrentUser {
+          id
+          email
+          password
         }
-      `;
+      }
+    `;
 
-      const response = await requestObject.send({ query }).expect(400);
+    const response = await requestObject.send({ query }).expect(400);
 
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual(
-        'Cannot query field "password" on type "User".'
-      );
-    });
+    expect(response.body.errors).toBeDefined();
+    expect(response.body.errors[0].message).toEqual(
+      'Cannot query field "password" on type "User".'
+    );
   });
 });

packages/backend/src/graphql/queries/get-executions.test.js

@@ -40,307 +40,291 @@ describe('graphQL getExecutions query', () => {
     }
   `;
 
-  const invalidToken = 'invalid-token';
-
-  describe('with unauthenticated user', () => {
+  describe('and without correct permissions', () => {
     it('should throw not authorized error', async () => {
+      const userWithoutPermissions = await createUser();
+      const token = createAuthTokenByUserId(userWithoutPermissions.id);
+
       const response = await request(app)
         .post('/graphql')
-        .set('Authorization', invalidToken)
+        .set('Authorization', token)
         .send({ query })
         .expect(200);
 
       expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+      expect(response.body.errors[0].message).toEqual('Not authorized!');
     });
   });
 
-  describe('with authenticated user', () => {
-    describe('and without permissions', () => {
-      it('should throw not authorized error', async () => {
-        const userWithoutPermissions = await createUser();
-        const token = createAuthTokenByUserId(userWithoutPermissions.id);
+  describe('and with correct permission', () => {
+    let role,
+      currentUser,
+      anotherUser,
+      token,
+      flowOne,
+      stepOneForFlowOne,
+      stepTwoForFlowOne,
+      executionOne,
+      flowTwo,
+      stepOneForFlowTwo,
+      stepTwoForFlowTwo,
+      executionTwo,
+      flowThree,
+      stepOneForFlowThree,
+      stepTwoForFlowThree,
+      executionThree,
+      expectedResponseForExecutionOne,
+      expectedResponseForExecutionTwo,
+      expectedResponseForExecutionThree;
 
+    beforeEach(async () => {
+      role = await createRole({
+        key: 'sample',
+        name: 'sample',
+      });
+
+      currentUser = await createUser({
+        roleId: role.id,
+        fullName: 'Current User',
+      });
+
+      anotherUser = await createUser();
+
+      token = createAuthTokenByUserId(currentUser.id);
+
+      flowOne = await createFlow({
+        userId: currentUser.id,
+      });
+
+      stepOneForFlowOne = await createStep({
+        flowId: flowOne.id,
+      });
+
+      stepTwoForFlowOne = await createStep({
+        flowId: flowOne.id,
+      });
+
+      executionOne = await createExecution({
+        flowId: flowOne.id,
+      });
+
+      await createExecutionStep({
+        executionId: executionOne.id,
+        stepId: stepOneForFlowOne.id,
+        status: 'success',
+      });
+
+      await createExecutionStep({
+        executionId: executionOne.id,
+        stepId: stepTwoForFlowOne.id,
+        status: 'success',
+      });
+
+      flowTwo = await createFlow({
+        userId: currentUser.id,
+      });
+
+      stepOneForFlowTwo = await createStep({
+        flowId: flowTwo.id,
+      });
+
+      stepTwoForFlowTwo = await createStep({
+        flowId: flowTwo.id,
+      });
+
+      executionTwo = await createExecution({
+        flowId: flowTwo.id,
+      });
+
+      await createExecutionStep({
+        executionId: executionTwo.id,
+        stepId: stepOneForFlowTwo.id,
+        status: 'success',
+      });
+
+      await createExecutionStep({
+        executionId: executionTwo.id,
+        stepId: stepTwoForFlowTwo.id,
+        status: 'failure',
+      });
+
+      flowThree = await createFlow({
+        userId: anotherUser.id,
+      });
+
+      stepOneForFlowThree = await createStep({
+        flowId: flowThree.id,
+      });
+
+      stepTwoForFlowThree = await createStep({
+        flowId: flowThree.id,
+      });
+
+      executionThree = await createExecution({
+        flowId: flowThree.id,
+      });
+
+      await createExecutionStep({
+        executionId: executionThree.id,
+        stepId: stepOneForFlowThree.id,
+        status: 'success',
+      });
+
+      await createExecutionStep({
+        executionId: executionThree.id,
+        stepId: stepTwoForFlowThree.id,
+        status: 'failure',
+      });
+
+      expectedResponseForExecutionOne = {
+        node: {
+          createdAt: executionOne.createdAt.getTime().toString(),
+          flow: {
+            active: flowOne.active,
+            id: flowOne.id,
+            name: flowOne.name,
+            steps: [
+              {
+                iconUrl: `${appConfig.baseUrl}/apps/${stepOneForFlowOne.appKey}/assets/favicon.svg`,
+              },
+              {
+                iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowOne.appKey}/assets/favicon.svg`,
+              },
+            ],
+          },
+          id: executionOne.id,
+          status: 'success',
+          testRun: executionOne.testRun,
+          updatedAt: executionOne.updatedAt.getTime().toString(),
+        },
+      };
+
+      expectedResponseForExecutionTwo = {
+        node: {
+          createdAt: executionTwo.createdAt.getTime().toString(),
+          flow: {
+            active: flowTwo.active,
+            id: flowTwo.id,
+            name: flowTwo.name,
+            steps: [
+              {
+                iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowTwo.appKey}/assets/favicon.svg`,
+              },
+              {
+                iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowTwo.appKey}/assets/favicon.svg`,
+              },
+            ],
+          },
+          id: executionTwo.id,
+          status: 'failure',
+          testRun: executionTwo.testRun,
+          updatedAt: executionTwo.updatedAt.getTime().toString(),
+        },
+      };
+
+      expectedResponseForExecutionThree = {
+        node: {
+          createdAt: executionThree.createdAt.getTime().toString(),
+          flow: {
+            active: flowThree.active,
+            id: flowThree.id,
+            name: flowThree.name,
+            steps: [
+              {
+                iconUrl: `${appConfig.baseUrl}/apps/${stepOneForFlowThree.appKey}/assets/favicon.svg`,
+              },
+              {
+                iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowThree.appKey}/assets/favicon.svg`,
+              },
+            ],
+          },
+          id: executionThree.id,
+          status: 'failure',
+          testRun: executionThree.testRun,
+          updatedAt: executionThree.updatedAt.getTime().toString(),
+        },
+      };
+    });
+
+    describe('and with isCreator condition', () => {
+      beforeEach(async () => {
+        await createPermission({
+          action: 'read',
+          subject: 'Execution',
+          roleId: role.id,
+          conditions: ['isCreator'],
+        });
+      });
+
+      it('should return executions data of the current user', async () => {
         const response = await request(app)
           .post('/graphql')
           .set('Authorization', token)
           .send({ query })
           .expect(200);
 
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
+        const expectedResponsePayload = {
+          data: {
+            getExecutions: {
+              edges: [
+                expectedResponseForExecutionTwo,
+                expectedResponseForExecutionOne,
+              ],
+              pageInfo: { currentPage: 1, totalPages: 1 },
+            },
+          },
+        };
+
+        expect(response.body).toEqual(expectedResponsePayload);
       });
     });
 
-    describe('and with correct permission', () => {
-      let role,
-        currentUser,
-        anotherUser,
-        token,
-        flowOne,
-        stepOneForFlowOne,
-        stepTwoForFlowOne,
-        executionOne,
-        flowTwo,
-        stepOneForFlowTwo,
-        stepTwoForFlowTwo,
-        executionTwo,
-        flowThree,
-        stepOneForFlowThree,
-        stepTwoForFlowThree,
-        executionThree,
-        expectedResponseForExecutionOne,
-        expectedResponseForExecutionTwo,
-        expectedResponseForExecutionThree;
-
+    describe('and without isCreator condition', () => {
       beforeEach(async () => {
-        role = await createRole({
-          key: 'sample',
-          name: 'sample',
-        });
-
-        currentUser = await createUser({
+        await createPermission({
+          action: 'read',
+          subject: 'Execution',
           roleId: role.id,
-          fullName: 'Current User',
-        });
-
-        anotherUser = await createUser();
-
-        token = createAuthTokenByUserId(currentUser.id);
-
-        flowOne = await createFlow({
-          userId: currentUser.id,
-        });
-
-        stepOneForFlowOne = await createStep({
-          flowId: flowOne.id,
-        });
-
-        stepTwoForFlowOne = await createStep({
-          flowId: flowOne.id,
-        });
-
-        executionOne = await createExecution({
-          flowId: flowOne.id,
-        });
-
-        await createExecutionStep({
-          executionId: executionOne.id,
-          stepId: stepOneForFlowOne.id,
-          status: 'success',
-        });
-
-        await createExecutionStep({
-          executionId: executionOne.id,
-          stepId: stepTwoForFlowOne.id,
-          status: 'success',
-        });
-
-        flowTwo = await createFlow({
-          userId: currentUser.id,
-        });
-
-        stepOneForFlowTwo = await createStep({
-          flowId: flowTwo.id,
-        });
-
-        stepTwoForFlowTwo = await createStep({
-          flowId: flowTwo.id,
-        });
-
-        executionTwo = await createExecution({
-          flowId: flowTwo.id,
-        });
-
-        await createExecutionStep({
-          executionId: executionTwo.id,
-          stepId: stepOneForFlowTwo.id,
-          status: 'success',
-        });
-
-        await createExecutionStep({
-          executionId: executionTwo.id,
-          stepId: stepTwoForFlowTwo.id,
-          status: 'failure',
-        });
-
-        flowThree = await createFlow({
-          userId: anotherUser.id,
-        });
-
-        stepOneForFlowThree = await createStep({
-          flowId: flowThree.id,
-        });
-
-        stepTwoForFlowThree = await createStep({
-          flowId: flowThree.id,
-        });
-
-        executionThree = await createExecution({
-          flowId: flowThree.id,
-        });
-
-        await createExecutionStep({
-          executionId: executionThree.id,
-          stepId: stepOneForFlowThree.id,
-          status: 'success',
-        });
-
-        await createExecutionStep({
-          executionId: executionThree.id,
-          stepId: stepTwoForFlowThree.id,
-          status: 'failure',
-        });
-
-        expectedResponseForExecutionOne = {
-          node: {
-            createdAt: executionOne.createdAt.getTime().toString(),
-            flow: {
-              active: flowOne.active,
-              id: flowOne.id,
-              name: flowOne.name,
-              steps: [
-                {
-                  iconUrl: `${appConfig.baseUrl}/apps/${stepOneForFlowOne.appKey}/assets/favicon.svg`,
-                },
-                {
-                  iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowOne.appKey}/assets/favicon.svg`,
-                },
-              ],
-            },
-            id: executionOne.id,
-            status: 'success',
-            testRun: executionOne.testRun,
-            updatedAt: executionOne.updatedAt.getTime().toString(),
-          },
-        };
-
-        expectedResponseForExecutionTwo = {
-          node: {
-            createdAt: executionTwo.createdAt.getTime().toString(),
-            flow: {
-              active: flowTwo.active,
-              id: flowTwo.id,
-              name: flowTwo.name,
-              steps: [
-                {
-                  iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowTwo.appKey}/assets/favicon.svg`,
-                },
-                {
-                  iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowTwo.appKey}/assets/favicon.svg`,
-                },
-              ],
-            },
-            id: executionTwo.id,
-            status: 'failure',
-            testRun: executionTwo.testRun,
-            updatedAt: executionTwo.updatedAt.getTime().toString(),
-          },
-        };
-
-        expectedResponseForExecutionThree = {
-          node: {
-            createdAt: executionThree.createdAt.getTime().toString(),
-            flow: {
-              active: flowThree.active,
-              id: flowThree.id,
-              name: flowThree.name,
-              steps: [
-                {
-                  iconUrl: `${appConfig.baseUrl}/apps/${stepOneForFlowThree.appKey}/assets/favicon.svg`,
-                },
-                {
-                  iconUrl: `${appConfig.baseUrl}/apps/${stepTwoForFlowThree.appKey}/assets/favicon.svg`,
-                },
-              ],
-            },
-            id: executionThree.id,
-            status: 'failure',
-            testRun: executionThree.testRun,
-            updatedAt: executionThree.updatedAt.getTime().toString(),
-          },
-        };
-      });
-
-      describe('and with isCreator condition', () => {
-        beforeEach(async () => {
-          await createPermission({
-            action: 'read',
-            subject: 'Execution',
-            roleId: role.id,
-            conditions: ['isCreator'],
-          });
-        });
-
-        it('should return executions data of the current user', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getExecutions: {
-                edges: [
-                  expectedResponseForExecutionTwo,
-                  expectedResponseForExecutionOne,
-                ],
-                pageInfo: { currentPage: 1, totalPages: 1 },
-              },
-            },
-          };
-
-          expect(response.body).toEqual(expectedResponsePayload);
+          conditions: [],
         });
       });
 
-      describe('and without isCreator condition', () => {
-        beforeEach(async () => {
-          await createPermission({
-            action: 'read',
-            subject: 'Execution',
-            roleId: role.id,
-            conditions: [],
-          });
-        });
+      it('should return executions data of all users', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query })
+          .expect(200);
 
-        it('should return executions data of all users', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getExecutions: {
-                edges: [
-                  expectedResponseForExecutionThree,
-                  expectedResponseForExecutionTwo,
-                  expectedResponseForExecutionOne,
-                ],
-                pageInfo: { currentPage: 1, totalPages: 1 },
-              },
+        const expectedResponsePayload = {
+          data: {
+            getExecutions: {
+              edges: [
+                expectedResponseForExecutionThree,
+                expectedResponseForExecutionTwo,
+                expectedResponseForExecutionOne,
+              ],
+              pageInfo: { currentPage: 1, totalPages: 1 },
             },
-          };
+          },
+        };
 
-          expect(response.body).toEqual(expectedResponsePayload);
+        expect(response.body).toEqual(expectedResponsePayload);
+      });
+    });
+
+    describe('and with filters', () => {
+      beforeEach(async () => {
+        await createPermission({
+          action: 'read',
+          subject: 'Execution',
+          roleId: role.id,
+          conditions: [],
         });
       });
 
-      describe('and with filters', () => {
-        beforeEach(async () => {
-          await createPermission({
-            action: 'read',
-            subject: 'Execution',
-            roleId: role.id,
-            conditions: [],
-          });
-        });
-
-        it('should return executions data for the specified flow', async () => {
-          const query = `
+      it('should return executions data for the specified flow', async () => {
+        const query = `
             query {
               getExecutions(limit: 10, offset: 0, filters: { flowId: "${flowOne.id}" }) {
                 pageInfo {
@@ -368,26 +352,26 @@ describe('graphQL getExecutions query', () => {
             }
           `;
 
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query })
-            .expect(200);
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query })
+          .expect(200);
 
-          const expectedResponsePayload = {
-            data: {
-              getExecutions: {
-                edges: [expectedResponseForExecutionOne],
-                pageInfo: { currentPage: 1, totalPages: 1 },
-              },
+        const expectedResponsePayload = {
+          data: {
+            getExecutions: {
+              edges: [expectedResponseForExecutionOne],
+              pageInfo: { currentPage: 1, totalPages: 1 },
             },
-          };
+          },
+        };
 
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
+        expect(response.body).toEqual(expectedResponsePayload);
+      });
 
-        it('should return only executions data with success status', async () => {
-          const query = `
+      it('should return only executions data with success status', async () => {
+        const query = `
             query {
               getExecutions(limit: 10, offset: 0, filters: { status: "success" }) {
                 pageInfo {
@@ -415,30 +399,30 @@ describe('graphQL getExecutions query', () => {
             }
           `;
 
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query })
-            .expect(200);
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query })
+          .expect(200);
 
-          const expectedResponsePayload = {
-            data: {
-              getExecutions: {
-                edges: [expectedResponseForExecutionOne],
-                pageInfo: { currentPage: 1, totalPages: 1 },
-              },
+        const expectedResponsePayload = {
+          data: {
+            getExecutions: {
+              edges: [expectedResponseForExecutionOne],
+              pageInfo: { currentPage: 1, totalPages: 1 },
             },
-          };
+          },
+        };
 
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
+        expect(response.body).toEqual(expectedResponsePayload);
+      });
 
-        it('should return only executions data within date range', async () => {
-          const createdAtFrom = executionOne.createdAt.getTime().toString();
+      it('should return only executions data within date range', async () => {
+        const createdAtFrom = executionOne.createdAt.getTime().toString();
 
-          const createdAtTo = executionOne.createdAt.getTime().toString();
+        const createdAtTo = executionOne.createdAt.getTime().toString();
 
-          const query = `
+        const query = `
             query {
               getExecutions(limit: 10, offset: 0, filters: { createdAt: { from: "${createdAtFrom}", to: "${createdAtTo}" }}) {
                 pageInfo {
@@ -466,23 +450,22 @@ describe('graphQL getExecutions query', () => {
             }
           `;
 
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query })
-            .expect(200);
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query })
+          .expect(200);
 
-          const expectedResponsePayload = {
-            data: {
-              getExecutions: {
-                edges: [expectedResponseForExecutionOne],
-                pageInfo: { currentPage: 1, totalPages: 1 },
-              },
+        const expectedResponsePayload = {
+          data: {
+            getExecutions: {
+              edges: [expectedResponseForExecutionOne],
+              pageInfo: { currentPage: 1, totalPages: 1 },
             },
-          };
+          },
+        };
 
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
+        expect(response.body).toEqual(expectedResponsePayload);
       });
     });
   });

packages/backend/src/graphql/queries/get-flow.test.js

@@ -40,222 +40,200 @@ describe('graphQL getFlow query', () => {
     `;
   };
 
-  describe('with unauthenticated user', () => {
+  describe('and without permissions', () => {
     it('should throw not authorized error', async () => {
-      const invalidToken = 'invalid-token';
+      const userWithoutPermissions = await createUser();
+      const token = createAuthTokenByUserId(userWithoutPermissions.id);
       const flow = await createFlow();
 
       const response = await request(app)
         .post('/graphql')
-        .set('Authorization', invalidToken)
+        .set('Authorization', token)
         .send({ query: query(flow.id) })
         .expect(200);
 
       expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+      expect(response.body.errors[0].message).toEqual('Not authorized!');
     });
   });
 
-  describe('with authenticated user', () => {
-    describe('and without permissions', () => {
-      it('should throw not authorized error', async () => {
-        const userWithoutPermissions = await createUser();
-        const token = createAuthTokenByUserId(userWithoutPermissions.id);
-        const flow = await createFlow();
+  describe('and with correct permission', () => {
+    let currentUser, currentUserRole, currentUserFlow;
+
+    beforeEach(async () => {
+      currentUserRole = await createRole();
+      currentUser = await createUser({ roleId: currentUserRole.id });
+      currentUserFlow = await createFlow({ userId: currentUser.id });
+    });
+
+    describe('and with isCreator condition', () => {
+      it('should return executions data of the current user', async () => {
+        await createPermission({
+          action: 'read',
+          subject: 'Flow',
+          roleId: currentUserRole.id,
+          conditions: ['isCreator'],
+        });
+
+        const triggerStep = await createStep({
+          flowId: currentUserFlow.id,
+          type: 'trigger',
+          key: 'catchRawWebhook',
+          webhookPath: `/webhooks/flows/${currentUserFlow.id}`,
+        });
+
+        const actionConnection = await createConnection({
+          userId: currentUser.id,
+          formattedData: {
+            screenName: 'Test',
+            authenticationKey: 'test key',
+          },
+        });
+
+        const actionStep = await createStep({
+          flowId: currentUserFlow.id,
+          type: 'action',
+          connectionId: actionConnection.id,
+          key: 'translateText',
+        });
+
+        const token = createAuthTokenByUserId(currentUser.id);
 
         const response = await request(app)
           .post('/graphql')
           .set('Authorization', token)
-          .send({ query: query(flow.id) })
+          .send({ query: query(currentUserFlow.id) })
           .expect(200);
 
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
+        const expectedResponsePayload = {
+          data: {
+            getFlow: {
+              active: currentUserFlow.active,
+              id: currentUserFlow.id,
+              name: currentUserFlow.name,
+              status: 'draft',
+              steps: [
+                {
+                  appKey: triggerStep.appKey,
+                  connection: null,
+                  iconUrl: `${appConfig.baseUrl}/apps/${triggerStep.appKey}/assets/favicon.svg`,
+                  id: triggerStep.id,
+                  key: 'catchRawWebhook',
+                  parameters: {},
+                  position: 1,
+                  status: triggerStep.status,
+                  type: 'trigger',
+                  webhookUrl: `${appConfig.baseUrl}/webhooks/flows/${currentUserFlow.id}`,
+                },
+                {
+                  appKey: actionStep.appKey,
+                  connection: {
+                    createdAt: actionConnection.createdAt.getTime().toString(),
+                    id: actionConnection.id,
+                    verified: actionConnection.verified,
+                  },
+                  iconUrl: `${appConfig.baseUrl}/apps/${actionStep.appKey}/assets/favicon.svg`,
+                  id: actionStep.id,
+                  key: 'translateText',
+                  parameters: {},
+                  position: 1,
+                  status: actionStep.status,
+                  type: 'action',
+                  webhookUrl: 'http://localhost:3000/null',
+                },
+              ],
+            },
+          },
+        };
+
+        expect(response.body).toEqual(expectedResponsePayload);
       });
     });
 
-    describe('and with correct permission', () => {
-      let currentUser, currentUserRole, currentUserFlow;
-
-      beforeEach(async () => {
-        currentUserRole = await createRole();
-        currentUser = await createUser({ roleId: currentUserRole.id });
-        currentUserFlow = await createFlow({ userId: currentUser.id });
-      });
-
-      describe('and with isCreator condition', () => {
-        it('should return executions data of the current user', async () => {
-          await createPermission({
-            action: 'read',
-            subject: 'Flow',
-            roleId: currentUserRole.id,
-            conditions: ['isCreator'],
-          });
-
-          const triggerStep = await createStep({
-            flowId: currentUserFlow.id,
-            type: 'trigger',
-            key: 'catchRawWebhook',
-            webhookPath: `/webhooks/flows/${currentUserFlow.id}`,
-          });
-
-          const actionConnection = await createConnection({
-            userId: currentUser.id,
-            formattedData: {
-              screenName: 'Test',
-              authenticationKey: 'test key',
-            },
-          });
-
-          const actionStep = await createStep({
-            flowId: currentUserFlow.id,
-            type: 'action',
-            connectionId: actionConnection.id,
-            key: 'translateText',
-          });
-
-          const token = createAuthTokenByUserId(currentUser.id);
-
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query: query(currentUserFlow.id) })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getFlow: {
-                active: currentUserFlow.active,
-                id: currentUserFlow.id,
-                name: currentUserFlow.name,
-                status: 'draft',
-                steps: [
-                  {
-                    appKey: triggerStep.appKey,
-                    connection: null,
-                    iconUrl: `${appConfig.baseUrl}/apps/${triggerStep.appKey}/assets/favicon.svg`,
-                    id: triggerStep.id,
-                    key: 'catchRawWebhook',
-                    parameters: {},
-                    position: 1,
-                    status: triggerStep.status,
-                    type: 'trigger',
-                    webhookUrl: `${appConfig.baseUrl}/webhooks/flows/${currentUserFlow.id}`,
-                  },
-                  {
-                    appKey: actionStep.appKey,
-                    connection: {
-                      createdAt: actionConnection.createdAt
-                        .getTime()
-                        .toString(),
-                      id: actionConnection.id,
-                      verified: actionConnection.verified,
-                    },
-                    iconUrl: `${appConfig.baseUrl}/apps/${actionStep.appKey}/assets/favicon.svg`,
-                    id: actionStep.id,
-                    key: 'translateText',
-                    parameters: {},
-                    position: 1,
-                    status: actionStep.status,
-                    type: 'action',
-                    webhookUrl: 'http://localhost:3000/null',
-                  },
-                ],
-              },
-            },
-          };
-
-          expect(response.body).toEqual(expectedResponsePayload);
+    describe('and without isCreator condition', () => {
+      it('should return executions data of all users', async () => {
+        await createPermission({
+          action: 'read',
+          subject: 'Flow',
+          roleId: currentUserRole.id,
+          conditions: [],
         });
-      });
 
-      describe('and without isCreator condition', () => {
-        it('should return executions data of all users', async () => {
-          await createPermission({
-            action: 'read',
-            subject: 'Flow',
-            roleId: currentUserRole.id,
-            conditions: [],
-          });
+        const anotherUser = await createUser();
+        const anotherUserFlow = await createFlow({ userId: anotherUser.id });
 
-          const anotherUser = await createUser();
-          const anotherUserFlow = await createFlow({ userId: anotherUser.id });
-
-          const triggerStep = await createStep({
-            flowId: anotherUserFlow.id,
-            type: 'trigger',
-            key: 'catchRawWebhook',
-            webhookPath: `/webhooks/flows/${anotherUserFlow.id}`,
-          });
-
-          const actionConnection = await createConnection({
-            userId: anotherUser.id,
-            formattedData: {
-              screenName: 'Test',
-              authenticationKey: 'test key',
-            },
-          });
-
-          const actionStep = await createStep({
-            flowId: anotherUserFlow.id,
-            type: 'action',
-            connectionId: actionConnection.id,
-            key: 'translateText',
-          });
-
-          const token = createAuthTokenByUserId(currentUser.id);
-
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', token)
-            .send({ query: query(anotherUserFlow.id) })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getFlow: {
-                active: anotherUserFlow.active,
-                id: anotherUserFlow.id,
-                name: anotherUserFlow.name,
-                status: 'draft',
-                steps: [
-                  {
-                    appKey: triggerStep.appKey,
-                    connection: null,
-                    iconUrl: `${appConfig.baseUrl}/apps/${triggerStep.appKey}/assets/favicon.svg`,
-                    id: triggerStep.id,
-                    key: 'catchRawWebhook',
-                    parameters: {},
-                    position: 1,
-                    status: triggerStep.status,
-                    type: 'trigger',
-                    webhookUrl: `${appConfig.baseUrl}/webhooks/flows/${anotherUserFlow.id}`,
-                  },
-                  {
-                    appKey: actionStep.appKey,
-                    connection: {
-                      createdAt: actionConnection.createdAt
-                        .getTime()
-                        .toString(),
-                      id: actionConnection.id,
-                      verified: actionConnection.verified,
-                    },
-                    iconUrl: `${appConfig.baseUrl}/apps/${actionStep.appKey}/assets/favicon.svg`,
-                    id: actionStep.id,
-                    key: 'translateText',
-                    parameters: {},
-                    position: 1,
-                    status: actionStep.status,
-                    type: 'action',
-                    webhookUrl: 'http://localhost:3000/null',
-                  },
-                ],
-              },
-            },
-          };
-
-          expect(response.body).toEqual(expectedResponsePayload);
+        const triggerStep = await createStep({
+          flowId: anotherUserFlow.id,
+          type: 'trigger',
+          key: 'catchRawWebhook',
+          webhookPath: `/webhooks/flows/${anotherUserFlow.id}`,
         });
+
+        const actionConnection = await createConnection({
+          userId: anotherUser.id,
+          formattedData: {
+            screenName: 'Test',
+            authenticationKey: 'test key',
+          },
+        });
+
+        const actionStep = await createStep({
+          flowId: anotherUserFlow.id,
+          type: 'action',
+          connectionId: actionConnection.id,
+          key: 'translateText',
+        });
+
+        const token = createAuthTokenByUserId(currentUser.id);
+
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', token)
+          .send({ query: query(anotherUserFlow.id) })
+          .expect(200);
+
+        const expectedResponsePayload = {
+          data: {
+            getFlow: {
+              active: anotherUserFlow.active,
+              id: anotherUserFlow.id,
+              name: anotherUserFlow.name,
+              status: 'draft',
+              steps: [
+                {
+                  appKey: triggerStep.appKey,
+                  connection: null,
+                  iconUrl: `${appConfig.baseUrl}/apps/${triggerStep.appKey}/assets/favicon.svg`,
+                  id: triggerStep.id,
+                  key: 'catchRawWebhook',
+                  parameters: {},
+                  position: 1,
+                  status: triggerStep.status,
+                  type: 'trigger',
+                  webhookUrl: `${appConfig.baseUrl}/webhooks/flows/${anotherUserFlow.id}`,
+                },
+                {
+                  appKey: actionStep.appKey,
+                  connection: {
+                    createdAt: actionConnection.createdAt.getTime().toString(),
+                    id: actionConnection.id,
+                    verified: actionConnection.verified,
+                  },
+                  iconUrl: `${appConfig.baseUrl}/apps/${actionStep.appKey}/assets/favicon.svg`,
+                  id: actionStep.id,
+                  key: 'translateText',
+                  parameters: {},
+                  position: 1,
+                  status: actionStep.status,
+                  type: 'action',
+                  webhookUrl: 'http://localhost:3000/null',
+                },
+              ],
+            },
+          },
+        };
+
+        expect(response.body).toEqual(expectedResponsePayload);
       });
     });
   });

packages/backend/src/graphql/queries/get-role.ee.test.js

@@ -17,7 +17,6 @@ describe('graphQL getRole query', () => {
     userWithoutPermissions,
     tokenWithPermissions,
     tokenWithoutPermissions,
-    invalidToken,
     permissionOne,
     permissionTwo;
 
@@ -74,108 +73,91 @@ describe('graphQL getRole query', () => {
     tokenWithoutPermissions = createAuthTokenByUserId(
       userWithoutPermissions.id
     );
-
-    invalidToken = 'invalid-token';
   });
 
-  describe('with unauthenticated user', () => {
-    it('should throw not authorized error', async () => {
-      const response = await request(app)
-        .post('/graphql')
-        .set('Authorization', invalidToken)
-        .send({ query: queryWithValidRole })
-        .expect(200);
-
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+  describe('and with valid license', () => {
+    beforeEach(async () => {
+      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
     });
-  });
 
-  describe('with authenticated user', () => {
-    describe('and with valid license', () => {
-      beforeEach(async () => {
-        vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+    describe('and without permissions', () => {
+      it('should throw not authorized error', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithoutPermissions)
+          .send({ query: queryWithValidRole })
+          .expect(200);
+
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('Not authorized!');
       });
+    });
 
-      describe('and without permissions', () => {
-        it('should throw not authorized error', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithoutPermissions)
-            .send({ query: queryWithValidRole })
-            .expect(200);
+    describe('and correct permissions', () => {
+      it('should return role data for a valid role id', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithPermissions)
+          .send({ query: queryWithValidRole })
+          .expect(200);
 
-          expect(response.body.errors).toBeDefined();
-          expect(response.body.errors[0].message).toEqual('Not authorized!');
-        });
-      });
-
-      describe('and correct permissions', () => {
-        it('should return role data for a valid role id', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithPermissions)
-            .send({ query: queryWithValidRole })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getRole: {
-                description: validRole.description,
-                id: validRole.id,
-                isAdmin: validRole.key === 'admin',
-                key: validRole.key,
-                name: validRole.name,
-                permissions: [
-                  {
-                    action: permissionOne.action,
-                    conditions: permissionOne.conditions,
-                    id: permissionOne.id,
-                    subject: permissionOne.subject,
-                  },
-                  {
-                    action: permissionTwo.action,
-                    conditions: permissionTwo.conditions,
-                    id: permissionTwo.id,
-                    subject: permissionTwo.subject,
-                  },
-                ],
-              },
+        const expectedResponsePayload = {
+          data: {
+            getRole: {
+              description: validRole.description,
+              id: validRole.id,
+              isAdmin: validRole.key === 'admin',
+              key: validRole.key,
+              name: validRole.name,
+              permissions: [
+                {
+                  action: permissionOne.action,
+                  conditions: permissionOne.conditions,
+                  id: permissionOne.id,
+                  subject: permissionOne.subject,
+                },
+                {
+                  action: permissionTwo.action,
+                  conditions: permissionTwo.conditions,
+                  id: permissionTwo.id,
+                  subject: permissionTwo.subject,
+                },
+              ],
             },
-          };
+          },
+        };
 
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
+        expect(response.body).toEqual(expectedResponsePayload);
+      });
 
-        it('should return not found for invalid role id', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithPermissions)
-            .send({ query: queryWithInvalidRole })
-            .expect(200);
+      it('should return not found for invalid role id', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithPermissions)
+          .send({ query: queryWithInvalidRole })
+          .expect(200);
 
-          expect(response.body.errors).toBeDefined();
-          expect(response.body.errors[0].message).toEqual('NotFoundError');
-        });
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('NotFoundError');
       });
     });
+  });
 
-    describe('and without valid license', () => {
-      beforeEach(async () => {
-        vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
-      });
+  describe('and without valid license', () => {
+    beforeEach(async () => {
+      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
+    });
 
-      describe('and correct permissions', () => {
-        it('should throw not authorized error', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithPermissions)
-            .send({ query: queryWithInvalidRole })
-            .expect(200);
+    describe('and correct permissions', () => {
+      it('should throw not authorized error', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithPermissions)
+          .send({ query: queryWithInvalidRole })
+          .expect(200);
 
-          expect(response.body.errors).toBeDefined();
-          expect(response.body.errors[0].message).toEqual('Not authorized!');
-        });
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('Not authorized!');
       });
     });
   });

packages/backend/src/graphql/queries/get-roles.ee.test.js

@@ -15,8 +15,7 @@ describe('graphQL getRoles query', () => {
     userWithPermissions,
     userWithoutPermissions,
     tokenWithPermissions,
-    tokenWithoutPermissions,
-    invalidToken;
+    tokenWithoutPermissions;
 
   beforeEach(async () => {
     currentUserRole = await createRole({ name: 'Current user role' });
@@ -53,99 +52,82 @@ describe('graphQL getRoles query', () => {
     tokenWithoutPermissions = createAuthTokenByUserId(
       userWithoutPermissions.id
     );
-
-    invalidToken = 'invalid-token';
   });
 
-  describe('with unauthenticated user', () => {
-    it('should throw not authorized error', async () => {
-      const response = await request(app)
-        .post('/graphql')
-        .set('Authorization', invalidToken)
-        .send({ query })
-        .expect(200);
-
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+  describe('and with valid license', () => {
+    beforeEach(async () => {
+      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
     });
-  });
 
-  describe('with authenticated user', () => {
-    describe('and with valid license', () => {
-      beforeEach(async () => {
-        vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
-      });
+    describe('and without permissions', () => {
+      it('should throw not authorized error', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithoutPermissions)
+          .send({ query })
+          .expect(200);
 
-      describe('and without permissions', () => {
-        it('should throw not authorized error', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithoutPermissions)
-            .send({ query })
-            .expect(200);
-
-          expect(response.body.errors).toBeDefined();
-          expect(response.body.errors[0].message).toEqual('Not authorized!');
-        });
-      });
-
-      describe('and correct permissions', () => {
-        it('should return roles data', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithPermissions)
-            .send({ query })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getRoles: [
-                {
-                  description: currentUserRole.description,
-                  id: currentUserRole.id,
-                  isAdmin: currentUserRole.key === 'admin',
-                  key: currentUserRole.key,
-                  name: currentUserRole.name,
-                },
-                {
-                  description: roleOne.description,
-                  id: roleOne.id,
-                  isAdmin: roleOne.key === 'admin',
-                  key: roleOne.key,
-                  name: roleOne.name,
-                },
-                {
-                  description: roleSecond.description,
-                  id: roleSecond.id,
-                  isAdmin: roleSecond.key === 'admin',
-                  key: roleSecond.key,
-                  name: roleSecond.name,
-                },
-              ],
-            },
-          };
-
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('Not authorized!');
       });
     });
 
-    describe('and without valid license', () => {
-      beforeEach(async () => {
-        vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
+    describe('and correct permissions', () => {
+      it('should return roles data', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithPermissions)
+          .send({ query })
+          .expect(200);
+
+        const expectedResponsePayload = {
+          data: {
+            getRoles: [
+              {
+                description: currentUserRole.description,
+                id: currentUserRole.id,
+                isAdmin: currentUserRole.key === 'admin',
+                key: currentUserRole.key,
+                name: currentUserRole.name,
+              },
+              {
+                description: roleOne.description,
+                id: roleOne.id,
+                isAdmin: roleOne.key === 'admin',
+                key: roleOne.key,
+                name: roleOne.name,
+              },
+              {
+                description: roleSecond.description,
+                id: roleSecond.id,
+                isAdmin: roleSecond.key === 'admin',
+                key: roleSecond.key,
+                name: roleSecond.name,
+              },
+            ],
+          },
+        };
+
+        expect(response.body).toEqual(expectedResponsePayload);
       });
+    });
+  });
 
-      describe('and correct permissions', () => {
-        it('should throw not authorized error', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', tokenWithPermissions)
-            .send({ query })
-            .expect(200);
+  describe('and without valid license', () => {
+    beforeEach(async () => {
+      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
+    });
 
-          expect(response.body.errors).toBeDefined();
-          expect(response.body.errors[0].message).toEqual('Not authorized!');
-        });
+    describe('and correct permissions', () => {
+      it('should throw not authorized error', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', tokenWithPermissions)
+          .send({ query })
+          .expect(200);
+
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('Not authorized!');
       });
     });
   });

packages/backend/src/graphql/queries/get-trial-status.ee.test.js

@@ -16,34 +16,46 @@ describe('graphQL getTrialStatus query', () => {
     }
   `;
 
-  const invalidToken = 'invalid-token';
+  let user, userToken;
 
-  describe('with unauthenticated user', () => {
-    it('should throw not authorized error', async () => {
+  beforeEach(async () => {
+    const trialExpiryDate = DateTime.now().plus({ days: 30 }).toISODate();
+
+    user = await createUser({ trialExpiryDate });
+    userToken = createAuthTokenByUserId(user.id);
+  });
+
+  describe('and with cloud flag disabled', () => {
+    beforeEach(async () => {
+      vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(false);
+    });
+
+    it('should return null', async () => {
       const response = await request(app)
         .post('/graphql')
-        .set('Authorization', invalidToken)
+        .set('Authorization', userToken)
         .send({ query })
         .expect(200);
 
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+      const expectedResponsePayload = {
+        data: { getTrialStatus: null },
+      };
+
+      expect(response.body).toEqual(expectedResponsePayload);
     });
   });
 
-  describe('with authenticated user', () => {
-    let user, userToken;
-
+  describe('and with cloud flag enabled', () => {
     beforeEach(async () => {
-      const trialExpiryDate = DateTime.now().plus({ days: 30 }).toISODate();
-
-      user = await createUser({ trialExpiryDate });
-      userToken = createAuthTokenByUserId(user.id);
+      vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
     });
 
-    describe('and with cloud flag disabled', () => {
+    describe('and not in trial and has active subscription', () => {
       beforeEach(async () => {
-        vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(false);
+        vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(false);
+        vi.spyOn(User.prototype, 'hasActiveSubscription').mockResolvedValue(
+          true
+        );
       });
 
       it('should return null', async () => {
@@ -61,56 +73,27 @@ describe('graphQL getTrialStatus query', () => {
       });
     });
 
-    describe('and with cloud flag enabled', () => {
+    describe('and in trial period', () => {
       beforeEach(async () => {
-        vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
+        vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(true);
       });
 
-      describe('and not in trial and has active subscription', () => {
-        beforeEach(async () => {
-          vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(false);
-          vi.spyOn(User.prototype, 'hasActiveSubscription').mockResolvedValue(
-            true
-          );
-        });
+      it('should return null', async () => {
+        const response = await request(app)
+          .post('/graphql')
+          .set('Authorization', userToken)
+          .send({ query })
+          .expect(200);
 
-        it('should return null', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', userToken)
-            .send({ query })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: { getTrialStatus: null },
-          };
-
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
-      });
-
-      describe('and in trial period', () => {
-        beforeEach(async () => {
-          vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(true);
-        });
-
-        it('should return null', async () => {
-          const response = await request(app)
-            .post('/graphql')
-            .set('Authorization', userToken)
-            .send({ query })
-            .expect(200);
-
-          const expectedResponsePayload = {
-            data: {
-              getTrialStatus: {
-                expireAt: new Date(user.trialExpiryDate).getTime().toString(),
-              },
+        const expectedResponsePayload = {
+          data: {
+            getTrialStatus: {
+              expireAt: new Date(user.trialExpiryDate).getTime().toString(),
             },
-          };
+          },
+        };
 
-          expect(response.body).toEqual(expectedResponsePayload);
-        });
+        expect(response.body).toEqual(expectedResponsePayload);
       });
     });
   });

packages/backend/src/graphql/queries/get-user.test.js

@@ -8,37 +8,12 @@ import { createPermission } from '../../../test/factories/permission';
 import { createUser } from '../../../test/factories/user';
 
 describe('graphQL getUser query', () => {
-  describe('with unauthenticated user', () => {
+  describe('and without permissions', () => {
     it('should throw not authorized error', async () => {
-      const invalidUserId = '123123123';
+      const userWithoutPermissions = await createUser();
+      const anotherUser = await createUser();
 
       const query = `
-        query {
-          getUser(id: "${invalidUserId}") {
-            id
-            email
-          }
-        }
-      `;
-
-      const response = await request(app)
-        .post('/graphql')
-        .set('Authorization', 'invalid-token')
-        .send({ query })
-        .expect(200);
-
-      expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
-    });
-  });
-
-  describe('with authenticated user', () => {
-    describe('and without permissions', () => {
-      it('should throw not authorized error', async () => {
-        const userWithoutPermissions = await createUser();
-        const anotherUser = await createUser();
-
-        const query = `
           query {
             getUser(id: "${anotherUser.id}") {
               id
@@ -47,50 +22,48 @@ describe('graphQL getUser query', () => {
           }
         `;
 
-        const token = createAuthTokenByUserId(userWithoutPermissions.id);
+      const token = createAuthTokenByUserId(userWithoutPermissions.id);
 
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', token)
-          .send({ query })
-          .expect(200);
+      const response = await request(app)
+        .post('/graphql')
+        .set('Authorization', token)
+        .send({ query })
+        .expect(200);
 
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors[0].message).toEqual('Not authorized!');
+    });
+  });
+
+  describe('and correct permissions', () => {
+    let role, currentUser, anotherUser, token, requestObject;
+
+    beforeEach(async () => {
+      role = await createRole({
+        key: 'sample',
+        name: 'sample',
       });
+
+      await createPermission({
+        action: 'read',
+        subject: 'User',
+        roleId: role.id,
+      });
+
+      currentUser = await createUser({
+        roleId: role.id,
+      });
+
+      anotherUser = await createUser({
+        roleId: role.id,
+      });
+
+      token = createAuthTokenByUserId(currentUser.id);
+      requestObject = request(app).post('/graphql').set('Authorization', token);
     });
 
-    describe('and correct permissions', () => {
-      let role, currentUser, anotherUser, token, requestObject;
-
-      beforeEach(async () => {
-        role = await createRole({
-          key: 'sample',
-          name: 'sample',
-        });
-
-        await createPermission({
-          action: 'read',
-          subject: 'User',
-          roleId: role.id,
-        });
-
-        currentUser = await createUser({
-          roleId: role.id,
-        });
-
-        anotherUser = await createUser({
-          roleId: role.id,
-        });
-
-        token = createAuthTokenByUserId(currentUser.id);
-        requestObject = request(app)
-          .post('/graphql')
-          .set('Authorization', token);
-      });
-
-      it('should return user data for a valid user id', async () => {
-        const query = `
+    it('should return user data for a valid user id', async () => {
+      const query = `
           query {
             getUser(id: "${anotherUser.id}") {
               id
@@ -107,26 +80,26 @@ describe('graphQL getUser query', () => {
           }
         `;
 
-        const response = await requestObject.send({ query }).expect(200);
+      const response = await requestObject.send({ query }).expect(200);
 
-        const expectedResponsePayload = {
-          data: {
-            getUser: {
-              createdAt: anotherUser.createdAt.getTime().toString(),
-              email: anotherUser.email,
-              fullName: anotherUser.fullName,
-              id: anotherUser.id,
-              role: { id: role.id, name: role.name },
-              updatedAt: anotherUser.updatedAt.getTime().toString(),
-            },
+      const expectedResponsePayload = {
+        data: {
+          getUser: {
+            createdAt: anotherUser.createdAt.getTime().toString(),
+            email: anotherUser.email,
+            fullName: anotherUser.fullName,
+            id: anotherUser.id,
+            role: { id: role.id, name: role.name },
+            updatedAt: anotherUser.updatedAt.getTime().toString(),
           },
-        };
+        },
+      };
 
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
+      expect(response.body).toEqual(expectedResponsePayload);
+    });
 
-      it('should not return user password for a valid user id', async () => {
-        const query = `
+    it('should not return user password for a valid user id', async () => {
+      const query = `
           query {
             getUser(id: "${anotherUser.id}") {
               id
@@ -136,18 +109,18 @@ describe('graphQL getUser query', () => {
           }
         `;
 
-        const response = await requestObject.send({ query }).expect(400);
+      const response = await requestObject.send({ query }).expect(400);
 
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual(
-          'Cannot query field "password" on type "User".'
-        );
-      });
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors[0].message).toEqual(
+        'Cannot query field "password" on type "User".'
+      );
+    });
 
-      it('should return not found for invalid user id', async () => {
-        const invalidUserId = Crypto.randomUUID();
+    it('should return not found for invalid user id', async () => {
+      const invalidUserId = Crypto.randomUUID();
 
-        const query = `
+      const query = `
           query {
             getUser(id: "${invalidUserId}") {
               id
@@ -164,11 +137,10 @@ describe('graphQL getUser query', () => {
           }
         `;
 
-        const response = await requestObject.send({ query }).expect(200);
+      const response = await requestObject.send({ query }).expect(200);
 
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('NotFoundError');
-      });
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors[0].message).toEqual('NotFoundError');
     });
   });
 });

packages/backend/src/graphql/queries/get-users.test.js

@@ -30,111 +30,95 @@ describe('graphQL getUsers query', () => {
     }
   `;
 
-  describe('with unauthenticated user', () => {
+  describe('and without permissions', () => {
     it('should throw not authorized error', async () => {
+      const userWithoutPermissions = await createUser();
+      const token = createAuthTokenByUserId(userWithoutPermissions.id);
+
       const response = await request(app)
         .post('/graphql')
-        .set('Authorization', 'invalid-token')
+        .set('Authorization', token)
         .send({ query })
         .expect(200);
 
       expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not Authorised!');
+      expect(response.body.errors[0].message).toEqual('Not authorized!');
     });
   });
 
-  describe('with authenticated user', () => {
-    describe('and without permissions', () => {
-      it('should throw not authorized error', async () => {
-        const userWithoutPermissions = await createUser();
-        const token = createAuthTokenByUserId(userWithoutPermissions.id);
+  describe('and with correct permissions', () => {
+    let role, currentUser, anotherUser, token, requestObject;
 
-        const response = await request(app)
-          .post('/graphql')
-          .set('Authorization', token)
-          .send({ query })
-          .expect(200);
-
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
+    beforeEach(async () => {
+      role = await createRole({
+        key: 'sample',
+        name: 'sample',
       });
+
+      await createPermission({
+        action: 'read',
+        subject: 'User',
+        roleId: role.id,
+      });
+
+      currentUser = await createUser({
+        roleId: role.id,
+        fullName: 'Current User',
+      });
+
+      anotherUser = await createUser({
+        roleId: role.id,
+        fullName: 'Another User',
+      });
+
+      token = createAuthTokenByUserId(currentUser.id);
+      requestObject = request(app).post('/graphql').set('Authorization', token);
     });
 
-    describe('and with correct permissions', () => {
-      let role, currentUser, anotherUser, token, requestObject;
+    it('should return users data', async () => {
+      const response = await requestObject.send({ query }).expect(200);
 
-      beforeEach(async () => {
-        role = await createRole({
-          key: 'sample',
-          name: 'sample',
-        });
-
-        await createPermission({
-          action: 'read',
-          subject: 'User',
-          roleId: role.id,
-        });
-
-        currentUser = await createUser({
-          roleId: role.id,
-          fullName: 'Current User',
-        });
-
-        anotherUser = await createUser({
-          roleId: role.id,
-          fullName: 'Another User',
-        });
-
-        token = createAuthTokenByUserId(currentUser.id);
-        requestObject = request(app)
-          .post('/graphql')
-          .set('Authorization', token);
-      });
-
-      it('should return users data', async () => {
-        const response = await requestObject.send({ query }).expect(200);
-
-        const expectedResponsePayload = {
-          data: {
-            getUsers: {
-              edges: [
-                {
-                  node: {
-                    email: anotherUser.email,
-                    fullName: anotherUser.fullName,
-                    id: anotherUser.id,
-                    role: {
-                      id: role.id,
-                      name: role.name,
-                    },
+      const expectedResponsePayload = {
+        data: {
+          getUsers: {
+            edges: [
+              {
+                node: {
+                  email: anotherUser.email,
+                  fullName: anotherUser.fullName,
+                  id: anotherUser.id,
+                  role: {
+                    id: role.id,
+                    name: role.name,
                   },
                 },
-                {
-                  node: {
-                    email: currentUser.email,
-                    fullName: currentUser.fullName,
-                    id: currentUser.id,
-                    role: {
-                      id: role.id,
-                      name: role.name,
-                    },
-                  },
-                },
-              ],
-              pageInfo: {
-                currentPage: 1,
-                totalPages: 1,
               },
-              totalCount: 2,
+              {
+                node: {
+                  email: currentUser.email,
+                  fullName: currentUser.fullName,
+                  id: currentUser.id,
+                  role: {
+                    id: role.id,
+                    name: role.name,
+                  },
+                },
+              },
+            ],
+            pageInfo: {
+              currentPage: 1,
+              totalPages: 1,
             },
+            totalCount: 2,
           },
-        };
+        },
+      };
 
-        expect(response.body).toEqual(expectedResponsePayload);
-      });
+      expect(response.body).toEqual(expectedResponsePayload);
+    });
 
-      it('should not return users data with password', async () => {
-        const query = `
+    it('should not return users data with password', async () => {
+      const query = `
           query {
             getUsers(limit: 10, offset: 0) {
               pageInfo {
@@ -153,13 +137,12 @@ describe('graphQL getUsers query', () => {
           }
         `;
 
-        const response = await requestObject.send({ query }).expect(400);
+      const response = await requestObject.send({ query }).expect(400);
 
-        expect(response.body.errors).toBeDefined();
-        expect(response.body.errors[0].message).toEqual(
-          'Cannot query field "password" on type "User".'
-        );
-      });
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors[0].message).toEqual(
+        'Cannot query field "password" on type "User".'
+      );
     });
   });
 });

packages/backend/src/helpers/authentication.js

@@ -3,7 +3,7 @@ import jwt from 'jsonwebtoken';
 import appConfig from '../config/app.js';
 import User from '../models/user.js';
 
-const isAuthenticated = rule()(async (_parent, _args, req) => {
+export const isAuthenticated = async (_parent, _args, req) => {
   const token = req.headers['authorization'];
 
   if (token == null) return false;
@@ -26,29 +26,32 @@ const isAuthenticated = rule()(async (_parent, _args, req) => {
   } catch (error) {
     return false;
   }
-});
+};
 
-const authentication = shield(
-  {
-    Query: {
-      '*': isAuthenticated,
-      getAutomatischInfo: allow,
-      getConfig: allow,
-      getNotifications: allow,
-      healthcheck: allow,
-      listSamlAuthProviders: allow,
-    },
-    Mutation: {
-      '*': isAuthenticated,
-      forgotPassword: allow,
-      login: allow,
-      registerUser: allow,
-      resetPassword: allow,
-    },
+const isAuthenticatedRule = rule()(isAuthenticated);
+
+export const authenticationRules = {
+  Query: {
+    '*': isAuthenticatedRule,
+    getAutomatischInfo: allow,
+    getConfig: allow,
+    getNotifications: allow,
+    healthcheck: allow,
+    listSamlAuthProviders: allow,
   },
-  {
-    allowExternalErrors: true,
-  }
-);
+  Mutation: {
+    '*': isAuthenticatedRule,
+    forgotPassword: allow,
+    login: allow,
+    registerUser: allow,
+    resetPassword: allow,
+  },
+};
+
+const authenticationOptions = {
+  allowExternalErrors: true,
+};
+
+const authentication = shield(authenticationRules, authenticationOptions);
 
 export default authentication;

packages/backend/src/helpers/authentication.test.js

@@ -0,0 +1,78 @@
+import { describe, it, expect, vi } from 'vitest';
+import { allow } from 'graphql-shield';
+import jwt from 'jsonwebtoken';
+import User from '../models/user.js';
+import { isAuthenticated, authenticationRules } from './authentication.js';
+
+vi.mock('jsonwebtoken');
+vi.mock('../models/user.js');
+
+describe('isAuthenticated', () => {
+  it('should return false if no token is provided', async () => {
+    const req = { headers: {} };
+    expect(await isAuthenticated(null, null, req)).toBe(false);
+  });
+
+  it('should return false if token is invalid', async () => {
+    jwt.verify.mockImplementation(() => {
+      throw new Error('invalid token');
+    });
+
+    const req = { headers: { authorization: 'invalidToken' } };
+    expect(await isAuthenticated(null, null, req)).toBe(false);
+  });
+
+  it('should return true if token is valid', async () => {
+    jwt.verify.mockReturnValue({ userId: '123' });
+
+    User.query.mockReturnValue({
+      findById: vi.fn().mockReturnValue({
+        leftJoinRelated: vi.fn().mockReturnThis(),
+        withGraphFetched: vi
+          .fn()
+          .mockResolvedValue({ id: '123', role: {}, permissions: {} }),
+      }),
+    });
+
+    const req = { headers: { authorization: 'validToken' } };
+    expect(await isAuthenticated(null, null, req)).toBe(true);
+  });
+});
+
+describe('authentication rules', () => {
+  const getQueryAndMutationNames = (rules) => {
+    const queries = Object.keys(rules.Query || {});
+    const mutations = Object.keys(rules.Mutation || {});
+    return { queries, mutations };
+  };
+
+  const { queries, mutations } = getQueryAndMutationNames(authenticationRules);
+
+  describe('for queries', () => {
+    queries.forEach((query) => {
+      it(`should apply correct rule for query: ${query}`, () => {
+        const ruleApplied = authenticationRules.Query[query];
+
+        if (query === '*') {
+          expect(ruleApplied.func).toBe(isAuthenticated);
+        } else {
+          expect(ruleApplied).toEqual(allow);
+        }
+      });
+    });
+  });
+
+  describe('for mutations', () => {
+    mutations.forEach((mutation) => {
+      it(`should apply correct rule for mutation: ${mutation}`, () => {
+        const ruleApplied = authenticationRules.Mutation[mutation];
+
+        if (mutation === '*') {
+          expect(ruleApplied.func).toBe(isAuthenticated);
+        } else {
+          expect(ruleApplied).toBe(allow);
+        }
+      });
+    });
+  });
+});

packages/backend/src/helpers/compile-email.ee.js

@@ -1,6 +1,9 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as handlebars from 'handlebars';
+import path from 'path';
+import fs from 'fs';
+import handlebars from 'handlebars';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const compileEmail = (emailPath, replacements = {}) => {
   const filePath = path.join(__dirname, `../views/emails/${emailPath}.ee.hbs`);

packages/backend/src/helpers/web-ui-handler.js

@@ -15,7 +15,7 @@ const webUIHandler = async (app) => {
   app.use(express.static(webBuildPath));
 
   app.get('*', (_req, res) => {
-    res.set('Content-Security-Policy', 'frame-ancestors: none;');
+    res.set('Content-Security-Policy', 'frame-ancestors \'none\';');
     res.set('X-Frame-Options', 'DENY');
 
     res.sendFile(indexHtml);

packages/docs/pages/.vitepress/config.js

@@ -32,6 +32,15 @@ export default defineConfig({
     ],
     sidebar: {
       '/apps/': [
+        {
+          text: 'Airbrake',
+          collapsible: true,
+          collapsed: true,
+          items: [
+            { text: 'Triggers', link: '/apps/airbrake/triggers' },
+            { text: 'Connection', link: '/apps/airbrake/connection' },
+          ],
+        },
         {
           text: 'Carbone',
           collapsible: true,
@@ -305,7 +314,7 @@ export default defineConfig({
           collapsed: true,
           items: [
             { text: 'Actions', link: '/apps/removebg/actions' },
-            { text: 'Connection', link: '/apps/removebg/connection' }
+            { text: 'Connection', link: '/apps/removebg/connection' },
           ],
         },
         {

packages/docs/pages/advanced/configuration.md

@@ -14,31 +14,33 @@ The default values for some environment variables might be different in our deve
 Please be careful with the `ENCRYPTION_KEY` and `WEBHOOK_SECRET_KEY` environment variables. They are used to encrypt your credentials from third-party services and verify webhook requests. If you change them, your existing connections and flows will not continue to work.
 :::
 
-| Variable Name               | Type    | Default Value      | Description                                                                                          |
-| --------------------------- | ------- | ------------------ | ---------------------------------------------------------------------------------------------------- |
-| `HOST`                      | string  | `localhost`        | HTTP Host                                                                                            |
-| `PROTOCOL`                  | string  | `http`             | HTTP Protocol                                                                                        |
-| `PORT`                      | string  | `3000`             | HTTP Port                                                                                            |
-| `APP_ENV`                   | string  | `production`       | Automatisch Environment                                                                              |
-| `WEB_APP_URL`               | string  |                    | Can be used to override connection URLs and CORS URL                                                 |
-| `WEBHOOK_URL`               | string  |                    | Can be used to override webhook URL                                                                  |
-| `LOG_LEVEL`                 | string  | `info`             | Can be used to configure log level such as `error`, `warn`, `info`, `http`, `debug`                  |
-| `POSTGRES_DATABASE`         | string  | `automatisch`      | Database Name                                                                                        |
-| `POSTGRES_SCHEMA`           | string  | `public`           | Database Schema                                                                                      |
-| `POSTGRES_PORT`             | number  | `5432`             | Database Port                                                                                        |
-| `POSTGRES_ENABLE_SSL`       | boolean | `false`            | Enable/Disable SSL for the database                                                                  |
-| `POSTGRES_HOST`             | string  | `postgres`         | Database Host                                                                                        |
-| `POSTGRES_USERNAME`         | string  | `automatisch_user` | Database User                                                                                        |
-| `POSTGRES_PASSWORD`         | string  |                    | Password of Database User                                                                            |
-| `ENCRYPTION_KEY`            | string  |                    | Encryption Key to store credentials                                                                  |
-| `WEBHOOK_SECRET_KEY`        | string  |                    | Webhook Secret Key to verify webhook requests                                                        |
-| `APP_SECRET_KEY`            | string  |                    | Secret Key to authenticate the user                                                                  |
-| `REDIS_HOST`                | string  | `redis`            | Redis Host                                                                                           |
-| `REDIS_PORT`                | number  | `6379`             | Redis Port                                                                                           |
-| `REDIS_USERNAME`            | string  |                    | Redis Username                                                                                       |
-| `REDIS_PASSWORD`            | string  |                    | Redis Password                                                                                       |
-| `REDIS_TLS`                 | boolean | `false`            | Redis TLS                                                                                            |
-| `TELEMETRY_ENABLED`         | boolean | `true`             | Enable/Disable Telemetry                                                                             |
-| `ENABLE_BULLMQ_DASHBOARD`   | boolean | `false`            | Enable BullMQ Dashboard                                                                              |
-| `BULLMQ_DASHBOARD_USERNAME` | string  |                    | Username to login BullMQ Dashboard                                                                   |
-| `BULLMQ_DASHBOARD_PASSWORD` | string  |                    | Password to login BullMQ Dashboard                                                                   |
+| Variable Name                | Type    | Default Value      | Description                                                                         |
+| ---------------------------- | ------- | ------------------ | ----------------------------------------------------------------------------------- |
+| `HOST`                       | string  | `localhost`        | HTTP Host                                                                           |
+| `PROTOCOL`                   | string  | `http`             | HTTP Protocol                                                                       |
+| `PORT`                       | string  | `3000`             | HTTP Port                                                                           |
+| `APP_ENV`                    | string  | `production`       | Automatisch Environment                                                             |
+| `WEB_APP_URL`                | string  |                    | Can be used to override connection URLs and CORS URL                                |
+| `WEBHOOK_URL`                | string  |                    | Can be used to override webhook URL                                                 |
+| `LOG_LEVEL`                  | string  | `info`             | Can be used to configure log level such as `error`, `warn`, `info`, `http`, `debug` |
+| `POSTGRES_DATABASE`          | string  | `automatisch`      | Database Name                                                                       |
+| `POSTGRES_SCHEMA`            | string  | `public`           | Database Schema                                                                     |
+| `POSTGRES_PORT`              | number  | `5432`             | Database Port                                                                       |
+| `POSTGRES_ENABLE_SSL`        | boolean | `false`            | Enable/Disable SSL for the database                                                 |
+| `POSTGRES_HOST`              | string  | `postgres`         | Database Host                                                                       |
+| `POSTGRES_USERNAME`          | string  | `automatisch_user` | Database User                                                                       |
+| `POSTGRES_PASSWORD`          | string  |                    | Password of Database User                                                           |
+| `ENCRYPTION_KEY`             | string  |                    | Encryption Key to store credentials                                                 |
+| `WEBHOOK_SECRET_KEY`         | string  |                    | Webhook Secret Key to verify webhook requests                                       |
+| `APP_SECRET_KEY`             | string  |                    | Secret Key to authenticate the user                                                 |
+| `REDIS_HOST`                 | string  | `redis`            | Redis Host                                                                          |
+| `REDIS_PORT`                 | number  | `6379`             | Redis Port                                                                          |
+| `REDIS_USERNAME`             | string  |                    | Redis Username                                                                      |
+| `REDIS_PASSWORD`             | string  |                    | Redis Password                                                                      |
+| `REDIS_TLS`                  | boolean | `false`            | Redis TLS                                                                           |
+| `TELEMETRY_ENABLED`          | boolean | `true`             | Enable/Disable Telemetry                                                            |
+| `ENABLE_BULLMQ_DASHBOARD`    | boolean | `false`            | Enable BullMQ Dashboard                                                             |
+| `BULLMQ_DASHBOARD_USERNAME`  | string  |                    | Username to login BullMQ Dashboard                                                  |
+| `BULLMQ_DASHBOARD_PASSWORD`  | string  |                    | Password to login BullMQ Dashboard                                                  |
+| `DISABLE_NOTIFICATIONS_PAGE` | boolean | `false`            | Enable/Disable notifications page                                                   |
+| `DISABLE_FAVICON`            | boolean | `false`            | Enable/Disable favicon                                                              |

packages/docs/pages/apps/airbrake/connection.md

@@ -0,0 +1,13 @@
+# Airbrake
+
+:::info
+This page explains the steps you need to follow to set up the Airbrake
+connection in Automatisch. If any of the steps are outdated, please let us know!
+:::
+
+1. Login to your Airbrake account: [https://www.airbrake.io/](https://www.airbrake.io/).
+2. Go to your profile & notifications page.
+3. Copy `Auth Token` from the page to the `Auth Token` field on Automatisch.
+4. Fill the instance URL field with your subdomain. (https://{yoursubdomain}.airbrake.io)
+5. Write any screen name to be displayed in Automatisch.
+6. Now, you can start using the Airbrake connection with Automatisch.

packages/docs/pages/apps/airbrake/triggers.md

@@ -0,0 +1,12 @@
+---
+favicon: /favicons/airbrake.svg
+items:
+  - name: New errors
+    desc: Triggers when a new error occurs.
+---
+
+<script setup>
+  import CustomListing from '../../components/CustomListing.vue'
+</script>
+
+<CustomListing />

packages/docs/pages/guide/available-apps.md

@@ -3,6 +3,7 @@
 The following integrations are currently supported by Automatisch.
 
 - [Carbone](/apps/carbone/actions)
+- [Airbrake](/apps/airbrake/triggers)
 - [DeepL](/apps/deepl/actions)
 - [Delay](/apps/delay/actions)
 - [Discord](/apps/discord/actions)

packages/docs/pages/public/favicons/airbrake.svg

@@ -0,0 +1 @@
+<svg height="255" preserveAspectRatio="xMidYMid" viewBox="0 0 256 255" width="256" xmlns="http://www.w3.org/2000/svg"><path d="m128.636514 155.746615v-155.23361889h-3.522242v.06873152l-124.60824865 64.03287157v60.8642488h.00597665v3.234366h-.00597665v60.868233l124.60824865 64.747082h3.842989v-98.581914z" fill="#ff8e4a"/><path d="m129.941416 254.328529 125.568498-64.747082v-124.9668478l-125.887253-64.10160309h-2.243237v253.81055289h2.243237" fill="#f48746"/><path d="m109.097837 87.2551595h36.19561v59.2077195h-36.19561z" fill="#ff8e4a"/><path d="m66.1735097 188.397074h14.8639378c9.4102412 0 12.6087471-2.238257 15.6189883-9.988981l8.2796572-21.353587h45.159596l8.280653 21.353587c3.011238 7.750724 6.396016 9.988981 15.805261 9.988981h14.677665v-19.114335h-3.011237c-3.19751 0-4.704622-.689307-5.831222-3.790194l-39.516638-99.3658524h-25.779299l-39.703907 99.3658524c-1.1285915 3.100887-2.632716 3.790194-5.833214 3.790194h-3.0102413zm44.4075333-49.939922 11.478163-30.655253c2.445448-6.714771 5.269417-18.2556889 5.269417-18.2556889h.375533s2.822972 11.5409179 5.269416 18.2556889l11.478163 30.655253z" fill="#fff"/><path d="m231.204856 150.082739v-51.8086223c.235082 4.5233303 2.970397 16.8432063 24.305058 27.8512063v11.653479zm0-53.1623343v1.353712c-.029883-.5926848-.01793-1.0479066 0-1.353712zm.041837-.4392841s-.022911.1534008-.041837.4392841v-.4392841z" fill="#d4763c"/><path d="m231.155051 94.3016342c-.013946.9931207.05877 1.8945993.049805 2.0460078-.01793.2480312-2.220327 16.094132 24.305058 29.777681v-60.863253c-23.325883 12.0349884-24.449494 25.7414475-24.354863 29.0395642" fill="#ff8e4a"/></svg>

packages/web/public/index.html

@@ -2,7 +2,6 @@
 <html lang="en">
   <head>
     <meta charset="utf-8" />
-    <link rel="icon" href="%PUBLIC_URL%/favicon.ico" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="theme-color" content="#0059F7" />
     <meta

packages/web/public/manifest.json

@@ -2,13 +2,6 @@
   "short_name": "automatisch",
   "name": "automatisch",
   "description": "Build workflow automation without spending time and money. No code is required.",
-  "icons": [
-    {
-      "src": "favicon.ico",
-      "sizes": "64x64 32x32 24x24 16x16",
-      "type": "image/x-icon"
-    }
-  ],
   "start_url": ".",
   "display": "standalone",
   "theme_color": "#000000",

packages/web/src/components/AdminSettingsLayout/index.tsx

@@ -15,6 +15,7 @@ import { SvgIconComponent } from '@mui/icons-material';
 import AppBar from 'components/AppBar';
 import Drawer from 'components/Drawer';
 import * as URLS from 'config/urls';
+import useFormatMessage from 'hooks/useFormatMessage';
 import useCurrentUserAbility from 'hooks/useCurrentUserAbility';
 
 type SettingsLayoutProps = {
@@ -86,19 +87,11 @@ function createDrawerLinks({
   return items;
 }
 
-const drawerBottomLinks = [
-  {
-    Icon: ArrowBackIosNewIcon,
-    primary: 'adminSettingsDrawer.goBack',
-    to: '/',
-    dataTest: 'go-back-drawer-link',
-  },
-];
-
 export default function SettingsLayout({
   children,
 }: SettingsLayoutProps): React.ReactElement {
   const theme = useTheme();
+  const formatMessage = useFormatMessage();
   const currentUserAbility = useCurrentUserAbility();
   const matchSmallScreens = useMediaQuery(theme.breakpoints.down('lg'));
   const [isDrawerOpen, setDrawerOpen] = React.useState(!matchSmallScreens);
@@ -116,6 +109,15 @@ export default function SettingsLayout({
     canUpdateApp: currentUserAbility.can('update', 'App'),
   });
 
+  const drawerBottomLinks = [
+    {
+      Icon: ArrowBackIosNewIcon,
+      primary: formatMessage('adminSettingsDrawer.goBack'),
+      to: '/',
+      dataTest: 'go-back-drawer-link',
+    },
+  ];
+
   return (
     <>
       <AppBar

packages/web/src/components/Drawer/index.tsx

@@ -19,6 +19,7 @@ type DrawerLink = {
   Icon: React.ElementType;
   primary: string;
   to: string;
+  target?: '_blank';
   badgeContent?: React.ReactNode;
   dataTest?: string;
 };
@@ -69,7 +70,7 @@ export default function Drawer(props: DrawerProps): React.ReactElement {
 
       <List sx={{ py: 0, mt: 3 }}>
         {bottomLinks.map(
-          ({ Icon, badgeContent, primary, to, dataTest }, index) => (
+          ({ Icon, badgeContent, primary, to, dataTest, target }, index) => (
             <ListItemLink
               key={`${to}-${index}`}
               icon={
@@ -77,9 +78,10 @@ export default function Drawer(props: DrawerProps): React.ReactElement {
                   <Icon htmlColor={theme.palette.primary.main} />
                 </Badge>
               }
-              primary={formatMessage(primary)}
+              primary={primary}
               to={to}
               onClick={closeOnClick}
+              target={target}
               data-test={dataTest}
             />
           )

packages/web/src/components/Layout/index.tsx

@@ -7,12 +7,14 @@ import AppsIcon from '@mui/icons-material/Apps';
 import SwapCallsIcon from '@mui/icons-material/SwapCalls';
 import HistoryIcon from '@mui/icons-material/History';
 import NotificationsIcon from '@mui/icons-material/Notifications';
+import ArrowBackIosNew from '@mui/icons-material/ArrowBackIosNew';
 
 import * as URLS from 'config/urls';
+import useFormatMessage from 'hooks/useFormatMessage';
 import useVersion from 'hooks/useVersion';
 import AppBar from 'components/AppBar';
 import Drawer from 'components/Drawer';
-import useAutomatischInfo from 'hooks/useAutomatischInfo';
+import useConfig from 'hooks/useConfig';
 
 type PublicLayoutProps = {
   children: React.ReactNode;
@@ -40,47 +42,94 @@ const drawerLinks = [
 ];
 
 type GenerateDrawerBottomLinksOptions = {
-  isMation: boolean;
-  loading: boolean;
+  disableNotificationsPage: boolean;
   notificationBadgeContent: number;
+  additionalDrawerLink?: string;
+  additionalDrawerLinkText?: string;
+  additionalDrawerLinkIcon?: string;
+  formatMessage: ReturnType<typeof useFormatMessage>;
 };
 
-const generateDrawerBottomLinks = ({
-  isMation,
-  loading,
+const generateDrawerBottomLinks = async ({
+  disableNotificationsPage,
   notificationBadgeContent = 0,
+  additionalDrawerLink,
+  additionalDrawerLinkText,
+  formatMessage,
 }: GenerateDrawerBottomLinksOptions) => {
-  if (loading || isMation) {
-    return [];
+  const notificationsPageLinkObject = {
+    Icon: NotificationsIcon,
+    primary: formatMessage('settingsDrawer.notifications'),
+    to: URLS.UPDATES,
+    badgeContent: notificationBadgeContent,
+  };
+
+  const hasAdditionalDrawerLink =
+    additionalDrawerLink && additionalDrawerLinkText;
+
+  const additionalDrawerLinkObject = {
+    Icon: ArrowBackIosNew,
+    primary: additionalDrawerLinkText || '',
+    to: additionalDrawerLink || '',
+    target: '_blank' as const,
+  };
+
+  const links = [];
+
+  if (!disableNotificationsPage) {
+    links.push(notificationsPageLinkObject);
   }
 
-  return [
-    {
-      Icon: NotificationsIcon,
-      primary: 'settingsDrawer.notifications',
-      to: URLS.UPDATES,
-      badgeContent: notificationBadgeContent,
-    },
-  ];
+  if (hasAdditionalDrawerLink) {
+    links.push(additionalDrawerLinkObject);
+  }
+
+  return links;
+};
+
+type Link = {
+  Icon: React.ElementType;
+  primary: string;
+  target?: '_blank';
+  to: string;
+  badgeContent?: React.ReactNode;
 };
 
 export default function PublicLayout({
   children,
 }: PublicLayoutProps): React.ReactElement {
   const version = useVersion();
-  const { isMation, loading } = useAutomatischInfo();
+  const { config, loading } = useConfig([
+    'disableNotificationsPage',
+    'additionalDrawerLink',
+    'additionalDrawerLinkText',
+  ]);
   const theme = useTheme();
+  const formatMessage = useFormatMessage();
+  const [bottomLinks, setBottomLinks] = React.useState<Link[]>([]);
   const matchSmallScreens = useMediaQuery(theme.breakpoints.down('lg'));
   const [isDrawerOpen, setDrawerOpen] = React.useState(!matchSmallScreens);
 
   const openDrawer = () => setDrawerOpen(true);
   const closeDrawer = () => setDrawerOpen(false);
 
-  const drawerBottomLinks = generateDrawerBottomLinks({
-    notificationBadgeContent: version.newVersionCount,
-    loading,
-    isMation,
-  });
+  React.useEffect(() => {
+    async function perform() {
+      const newBottomLinks = await generateDrawerBottomLinks({
+        notificationBadgeContent: version.newVersionCount,
+        disableNotificationsPage: config?.disableNotificationsPage as boolean,
+        additionalDrawerLink: config?.additionalDrawerLink as string,
+        additionalDrawerLinkText: config?.additionalDrawerLinkText as string,
+        formatMessage,
+      });
+
+      setBottomLinks(newBottomLinks);
+    }
+
+    if (loading) return;
+
+    perform();
+  }, [config, loading, version.newVersionCount]);
 
   return (
     <>
@@ -93,7 +142,7 @@ export default function PublicLayout({
       <Box sx={{ display: 'flex' }}>
         <Drawer
           links={drawerLinks}
-          bottomLinks={drawerBottomLinks}
+          bottomLinks={bottomLinks}
           open={isDrawerOpen}
           onOpen={openDrawer}
           onClose={closeDrawer}

packages/web/src/components/ListItemLink/index.tsx

@@ -9,6 +9,7 @@ type ListItemLinkProps = {
   icon: React.ReactNode;
   primary: string;
   to: string;
+  target?: '_blank';
   onClick?: (event: React.SyntheticEvent) => void;
   'data-test'?: string;
 };
@@ -16,14 +17,29 @@ type ListItemLinkProps = {
 export default function ListItemLink(
   props: ListItemLinkProps
 ): React.ReactElement {
-  const { icon, primary, to, onClick, 'data-test': dataTest } = props;
+  const { icon, primary, to, onClick, 'data-test': dataTest, target } = props;
   const selected = useMatch({ path: to, end: true });
 
   const CustomLink = React.useMemo(
     () =>
       React.forwardRef<HTMLAnchorElement, Omit<LinkProps, 'to'>>(
         function InLineLink(linkProps, ref) {
-          return <Link ref={ref} to={to} {...linkProps} />;
+          try {
+            // challenge the link to check if it's absolute URL
+            new URL(to); // should throw an error if it's not an absolute URL
+
+            return (
+              <a
+                {...linkProps}
+                ref={ref}
+                href={to}
+                target={target}
+                rel="noopener noreferrer"
+              />
+            );
+          } catch {
+            return <Link ref={ref} {...linkProps} to={to} />;
+          }
         }
       ),
     [to]
@@ -37,6 +53,7 @@ export default function ListItemLink(
         selected={!!selected}
         onClick={onClick}
         data-test={dataTest}
+        target={target}
       >
         <ListItemIcon sx={{ minWidth: 52 }}>{icon}</ListItemIcon>
         <ListItemText

packages/web/src/components/MetadataProvider/index.tsx

@@ -15,6 +15,27 @@ const MetadataProvider = ({
     document.title = (config?.title as string) || 'Automatisch';
   }, [config?.title]);
 
+  React.useEffect(() => {
+    const existingFaviconElement = document.querySelector(
+      "link[rel~='icon']"
+    ) as HTMLLinkElement | null;
+
+    if (config?.disableFavicon === true) {
+      existingFaviconElement?.remove();
+    }
+
+    if (config?.disableFavicon === false) {
+      if (existingFaviconElement) {
+        existingFaviconElement.href = '/browser-tab.ico';
+      } else {
+        const newFaviconElement = document.createElement('link');
+        newFaviconElement.rel = 'icon';
+        document.head.appendChild(newFaviconElement);
+        newFaviconElement.href = '/browser-tab.ico';
+      }
+    }
+  }, [config?.disableFavicon]);
+
   return <>{children}</>;
 };
 

packages/web/src/components/SettingsLayout/index.tsx

@@ -9,6 +9,7 @@ import PaymentIcon from '@mui/icons-material/Payment';
 
 import * as URLS from 'config/urls';
 import useAutomatischInfo from 'hooks/useAutomatischInfo';
+import useFormatMessage from 'hooks/useFormatMessage';
 import AppBar from 'components/AppBar';
 import Drawer from 'components/Drawer';
 
@@ -22,8 +23,8 @@ function createDrawerLinks({ isCloud }: { isCloud: boolean }) {
       Icon: AccountCircleIcon,
       primary: 'settingsDrawer.myProfile',
       to: URLS.SETTINGS_PROFILE,
-    }
-  ]
+    },
+  ];
 
   if (isCloud) {
     items.push({
@@ -36,19 +37,12 @@ function createDrawerLinks({ isCloud }: { isCloud: boolean }) {
   return items;
 }
 
-const drawerBottomLinks = [
-  {
-    Icon: ArrowBackIosNewIcon,
-    primary: 'settingsDrawer.goBack',
-    to: '/',
-  },
-];
-
 export default function SettingsLayout({
   children,
 }: SettingsLayoutProps): React.ReactElement {
   const { isCloud } = useAutomatischInfo();
   const theme = useTheme();
+  const formatMessage = useFormatMessage();
   const matchSmallScreens = useMediaQuery(theme.breakpoints.down('lg'));
   const [isDrawerOpen, setDrawerOpen] = React.useState(!matchSmallScreens);
 
@@ -56,6 +50,14 @@ export default function SettingsLayout({
   const closeDrawer = () => setDrawerOpen(false);
   const drawerLinks = createDrawerLinks({ isCloud });
 
+  const drawerBottomLinks = [
+    {
+      Icon: ArrowBackIosNewIcon,
+      primary: formatMessage('settingsDrawer.goBack'),
+      to: '/',
+    },
+  ];
+
   return (
     <>
       <AppBar

yarn.lock

@@ -15728,9 +15728,9 @@ vite-node@1.1.3:
     vite "^5.0.0"
 
 vite@^3.1.6:
-  version "3.2.7"
-  resolved "https://registry.npmjs.org/vite/-/vite-3.2.7.tgz"
-  integrity sha512-29pdXjk49xAP0QBr0xXqu2s5jiQIXNvE/xwd0vUizYT2Hzqe4BksNNoWllFVXJf4eLZ+UlVQmXfB4lWrc+t18g==
+  version "3.2.8"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-3.2.8.tgz#0697e13addf99ed44b838b8462a3a922fdd9d37b"
+  integrity sha512-EtQU16PLIJpAZol2cTLttNP1mX6L0SyI0pgQB1VOoWeQnMSvtiwovV3D6NcjN8CZQWWyESD2v5NGnpz5RvgOZA==
   dependencies:
     esbuild "^0.15.9"
     postcss "^8.4.18"
@@ -15740,9 +15740,9 @@ vite@^3.1.6:
     fsevents "~2.3.2"
 
 vite@^5.0.0:
-  version "5.0.11"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-5.0.11.tgz#31562e41e004cb68e1d51f5d2c641ab313b289e4"
-  integrity sha512-XBMnDjZcNAw/G1gEiskiM1v6yzM4GE5aMGvhWTlHAYYhxb7S3/V1s3m2LDHa8Vh6yIWYYB0iJwsEaS523c4oYA==
+  version "5.0.12"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-5.0.12.tgz#8a2ffd4da36c132aec4adafe05d7adde38333c47"
+  integrity sha512-4hsnEkG3q0N4Tzf1+t6NdN9dg/L3BM+q8SWgbSPnJvrgH2kgdyzfVJwbR1ic69/4uMJJ/3dqDZZE5/WwqW8U1w==
   dependencies:
     esbuild "^0.19.3"
     postcss "^8.4.32"