feat(notion): add update database item action

.devcontainer/devcontainer.json

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

package.json

@@ -6,7 +6,8 @@
     "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} lint",
+    "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",
     "build:docs": "cd ./packages/docs && yarn install && yarn build"
   },
   "workspaces": {

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

@@ -1 +0,0 @@
-<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

@@ -1,44 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/index.js

@@ -1,17 +0,0 @@
-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';
-
-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,
-});

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

@@ -1,6 +1,5 @@
 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';
@@ -9,12 +8,10 @@ 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,
@@ -23,7 +20,6 @@ const transformers = {
   markdownToHtml,
   pluralize,
   replace,
-  stringToBase64,
   trimWhitespace,
   useDefaultValue,
 };
@@ -41,7 +37,6 @@ 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' },
@@ -50,7 +45,6 @@ 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

@@ -1,8 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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,4 +1,3 @@
-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';
@@ -7,7 +6,6 @@ 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';
@@ -17,7 +15,6 @@ import formatPhoneNumber from './numbers/format-phone-number.js';
 import formatDateTime from './date-time/format-date-time.js';
 
 const options = {
-  base64ToString,
   capitalize,
   extractEmailAddress,
   extractNumber,
@@ -26,7 +23,6 @@ const options = {
   markdownToHtml,
   pluralize,
   replace,
-  stringToBase64,
   trimWhitespace,
   useDefaultValue,
   performMathOperation,

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

@@ -1,12 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/apps/notion/actions/index.js

@@ -1,5 +1,11 @@
 import createDatabaseItem from './create-database-item/index.js';
 import createPage from './create-page/index.js';
 import findDatabaseItem from './find-database-item/index.js';
+import updateDatabaseItem from './update-database-item/index.js';
 
-export default [createDatabaseItem, createPage, findDatabaseItem];
+export default [
+  createDatabaseItem,
+  createPage,
+  findDatabaseItem,
+  updateDatabaseItem,
+];

packages/backend/src/apps/notion/actions/update-database-item/index.js

@@ -0,0 +1,157 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Update database item',
+  key: 'updateDatabaseItem',
+  description: 'Updates a database item.',
+  arguments: [
+    {
+      label: 'Database',
+      key: 'databaseId',
+      type: 'dropdown',
+      required: true,
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listDatabases',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Item',
+      key: 'itemId',
+      type: 'dropdown',
+      required: true,
+      variables: true,
+      dependsOn: ['parameters.databaseId'],
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listDatabaseItems',
+          },
+          {
+            name: 'parameters.databaseId',
+            value: '{parameters.databaseId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Name',
+      key: 'name',
+      type: 'string',
+      required: false,
+      description:
+        'This field has a 2000 character limit. Any characters beyond 2000 will not be included.',
+      variables: true,
+    },
+    {
+      label: 'Tags',
+      key: 'tags',
+      type: 'dynamic',
+      required: false,
+      description: '',
+      fields: [
+        {
+          label: 'Tag',
+          key: 'tag',
+          type: 'dropdown',
+          required: true,
+          variables: true,
+          dependsOn: ['parameters.databaseId'],
+          source: {
+            type: 'query',
+            name: 'getDynamicData',
+            arguments: [
+              {
+                name: 'key',
+                value: 'listTags',
+              },
+              {
+                name: 'parameters.databaseId',
+                value: '{parameters.databaseId}',
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      label: 'Content',
+      key: 'content',
+      type: 'string',
+      required: false,
+      description:
+        'You can choose to add extra text to the database item, with a limit of up to 2000 characters if desired.',
+      variables: true,
+    },
+  ],
+
+  async run($) {
+    const itemId = $.step.parameters.itemId;
+    const name = $.step.parameters.name;
+    const truncatedName = name.slice(0, 2000);
+    const content = $.step.parameters.content;
+    const truncatedContent = content.slice(0, 2000);
+    const tags = $.step.parameters.tags;
+    const formattedTags = tags
+      .filter((tag) => tag.tag !== '')
+      .map((tag) => tag.tag);
+
+    const body = {
+      properties: {},
+    };
+
+    if (truncatedName) {
+      body.properties.Name = {
+        title: [
+          {
+            text: {
+              content: truncatedName,
+            },
+          },
+        ],
+      };
+    }
+
+    if (formattedTags?.length) {
+      body.properties.Tags = {
+        multi_select: formattedTags.map((tag) => ({ name: tag })),
+      };
+    }
+
+    if (truncatedContent) {
+      const response = await $.http.get(`/v1/blocks/${itemId}/children`);
+      const firstBlockId = response.data.results[0].id;
+
+      const body = {
+        paragraph: {
+          rich_text: [
+            {
+              type: 'text',
+              text: {
+                content: truncatedContent,
+              },
+            },
+          ],
+        },
+      };
+
+      await $.http.patch(`/v1/blocks/${firstBlockId}`, body);
+    }
+
+    const { data } = await $.http.patch(`/v1/pages/${itemId}`, body);
+
+    $.setActionItem({
+      raw: data,
+    });
+  },
+});

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

@@ -1,4 +1,6 @@
+import listDatabaseItems from './list-database-items/index.js';
 import listDatabases from './list-databases/index.js';
 import listParentPages from './list-parent-pages/index.js';
+import listTags from './list-tags/index.js';
 
-export default [listDatabases, listParentPages];
+export default [listDatabaseItems, listDatabases, listParentPages, listTags];

packages/backend/src/apps/notion/dynamic-data/list-database-items/index.js

@@ -0,0 +1,38 @@
+export default {
+  name: 'List database items',
+  key: 'listDatabaseItems',
+
+  async run($) {
+    const databases = {
+      data: [],
+      error: null,
+    };
+    const payload = {
+      start_cursor: undefined,
+    };
+    const databaseId = $.step.parameters.databaseId;
+
+    if (!databaseId) {
+      return databases;
+    }
+
+    do {
+      const response = await $.http.post(
+        `/v1/databases/${databaseId}/query`,
+        payload
+      );
+
+      payload.start_cursor = response.data.next_cursor;
+
+      for (const database of response.data.results) {
+        databases.data.push({
+          value: database.id,
+          name:
+            database.properties.Name?.title?.[0]?.plain_text || 'Untitled Page',
+        });
+      }
+    } while (payload.start_cursor);
+
+    return databases;
+  },
+};

packages/backend/src/apps/notion/dynamic-data/list-databases/index.js

@@ -22,7 +22,7 @@ export default {
       for (const database of response.data.results) {
         databases.data.push({
           value: database.id,
-          name: database.title[0].plain_text,
+          name: database.title?.[0]?.plain_text || 'Untitled Database',
         });
       }
     } while (payload.start_cursor);

packages/backend/src/apps/notion/dynamic-data/list-tags/index.js

@@ -0,0 +1,38 @@
+export default {
+  name: 'List tags',
+  key: 'listTags',
+
+  async run($) {
+    const tags = {
+      data: [],
+      error: null,
+    };
+    const databaseId = $.step.parameters.databaseId;
+    let allTags;
+
+    if (!databaseId) {
+      return tags;
+    }
+
+    const response = await $.http.get(`/v1/databases/${databaseId}`);
+    const tagsExist =
+      response.data.properties.Tags.multi_select.options.length !== 0;
+
+    if (tagsExist) {
+      allTags = response.data.properties.Tags.multi_select.options.map(
+        (tag) => tag.name
+      );
+    } else {
+      return tags;
+    }
+
+    for (const tag of allTags) {
+      tags.data.push({
+        value: tag,
+        name: tag,
+      });
+    }
+
+    return tags;
+  },
+};

packages/backend/src/config/app.js

@@ -18,9 +18,7 @@ const port = process.env.PORT || '3000';
 const serveWebAppSeparately =
   process.env.SERVE_WEB_APP_SEPARATELY === 'true' ? true : false;
 
-let apiUrl = new URL(
+let apiUrl = new URL(`${protocol}://${host}:${port}`).toString();
-  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
@@ -90,10 +88,6 @@ 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,10 +1,7 @@
-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,17 +1,9 @@
-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)) {
@@ -26,7 +18,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,7 +2,6 @@ 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', () => {
@@ -57,10 +56,6 @@ 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,
             },
           },
         };
@@ -87,48 +82,6 @@ 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,74 +6,100 @@ import { createRole } from '../../../test/factories/role';
 import { createUser } from '../../../test/factories/user';
 
 describe('graphQL getCurrentUser query', () => {
-  let role, currentUser, token, requestObject;
+  describe('with unauthenticated user', () => {
+    it('should throw not authorized error', async () => {
+      const invalidUserToken = 'invalid-token';
 
-  beforeEach(async () => {
+      const query = `
-    role = await createRole({
+        query {
-      key: 'sample',
+          getCurrentUser {
-      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 {
-          id
-          email
-          fullName
-          email
-          createdAt
-          updatedAt
-          role {
             id
-            name
+            email
           }
         }
-      }
+      `;
-    `;
 
-    const response = await requestObject.send({ query }).expect(200);
+      const response = await request(app)
+        .post('/graphql')
+        .set('Authorization', invalidUserToken)
+        .send({ query })
+        .expect(200);
 
-    const expectedResponsePayload = {
+      expect(response.body.errors).toBeDefined();
-      data: {
+      expect(response.body.errors[0].message).toEqual('Not Authorised!');
-        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);
   });
 
-  it('should not return user password', async () => {
+  describe('with authenticated user', () => {
-    const query = `
+    let role, currentUser, token, requestObject;
-      query {
+
-        getCurrentUser {
+    beforeEach(async () => {
-          id
+      role = await createRole({
-          email
+        key: 'sample',
-          password
+        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 {
+            id
+            email
+            fullName
+            email
+            createdAt
+            updatedAt
+            role {
+              id
+              name
+            }
+          }
         }
-      }
+      `;
-    `;
 
-    const response = await requestObject.send({ query }).expect(400);
+      const response = await requestObject.send({ query }).expect(200);
 
-    expect(response.body.errors).toBeDefined();
+      const expectedResponsePayload = {
-    expect(response.body.errors[0].message).toEqual(
+        data: {
-      'Cannot query field "password" on type "User".'
+          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);
+    });
+
+    it('should not return user password', async () => {
+      const query = `
+        query {
+          getCurrentUser {
+            id
+            email
+            password
+          }
+        }
+      `;
+
+      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".'
+      );
+    });
   });
 });

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

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

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

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

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

@@ -15,7 +15,8 @@ describe('graphQL getRoles query', () => {
     userWithPermissions,
     userWithoutPermissions,
     tokenWithPermissions,
-    tokenWithoutPermissions;
+    tokenWithoutPermissions,
+    invalidToken;
 
   beforeEach(async () => {
     currentUserRole = await createRole({ name: 'Current user role' });
@@ -52,82 +53,99 @@ describe('graphQL getRoles query', () => {
     tokenWithoutPermissions = createAuthTokenByUserId(
       userWithoutPermissions.id
     );
+
+    invalidToken = 'invalid-token';
   });
 
-  describe('and with valid license', () => {
+  describe('with unauthenticated user', () => {
-    beforeEach(async () => {
+    it('should throw not authorized error', async () => {
-      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+      const response = await request(app)
-    });
+        .post('/graphql')
+        .set('Authorization', invalidToken)
+        .send({ query })
+        .expect(200);
 
-    describe('and without permissions', () => {
+      expect(response.body.errors).toBeDefined();
-      it('should throw not authorized error', async () => {
+      expect(response.body.errors[0].message).toEqual('Not Authorised!');
-        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);
-      });
     });
   });
 
-  describe('and without valid license', () => {
+  describe('with authenticated user', () => {
-    beforeEach(async () => {
+    describe('and with valid license', () => {
-      vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
+      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);
+
+          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);
+        });
+      });
     });
 
-    describe('and correct permissions', () => {
+    describe('and without valid license', () => {
-      it('should throw not authorized error', async () => {
+      beforeEach(async () => {
-        const response = await request(app)
+        vi.spyOn(license, 'hasValidLicense').mockResolvedValue(false);
-          .post('/graphql')
+      });
-          .set('Authorization', tokenWithPermissions)
-          .send({ query })
-          .expect(200);
 
-        expect(response.body.errors).toBeDefined();
+      describe('and correct permissions', () => {
-        expect(response.body.errors[0].message).toEqual('Not authorized!');
+        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,46 +16,34 @@ describe('graphQL getTrialStatus query', () => {
     }
   `;
 
-  let user, userToken;
+  const invalidToken = 'invalid-token';
 
-  beforeEach(async () => {
+  describe('with unauthenticated user', () => {
-    const trialExpiryDate = DateTime.now().plus({ days: 30 }).toISODate();
+    it('should throw not authorized error', async () => {
-
-    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', userToken)
+        .set('Authorization', invalidToken)
         .send({ query })
         .expect(200);
 
-      const expectedResponsePayload = {
+      expect(response.body.errors).toBeDefined();
-        data: { getTrialStatus: null },
+      expect(response.body.errors[0].message).toEqual('Not Authorised!');
-      };
-
-      expect(response.body).toEqual(expectedResponsePayload);
     });
   });
 
-  describe('and with cloud flag enabled', () => {
+  describe('with authenticated user', () => {
+    let user, userToken;
+
     beforeEach(async () => {
-      vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
+      const trialExpiryDate = DateTime.now().plus({ days: 30 }).toISODate();
+
+      user = await createUser({ trialExpiryDate });
+      userToken = createAuthTokenByUserId(user.id);
     });
 
-    describe('and not in trial and has active subscription', () => {
+    describe('and with cloud flag disabled', () => {
       beforeEach(async () => {
-        vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(false);
+        vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(false);
-        vi.spyOn(User.prototype, 'hasActiveSubscription').mockResolvedValue(
-          true
-        );
       });
 
       it('should return null', async () => {
@@ -73,27 +61,56 @@ describe('graphQL getTrialStatus query', () => {
       });
     });
 
-    describe('and in trial period', () => {
+    describe('and with cloud flag enabled', () => {
       beforeEach(async () => {
-        vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(true);
+        vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(true);
       });
 
-      it('should return null', async () => {
+      describe('and not in trial and has active subscription', () => {
-        const response = await request(app)
+        beforeEach(async () => {
-          .post('/graphql')
+          vi.spyOn(User.prototype, 'inTrial').mockResolvedValue(false);
-          .set('Authorization', userToken)
+          vi.spyOn(User.prototype, 'hasActiveSubscription').mockResolvedValue(
-          .send({ query })
+            true
-          .expect(200);
+          );
+        });
 
-        const expectedResponsePayload = {
+        it('should return null', async () => {
-          data: {
+          const response = await request(app)
-            getTrialStatus: {
+            .post('/graphql')
-              expireAt: new Date(user.trialExpiryDate).getTime().toString(),
+            .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(),
+              },
             },
-          },
+          };
-        };
 
-        expect(response.body).toEqual(expectedResponsePayload);
+          expect(response.body).toEqual(expectedResponsePayload);
+        });
       });
     });
   });

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

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

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

@@ -30,95 +30,111 @@ describe('graphQL getUsers query', () => {
     }
   `;
 
-  describe('and without permissions', () => {
+  describe('with unauthenticated user', () => {
     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', token)
+        .set('Authorization', 'invalid-token')
         .send({ query })
         .expect(200);
 
       expect(response.body.errors).toBeDefined();
-      expect(response.body.errors[0].message).toEqual('Not authorized!');
+      expect(response.body.errors[0].message).toEqual('Not Authorised!');
     });
   });
 
-  describe('and with correct permissions', () => {
+  describe('with authenticated user', () => {
-    let role, currentUser, anotherUser, token, requestObject;
+    describe('and without permissions', () => {
+      it('should throw not authorized error', async () => {
+        const userWithoutPermissions = await createUser();
+        const token = createAuthTokenByUserId(userWithoutPermissions.id);
 
-    beforeEach(async () => {
+        const response = await request(app)
-      role = await createRole({
+          .post('/graphql')
-        key: 'sample',
+          .set('Authorization', token)
-        name: 'sample',
+          .send({ query })
+          .expect(200);
+
+        expect(response.body.errors).toBeDefined();
+        expect(response.body.errors[0].message).toEqual('Not authorized!');
       });
-
-      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 () => {
+    describe('and with correct permissions', () => {
-      const response = await requestObject.send({ query }).expect(200);
+      let role, currentUser, anotherUser, token, requestObject;
 
-      const expectedResponsePayload = {
+      beforeEach(async () => {
-        data: {
+        role = await createRole({
-          getUsers: {
+          key: 'sample',
-            edges: [
+          name: 'sample',
-              {
+        });
-                node: {
+
-                  email: anotherUser.email,
+        await createPermission({
-                  fullName: anotherUser.fullName,
+          action: 'read',
-                  id: anotherUser.id,
+          subject: 'User',
-                  role: {
+          roleId: role.id,
-                    id: role.id,
+        });
-                    name: role.name,
+
+        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,
+                    },
                   },
                 },
-              },
+                {
-              {
+                  node: {
-                node: {
+                    email: currentUser.email,
-                  email: currentUser.email,
+                    fullName: currentUser.fullName,
-                  fullName: currentUser.fullName,
+                    id: currentUser.id,
-                  id: currentUser.id,
+                    role: {
-                  role: {
+                      id: role.id,
-                    id: role.id,
+                      name: role.name,
-                    name: role.name,
+                    },
                   },
                 },
+              ],
+              pageInfo: {
+                currentPage: 1,
+                totalPages: 1,
               },
-            ],
+              totalCount: 2,
-            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 () => {
+      it('should not return users data with password', async () => {
-      const query = `
+        const query = `
           query {
             getUsers(limit: 10, offset: 0) {
               pageInfo {
@@ -137,12 +153,13 @@ 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).toBeDefined();
-      expect(response.body.errors[0].message).toEqual(
+        expect(response.body.errors[0].message).toEqual(
-        'Cannot query field "password" on type "User".'
+          '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';
 
-export const isAuthenticated = async (_parent, _args, req) => {
+const isAuthenticated = rule()(async (_parent, _args, req) => {
   const token = req.headers['authorization'];
 
   if (token == null) return false;
@@ -26,32 +26,29 @@ export const isAuthenticated = async (_parent, _args, req) => {
   } catch (error) {
     return false;
   }
-};
+});
 
-const isAuthenticatedRule = rule()(isAuthenticated);
+const authentication = shield(
-
+  {
-export const authenticationRules = {
+    Query: {
-  Query: {
+      '*': isAuthenticated,
-    '*': isAuthenticatedRule,
+      getAutomatischInfo: allow,
-    getAutomatischInfo: allow,
+      getConfig: allow,
-    getConfig: allow,
+      getNotifications: allow,
-    getNotifications: allow,
+      healthcheck: allow,
-    healthcheck: allow,
+      listSamlAuthProviders: allow,
-    listSamlAuthProviders: allow,
+    },
+    Mutation: {
+      '*': isAuthenticated,
+      forgotPassword: allow,
+      login: allow,
+      registerUser: allow,
+      resetPassword: allow,
+    },
   },
-  Mutation: {
+  {
-    '*': isAuthenticatedRule,
+    allowExternalErrors: true,
-    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

@@ -1,78 +0,0 @@
-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,9 +1,6 @@
-import path from 'path';
+import * as path from 'path';
-import fs from 'fs';
+import * as fs from 'fs';
-import handlebars from 'handlebars';
+import * as 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,12 +32,6 @@ export default defineConfig({
     ],
     sidebar: {
       '/apps/': [
-        {
-          text: 'Airbrake',
-          collapsible: true,
-          collapsed: true,
-          items: [{ text: 'Connection', link: '/apps/airbrake/connection' }],
-        },
         {
           text: 'Carbone',
           collapsible: true,
@@ -311,7 +305,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,33 +14,31 @@ 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                                                                         |
+| Variable Name               | Type    | Default Value      | Description                                                                                          |
-| ---------------------------- | ------- | ------------------ | ----------------------------------------------------------------------------------- |
+| --------------------------- | ------- | ------------------ | ---------------------------------------------------------------------------------------------------- |
-| `HOST`                       | string  | `localhost`        | HTTP Host                                                                           |
+| `HOST`                      | string  | `localhost`        | HTTP Host                                                                                            |
-| `PROTOCOL`                   | string  | `http`             | HTTP Protocol                                                                       |
+| `PROTOCOL`                  | string  | `http`             | HTTP Protocol                                                                                        |
-| `PORT`                       | string  | `3000`             | HTTP Port                                                                           |
+| `PORT`                      | string  | `3000`             | HTTP Port                                                                                            |
-| `APP_ENV`                    | string  | `production`       | Automatisch Environment                                                             |
+| `APP_ENV`                   | string  | `production`       | Automatisch Environment                                                                              |
-| `WEB_APP_URL`                | string  |                    | Can be used to override connection URLs and CORS URL                                |
+| `WEB_APP_URL`               | string  |                    | Can be used to override connection URLs and CORS URL                                                 |
-| `WEBHOOK_URL`                | string  |                    | Can be used to override webhook 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` |
+| `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_DATABASE`         | string  | `automatisch`      | Database Name                                                                                        |
-| `POSTGRES_SCHEMA`            | string  | `public`           | Database Schema                                                                     |
+| `POSTGRES_SCHEMA`           | string  | `public`           | Database Schema                                                                                      |
-| `POSTGRES_PORT`              | number  | `5432`             | Database Port                                                                       |
+| `POSTGRES_PORT`             | number  | `5432`             | Database Port                                                                                        |
-| `POSTGRES_ENABLE_SSL`        | boolean | `false`            | Enable/Disable SSL for the database                                                 |
+| `POSTGRES_ENABLE_SSL`       | boolean | `false`            | Enable/Disable SSL for the database                                                                  |
-| `POSTGRES_HOST`              | string  | `postgres`         | Database Host                                                                       |
+| `POSTGRES_HOST`             | string  | `postgres`         | Database Host                                                                                        |
-| `POSTGRES_USERNAME`          | string  | `automatisch_user` | Database User                                                                       |
+| `POSTGRES_USERNAME`         | string  | `automatisch_user` | Database User                                                                                        |
-| `POSTGRES_PASSWORD`          | string  |                    | Password of Database User                                                           |
+| `POSTGRES_PASSWORD`         | string  |                    | Password of Database User                                                                            |
-| `ENCRYPTION_KEY`             | string  |                    | Encryption Key to store credentials                                                 |
+| `ENCRYPTION_KEY`            | string  |                    | Encryption Key to store credentials                                                                  |
-| `WEBHOOK_SECRET_KEY`         | string  |                    | Webhook Secret Key to verify webhook requests                                       |
+| `WEBHOOK_SECRET_KEY`        | string  |                    | Webhook Secret Key to verify webhook requests                                                        |
-| `APP_SECRET_KEY`             | string  |                    | Secret Key to authenticate the user                                                 |
+| `APP_SECRET_KEY`            | string  |                    | Secret Key to authenticate the user                                                                  |
-| `REDIS_HOST`                 | string  | `redis`            | Redis Host                                                                          |
+| `REDIS_HOST`                | string  | `redis`            | Redis Host                                                                                           |
-| `REDIS_PORT`                 | number  | `6379`             | Redis Port                                                                          |
+| `REDIS_PORT`                | number  | `6379`             | Redis Port                                                                                           |
-| `REDIS_USERNAME`             | string  |                    | Redis Username                                                                      |
+| `REDIS_USERNAME`            | string  |                    | Redis Username                                                                                       |
-| `REDIS_PASSWORD`             | string  |                    | Redis Password                                                                      |
+| `REDIS_PASSWORD`            | string  |                    | Redis Password                                                                                       |
-| `REDIS_TLS`                  | boolean | `false`            | Redis TLS                                                                           |
+| `REDIS_TLS`                 | boolean | `false`            | Redis TLS                                                                                            |
-| `TELEMETRY_ENABLED`          | boolean | `true`             | Enable/Disable Telemetry                                                            |
+| `TELEMETRY_ENABLED`         | boolean | `true`             | Enable/Disable Telemetry                                                                             |
-| `ENABLE_BULLMQ_DASHBOARD`    | boolean | `false`            | Enable BullMQ Dashboard                                                             |
+| `ENABLE_BULLMQ_DASHBOARD`   | boolean | `false`            | Enable BullMQ Dashboard                                                                              |
-| `BULLMQ_DASHBOARD_USERNAME`  | string  |                    | Username to login BullMQ Dashboard                                                  |
+| `BULLMQ_DASHBOARD_USERNAME` | string  |                    | Username to login BullMQ Dashboard                                                                   |
-| `BULLMQ_DASHBOARD_PASSWORD`  | string  |                    | Password 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

@@ -1,13 +0,0 @@
-# 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/notion/actions.md

@@ -7,6 +7,8 @@ items:
     desc: Creates a page inside a parent page.
   - name: Find database item
     desc: Searches for an item in a database by property.
+  - name: Update database item
+    desc: Updates a database item.
 ---
 
 <script setup>

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

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

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

@@ -7,14 +7,12 @@ 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 useConfig from 'hooks/useConfig';
+import useAutomatischInfo from 'hooks/useAutomatischInfo';
 
 type PublicLayoutProps = {
   children: React.ReactNode;
@@ -42,94 +40,47 @@ const drawerLinks = [
 ];
 
 type GenerateDrawerBottomLinksOptions = {
-  disableNotificationsPage: boolean;
+  isMation: boolean;
+  loading: boolean;
   notificationBadgeContent: number;
-  additionalDrawerLink?: string;
-  additionalDrawerLinkText?: string;
-  additionalDrawerLinkIcon?: string;
-  formatMessage: ReturnType<typeof useFormatMessage>;
 };
 
-const generateDrawerBottomLinks = async ({
+const generateDrawerBottomLinks = ({
-  disableNotificationsPage,
+  isMation,
+  loading,
   notificationBadgeContent = 0,
-  additionalDrawerLink,
-  additionalDrawerLinkText,
-  formatMessage,
 }: GenerateDrawerBottomLinksOptions) => {
-  const notificationsPageLinkObject = {
+  if (loading || isMation) {
-    Icon: NotificationsIcon,
+    return [];
-    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);
   }
 
-  if (hasAdditionalDrawerLink) {
+  return [
-    links.push(additionalDrawerLinkObject);
+    {
-  }
+      Icon: NotificationsIcon,
-
+      primary: 'settingsDrawer.notifications',
-  return links;
+      to: URLS.UPDATES,
-};
+      badgeContent: notificationBadgeContent,
-
+    },
-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 { config, loading } = useConfig([
+  const { isMation, loading } = useAutomatischInfo();
-    '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);
 
-  React.useEffect(() => {
+  const drawerBottomLinks = generateDrawerBottomLinks({
-    async function perform() {
+    notificationBadgeContent: version.newVersionCount,
-      const newBottomLinks = await generateDrawerBottomLinks({
+    loading,
-        notificationBadgeContent: version.newVersionCount,
+    isMation,
-        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 (
     <>
@@ -142,7 +93,7 @@ export default function PublicLayout({
       <Box sx={{ display: 'flex' }}>
         <Drawer
           links={drawerLinks}
-          bottomLinks={bottomLinks}
+          bottomLinks={drawerBottomLinks}
           open={isDrawerOpen}
           onOpen={openDrawer}
           onClose={closeDrawer}

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

@@ -9,7 +9,6 @@ type ListItemLinkProps = {
   icon: React.ReactNode;
   primary: string;
   to: string;
-  target?: '_blank';
   onClick?: (event: React.SyntheticEvent) => void;
   'data-test'?: string;
 };
@@ -17,29 +16,14 @@ type ListItemLinkProps = {
 export default function ListItemLink(
   props: ListItemLinkProps
 ): React.ReactElement {
-  const { icon, primary, to, onClick, 'data-test': dataTest, target } = props;
+  const { icon, primary, to, onClick, 'data-test': dataTest } = props;
   const selected = useMatch({ path: to, end: true });
 
   const CustomLink = React.useMemo(
     () =>
       React.forwardRef<HTMLAnchorElement, Omit<LinkProps, 'to'>>(
         function InLineLink(linkProps, ref) {
-          try {
+          return <Link ref={ref} to={to} {...linkProps} />;
-            // 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]
@@ -53,7 +37,6 @@ 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,27 +15,6 @@ 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,7 +9,6 @@ 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';
 
@@ -23,8 +22,8 @@ function createDrawerLinks({ isCloud }: { isCloud: boolean }) {
       Icon: AccountCircleIcon,
       primary: 'settingsDrawer.myProfile',
       to: URLS.SETTINGS_PROFILE,
-    },
+    }
-  ];
+  ]
 
   if (isCloud) {
     items.push({
@@ -37,12 +36,19 @@ 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);
 
@@ -50,14 +56,6 @@ 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.8"
+  version "3.2.7"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-3.2.8.tgz#0697e13addf99ed44b838b8462a3a922fdd9d37b"
+  resolved "https://registry.npmjs.org/vite/-/vite-3.2.7.tgz"
-  integrity sha512-EtQU16PLIJpAZol2cTLttNP1mX6L0SyI0pgQB1VOoWeQnMSvtiwovV3D6NcjN8CZQWWyESD2v5NGnpz5RvgOZA==
+  integrity sha512-29pdXjk49xAP0QBr0xXqu2s5jiQIXNvE/xwd0vUizYT2Hzqe4BksNNoWllFVXJf4eLZ+UlVQmXfB4lWrc+t18g==
   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.12"
+  version "5.0.11"
-  resolved "https://registry.yarnpkg.com/vite/-/vite-5.0.12.tgz#8a2ffd4da36c132aec4adafe05d7adde38333c47"
+  resolved "https://registry.yarnpkg.com/vite/-/vite-5.0.11.tgz#31562e41e004cb68e1d51f5d2c641ab313b289e4"
-  integrity sha512-4hsnEkG3q0N4Tzf1+t6NdN9dg/L3BM+q8SWgbSPnJvrgH2kgdyzfVJwbR1ic69/4uMJJ/3dqDZZE5/WwqW8U1w==
+  integrity sha512-XBMnDjZcNAw/G1gEiskiM1v6yzM4GE5aMGvhWTlHAYYhxb7S3/V1s3m2LDHa8Vh6yIWYYB0iJwsEaS523c4oYA==
   dependencies:
     esbuild "^0.19.3"
     postcss "^8.4.32"