chore(deps): bump micromatch from 4.0.4 to 4.0.8

Bumps [micromatch](https://github.com/micromatch/micromatch) from 4.0.4 to 4.0.8.
- [Release notes](https://github.com/micromatch/micromatch/releases)
- [Changelog](https://github.com/micromatch/micromatch/blob/master/CHANGELOG.md)
- [Commits](https://github.com/micromatch/micromatch/compare/4.0.4...4.0.8)

---
updated-dependencies:
- dependency-name: micromatch
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>

docker/Dockerfile

@@ -1,10 +1,10 @@
 # syntax=docker/dockerfile:1
 FROM node:18-alpine
 
-ENV PORT 3000
+ENV PORT=3000
 
 RUN \
-  apk --no-cache add --virtual build-dependencies python3 build-base git
+  apk --no-cache add --virtual build-dependencies python3 build-base git make g++
 
 WORKDIR /automatisch
 

packages/backend/knexfile.js

@@ -1,6 +1,6 @@
 import { knexSnakeCaseMappers } from 'objection';
 import appConfig from './src/config/app.js';
-import path from 'path';
+import path, { join } from 'path';
 import { fileURLToPath } from 'url';
 
 const fileExtension = 'js';
@@ -20,12 +20,12 @@ const knexConfig = {
   searchPath: [appConfig.postgresSchema],
   pool: { min: 0, max: 20 },
   migrations: {
-    directory: __dirname + '/src/db/migrations',
+    directory: join(__dirname, '/src/db/migrations'),
     extension: fileExtension,
     loadExtensions: [`.${fileExtension}`],
   },
   seeds: {
-    directory: __dirname + '/src/db/seeds',
+    directory: join(__dirname, '/src/db/seeds'),
   },
   ...(appConfig.isTest ? knexSnakeCaseMappers() : {}),
 };

packages/backend/package.json

@@ -5,12 +5,13 @@
   "description": "The open source Zapier alternative. Build workflow automation without spending time and money.",
   "type": "module",
   "scripts": {
-    "dev": "nodemon --watch 'src/**/*.js' --exec 'node' src/server.js",
-    "worker": "nodemon --watch 'src/**/*.js' --exec 'node' src/worker.js",
+    "dev": "nodemon --exec node src/server.js",
+    "worker": "nodemon --exec node src/worker.js",
     "start": "node src/server.js",
     "start:worker": "node src/worker.js",
     "pretest": "APP_ENV=test node ./test/setup/prepare-test-env.js",
     "test": "APP_ENV=test vitest run",
+    "test:watch": "APP_ENV=test vitest watch",
     "lint": "eslint .",
     "db:create": "node ./bin/database/create.js",
     "db:seed:user": "node ./bin/database/seed-user.js",
@@ -49,6 +50,7 @@
     "http-errors": "~1.6.3",
     "http-proxy-agent": "^7.0.0",
     "https-proxy-agent": "^7.0.1",
+    "isolated-vm": "^5.0.1",
     "jsonwebtoken": "^9.0.0",
     "knex": "^2.4.0",
     "libphonenumber-js": "^1.10.48",
@@ -103,5 +105,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "nodemonConfig": {
+    "watch": [ "src/" ],
+    "ext": "js"
   }
 }

packages/backend/src/apps/carbone/actions/add-template/index.js

@@ -7,7 +7,7 @@ export default defineAction({
     'Creates an attachment of a specified object by given parent ID.',
   arguments: [
     {
-      label: 'Templete Data',
+      label: 'Template Data',
       key: 'templateData',
       type: 'string',
       required: true,

packages/backend/src/apps/clickup/actions/create-folder/index.js

@@ -0,0 +1,72 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Create folder',
+  key: 'createFolder',
+  description: 'Creates a new folder.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Folder Name',
+      key: 'folderName',
+      type: 'string',
+      required: true,
+      description: '',
+      variables: true,
+    },
+  ],
+
+  async run($) {
+    const { spaceId, folderName } = $.step.parameters;
+
+    const body = {
+      name: folderName,
+    };
+
+    const { data } = await $.http.post(`/v2/space/${spaceId}/folder`, body);
+
+    $.setActionItem({
+      raw: data,
+    });
+  },
+});

packages/backend/src/apps/clickup/actions/create-list/index.js

@@ -0,0 +1,135 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Create list',
+  key: 'createList',
+  description: 'Creates a new list.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Folder',
+      key: 'folderId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.spaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listFolders',
+          },
+          {
+            name: 'parameters.spaceId',
+            value: '{parameters.spaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'List Name',
+      key: 'listName',
+      type: 'string',
+      required: true,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'List Info',
+      key: 'listInfo',
+      type: 'string',
+      required: false,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'Priority',
+      key: 'priority',
+      type: 'dropdown',
+      required: false,
+      description: '',
+      variables: true,
+      options: [
+        { label: 'Urgent', value: 1 },
+        { label: 'High', value: 2 },
+        { label: 'Normal', value: 3 },
+        { label: 'Low', value: 4 },
+      ],
+    },
+    {
+      label: 'Due Date',
+      key: 'dueDate',
+      type: 'string',
+      required: false,
+      description: 'format: integer <int64>',
+      variables: true,
+    },
+  ],
+
+  async run($) {
+    const { folderId, listName, listInfo, priority, dueDate } =
+      $.step.parameters;
+
+    const body = {
+      name: listName,
+      content: listInfo,
+    };
+
+    if (priority) {
+      body.priority = priority;
+    }
+
+    if (dueDate) {
+      body.due_date = dueDate;
+    }
+
+    const { data } = await $.http.post(`/v2/folder/${folderId}/list`, body);
+
+    $.setActionItem({
+      raw: data,
+    });
+  },
+});

packages/backend/src/apps/clickup/actions/create-task/index.js

@@ -0,0 +1,294 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Create task',
+  key: 'createTask',
+  description: 'Creates a new task.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Folder',
+      key: 'folderId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.spaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listFolders',
+          },
+          {
+            name: 'parameters.spaceId',
+            value: '{parameters.spaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'List',
+      key: 'listId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.folderId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listLists',
+          },
+          {
+            name: 'parameters.folderId',
+            value: '{parameters.folderId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Task Name',
+      key: 'taskName',
+      type: 'string',
+      required: true,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'Task Description',
+      key: 'taskDescription',
+      type: 'string',
+      required: false,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'Markdown Content',
+      key: 'markdownContent',
+      type: 'dropdown',
+      required: false,
+      description: '',
+      variables: true,
+      options: [
+        { label: 'False', value: 'false' },
+        { label: 'True', value: 'true' },
+      ],
+    },
+    {
+      label: 'Assignees',
+      key: 'assigneeIds',
+      type: 'dynamic',
+      required: false,
+      description: '',
+      fields: [
+        {
+          label: 'Assignee',
+          key: 'assigneeId',
+          type: 'dropdown',
+          required: false,
+          dependsOn: ['parameters.listId'],
+          variables: true,
+          source: {
+            type: 'query',
+            name: 'getDynamicData',
+            arguments: [
+              {
+                name: 'key',
+                value: 'listAssignees',
+              },
+              {
+                name: 'parameters.listId',
+                value: '{parameters.listId}',
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      label: 'Task Status',
+      key: 'taskStatus',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.listId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listStatuses',
+          },
+          {
+            name: 'parameters.listId',
+            value: '{parameters.listId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Tags',
+      key: 'tagIds',
+      type: 'dynamic',
+      required: false,
+      description: '',
+      fields: [
+        {
+          label: 'tag',
+          key: 'tagId',
+          type: 'dropdown',
+          required: false,
+          variables: true,
+          source: {
+            type: 'query',
+            name: 'getDynamicData',
+            arguments: [
+              {
+                name: 'key',
+                value: 'listTags',
+              },
+            ],
+          },
+        },
+      ],
+    },
+    {
+      label: 'Priority',
+      key: 'priority',
+      type: 'dropdown',
+      required: false,
+      description: '',
+      variables: true,
+      options: [
+        { label: 'Urgent', value: 1 },
+        { label: 'High', value: 2 },
+        { label: 'Normal', value: 3 },
+        { label: 'Low', value: 4 },
+      ],
+    },
+    {
+      label: 'Due Date',
+      key: 'dueDate',
+      type: 'string',
+      required: false,
+      description: 'format: integer <int64>',
+      variables: true,
+    },
+    {
+      label: 'Start Date',
+      key: 'startDate',
+      type: 'string',
+      required: false,
+      description: 'format: integer <int64>',
+      variables: true,
+    },
+  ],
+
+  async run($) {
+    const {
+      listId,
+      taskName,
+      taskDescription,
+      markdownContent,
+      assigneeIds,
+      taskStatus,
+      tagIds,
+      priority,
+      dueDate,
+      startDate,
+    } = $.step.parameters;
+
+    const tags = tagIds.map((tag) => tag.tagId);
+    const assignees = assigneeIds.map((assignee) =>
+      Number(assignee.assigneeId)
+    );
+
+    const body = {
+      name: taskName,
+    };
+
+    if (assignees.length) {
+      body.assignees = assignees;
+    }
+
+    if (taskStatus) {
+      body.status = taskStatus;
+    }
+
+    if (tags.length) {
+      body.tags = tags;
+    }
+
+    if (priority) {
+      body.priority = priority;
+    }
+
+    if (dueDate) {
+      body.due_date = dueDate;
+    }
+
+    if (startDate) {
+      body.start_date = startDate;
+    }
+
+    if (markdownContent) {
+      body.markdown_description = taskDescription;
+    } else {
+      body.description = taskDescription;
+    }
+
+    const { data } = await $.http.post(`/v2/list/${listId}/task`, body);
+
+    $.setActionItem({
+      raw: data,
+    });
+  },
+});

packages/backend/src/apps/clickup/actions/find-task-by-id/index.js

@@ -0,0 +1,82 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Find task by id',
+  key: 'findTaskById',
+  description: 'Finds a task using id.',
+  arguments: [
+    {
+      label: 'Task ID',
+      key: 'taskId',
+      type: 'string',
+      required: true,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'Use Custom ID',
+      key: 'useCustomId',
+      type: 'dropdown',
+      required: false,
+      description: '',
+      variables: true,
+      options: [
+        {
+          label: 'True',
+          value: true,
+        },
+        {
+          label: 'False',
+          value: false,
+        },
+      ],
+      additionalFields: {
+        type: 'query',
+        name: 'getDynamicFields',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listFieldsWhenUsingCustomId',
+          },
+          {
+            name: 'parameters.useCustomId',
+            value: '{parameters.useCustomId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Include Subtasks?',
+      key: 'includeSubtasks',
+      type: 'dropdown',
+      required: false,
+      description: '',
+      variables: true,
+      options: [
+        {
+          label: 'True',
+          value: true,
+        },
+        {
+          label: 'False',
+          value: false,
+        },
+      ],
+    },
+  ],
+
+  async run($) {
+    const { taskId, useCustomId, includeSubtasks } = $.step.parameters;
+
+    const params = {
+      custom_task_ids: useCustomId || false,
+      include_subtasks: includeSubtasks,
+    };
+
+    const { data } = await $.http.get(`/v2/task/${taskId}`, { params });
+
+    $.setActionItem({
+      raw: data,
+    });
+  },
+});

packages/backend/src/apps/clickup/actions/index.js

@@ -0,0 +1,6 @@
+import createFolder from './create-folder/index.js';
+import createList from './create-list/index.js';
+import createTask from './create-task/index.js';
+import findTaskById from './find-task-by-id/index.js';
+
+export default [createFolder, createList, createTask, findTaskById];

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

@@ -0,0 +1,27 @@
+<svg width="185" height="185" viewBox="0 0 185 185" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g filter="url(#filter0_d)">
+<rect x="30" y="20" width="125" height="125" rx="62.5" fill="white"/>
+<rect x="30" y="20" width="125" height="125" rx="62.5" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M55.8789 105.714L69.3974 95.3593C76.5762 104.732 84.1998 109.051 92.6948 109.051C101.143 109.051 108.557 104.781 115.414 95.4832L129.119 105.59C119.232 118.996 106.932 126.079 92.6948 126.079C78.5049 126.079 66.0907 119.046 55.8789 105.714Z" fill="url(#paint0_linear)"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M92.6491 60.7078L68.5883 81.4406L57.4727 68.5407L92.6969 38.1885L127.647 68.5644L116.477 81.417L92.6491 60.7078Z" fill="url(#paint1_linear)"/>
+</g>
+<defs>
+<filter id="filter0_d" x="0" y="0" width="185" height="185" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
+<feFlood flood-opacity="0" result="BackgroundImageFix"/>
+<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0"/>
+<feOffset dy="10"/>
+<feGaussianBlur stdDeviation="15"/>
+<feColorMatrix type="matrix" values="0 0 0 0 0.0627451 0 0 0 0 0.117647 0 0 0 0 0.211765 0 0 0 0.1 0"/>
+<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow"/>
+<feBlend mode="normal" in="SourceGraphic" in2="effect1_dropShadow" result="shape"/>
+</filter>
+<linearGradient id="paint0_linear" x1="55.8789" y1="116.251" x2="129.119" y2="116.251" gradientUnits="userSpaceOnUse">
+<stop stop-color="#8930FD"/>
+<stop offset="1" stop-color="#49CCF9"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="57.4727" y1="67.6025" x2="127.647" y2="67.6025" gradientUnits="userSpaceOnUse">
+<stop stop-color="#FF02F0"/>
+<stop offset="1" stop-color="#FFC800"/>
+</linearGradient>
+</defs>
+</svg>

packages/backend/src/apps/clickup/auth/generate-auth-url.js

@@ -0,0 +1,21 @@
+import { URLSearchParams } from 'url';
+
+export default async function generateAuthUrl($) {
+  const oauthRedirectUrlField = $.app.auth.fields.find(
+    (field) => field.key == 'oAuthRedirectUrl'
+  );
+  const redirectUri = oauthRedirectUrlField.value;
+  const state = Math.random().toString();
+  const searchParams = new URLSearchParams({
+    client_id: $.auth.data.clientId,
+    redirect_uri: redirectUri,
+    state,
+  });
+
+  const url = `https://app.clickup.com/api?${searchParams.toString()}`;
+
+  await $.auth.set({
+    url,
+    originalState: state,
+  });
+}

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

@@ -0,0 +1,46 @@
+import generateAuthUrl from './generate-auth-url.js';
+import verifyCredentials from './verify-credentials.js';
+import isStillVerified from './is-still-verified.js';
+
+export default {
+  fields: [
+    {
+      key: 'oAuthRedirectUrl',
+      label: 'OAuth Redirect URL',
+      type: 'string',
+      required: true,
+      readOnly: true,
+      value: '{WEB_APP_URL}/app/clickup/connections/add',
+      placeholder: null,
+      description:
+        'When asked to input a redirect URL in ClickUp, enter the URL above.',
+      clickToCopy: true,
+    },
+    {
+      key: 'clientId',
+      label: 'Client ID',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: null,
+      clickToCopy: false,
+    },
+    {
+      key: 'clientSecret',
+      label: 'Client Secret',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: null,
+      clickToCopy: false,
+    },
+  ],
+
+  generateAuthUrl,
+  verifyCredentials,
+  isStillVerified,
+};

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

@@ -0,0 +1,8 @@
+import getCurrentUser from '../common/get-current-user.js';
+
+const isStillVerified = async ($) => {
+  const currentUser = await getCurrentUser($);
+  return !!currentUser.id;
+};
+
+export default isStillVerified;

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

@@ -0,0 +1,31 @@
+import getCurrentUser from '../common/get-current-user.js';
+
+const verifyCredentials = async ($) => {
+  if ($.auth.data.originalState !== $.auth.data.state) {
+    throw new Error(`The 'state' parameter does not match.`);
+  }
+
+  const { data } = await $.http.post('/v2/oauth/token', {
+    client_id: $.auth.data.clientId,
+    client_secret: $.auth.data.clientSecret,
+    code: $.auth.data.code,
+  });
+
+  await $.auth.set({
+    accessToken: data.access_token,
+    tokenType: data.token_type,
+  });
+
+  const currentUser = await getCurrentUser($);
+  const screenName = [currentUser.username, currentUser.email]
+    .filter(Boolean)
+    .join(' @ ');
+
+  await $.auth.set({
+    clientId: $.auth.data.clientId,
+    clientSecret: $.auth.data.clientSecret,
+    screenName,
+  });
+};
+
+export default verifyCredentials;

packages/backend/src/apps/clickup/common/add-auth-header.js

@@ -0,0 +1,9 @@
+const addAuthHeader = ($, requestConfig) => {
+  if ($.auth.data?.accessToken) {
+    requestConfig.headers.Authorization = `${$.auth.data.tokenType} ${$.auth.data.accessToken}`;
+  }
+
+  return requestConfig;
+};
+
+export default addAuthHeader;

packages/backend/src/apps/clickup/common/get-current-user.js

@@ -0,0 +1,6 @@
+const getCurrentUser = async ($) => {
+  const { data } = await $.http.get('/v2/user');
+  return data.user;
+};
+
+export default getCurrentUser;

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

@@ -0,0 +1,19 @@
+import listAssignees from './list-assignees/index.js';
+import listFolders from './list-folders/index.js';
+import listLists from './list-lists/index.js';
+import listSpaces from './list-spaces/index.js';
+import listStatuses from './list-statuses/index.js';
+import listTags from './list-tags/index.js';
+import listTasks from './list-tasks/index.js';
+import listWorkspaces from './list-workspaces/index.js';
+
+export default [
+  listAssignees,
+  listFolders,
+  listLists,
+  listSpaces,
+  listStatuses,
+  listTags,
+  listTasks,
+  listWorkspaces,
+];

packages/backend/src/apps/clickup/dynamic-data/list-assignees/index.js

@@ -0,0 +1,28 @@
+export default {
+  name: 'List assignees',
+  key: 'listAssignees',
+
+  async run($) {
+    const assignees = {
+      data: [],
+    };
+    const listId = $.step.parameters.listId;
+
+    if (!listId) {
+      return assignees;
+    }
+
+    const { data } = await $.http.get(`/v2/list/${listId}/member`);
+
+    if (data.members) {
+      for (const member of data.members) {
+        assignees.data.push({
+          value: member.id,
+          name: member.username,
+        });
+      }
+    }
+
+    return assignees;
+  },
+};

packages/backend/src/apps/clickup/dynamic-data/list-folders/index.js

@@ -0,0 +1,28 @@
+export default {
+  name: 'List folders',
+  key: 'listFolders',
+
+  async run($) {
+    const folders = {
+      data: [],
+    };
+    const spaceId = $.step.parameters.spaceId;
+
+    if (!spaceId) {
+      return folders;
+    }
+
+    const { data } = await $.http.get(`/v2/space/${spaceId}/folder`);
+
+    if (data.folders) {
+      for (const folder of data.folders) {
+        folders.data.push({
+          value: folder.id,
+          name: folder.name,
+        });
+      }
+    }
+
+    return folders;
+  },
+};

packages/backend/src/apps/clickup/dynamic-data/list-lists/index.js

@@ -0,0 +1,28 @@
+export default {
+  name: 'List lists',
+  key: 'listLists',
+
+  async run($) {
+    const lists = {
+      data: [],
+    };
+    const folderId = $.step.parameters.folderId;
+
+    if (!folderId) {
+      return lists;
+    }
+
+    const { data } = await $.http.get(`/v2/folder/${folderId}/list`);
+
+    if (data.lists) {
+      for (const list of data.lists) {
+        lists.data.push({
+          value: list.id,
+          name: list.name,
+        });
+      }
+    }
+
+    return lists;
+  },
+};

packages/backend/src/apps/clickup/dynamic-data/list-spaces/index.js

@@ -0,0 +1,28 @@
+export default {
+  name: 'List spaces',
+  key: 'listSpaces',
+
+  async run($) {
+    const spaces = {
+      data: [],
+    };
+    const workspaceId = $.step.parameters.workspaceId;
+
+    if (!workspaceId) {
+      return spaces;
+    }
+
+    const { data } = await $.http.get(`/v2/team/${workspaceId}/space`);
+
+    if (data.spaces) {
+      for (const space of data.spaces) {
+        spaces.data.push({
+          value: space.id,
+          name: space.name,
+        });
+      }
+    }
+
+    return spaces;
+  },
+};

packages/backend/src/apps/clickup/dynamic-data/list-statuses/index.js

@@ -0,0 +1,28 @@
+export default {
+  name: 'List statuses',
+  key: 'listStatuses',
+
+  async run($) {
+    const statuses = {
+      data: [],
+    };
+    const listId = $.step.parameters.listId;
+
+    if (!listId) {
+      return statuses;
+    }
+
+    const { data } = await $.http.get(`/v2/list/${listId}`);
+
+    if (data.statuses) {
+      for (const status of data.statuses) {
+        statuses.data.push({
+          value: status.status,
+          name: status.status,
+        });
+      }
+    }
+
+    return statuses;
+  },
+};

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

@@ -0,0 +1,28 @@
+export default {
+  name: 'List tags',
+  key: 'listTags',
+
+  async run($) {
+    const tags = {
+      data: [],
+    };
+    const spaceId = $.step.parameters.spaceId;
+
+    if (!spaceId) {
+      return spaceId;
+    }
+
+    const { data } = await $.http.get(`v2/space/${spaceId}/tag`);
+
+    if (data.tags) {
+      for (const tag of data.tags) {
+        tags.data.push({
+          value: tag.name,
+          name: tag.name,
+        });
+      }
+    }
+
+    return tags;
+  },
+};

packages/backend/src/apps/clickup/dynamic-data/list-tasks/index.js

@@ -0,0 +1,41 @@
+export default {
+  name: 'List tasks',
+  key: 'listTasks',
+
+  async run($) {
+    const tasks = {
+      data: [],
+    };
+    const listId = $.step.parameters.listId;
+    let next = false;
+
+    if (!listId) {
+      return tasks;
+    }
+
+    const params = {
+      order_by: 'created',
+      reverse: true,
+    };
+
+    do {
+      const { data } = await $.http.get(`/v2/list/${listId}/task`, { params });
+      if (data.last_page) {
+        next = false;
+      } else {
+        next = true;
+      }
+
+      if (data.tasks) {
+        for (const task of data.tasks) {
+          tasks.data.push({
+            value: task.id,
+            name: task.name,
+          });
+        }
+      }
+    } while (next);
+
+    return tasks;
+  },
+};

packages/backend/src/apps/clickup/dynamic-data/list-workspaces/index.js

@@ -0,0 +1,23 @@
+export default {
+  name: 'List workspaces',
+  key: 'listWorkspaces',
+
+  async run($) {
+    const workspaces = {
+      data: [],
+    };
+
+    const { data } = await $.http.get('/v2/team');
+
+    if (data.teams) {
+      for (const workspace of data.teams) {
+        workspaces.data.push({
+          value: workspace.id,
+          name: workspace.name,
+        });
+      }
+    }
+
+    return workspaces;
+  },
+};

packages/backend/src/apps/clickup/dynamic-fields/index.js

@@ -0,0 +1,3 @@
+import useCustomId from './use-custom-id/index.js';
+
+export default [useCustomId];

packages/backend/src/apps/clickup/dynamic-fields/use-custom-id/index.js

@@ -0,0 +1,29 @@
+export default {
+  name: 'List workspaces when using custom id',
+  key: 'listFieldsWhenUsingCustomId',
+
+  async run($) {
+    if ($.step.parameters.useCustomId) {
+      return [
+        {
+          label: 'Workspace',
+          key: 'workspaceId',
+          type: 'dropdown',
+          required: true,
+          description: '',
+          variables: true,
+          source: {
+            type: 'query',
+            name: 'getDynamicData',
+            arguments: [
+              {
+                name: 'key',
+                value: 'listWorkspaces',
+              },
+            ],
+          },
+        },
+      ];
+    }
+  },
+};

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

@@ -0,0 +1,24 @@
+import defineApp from '../../helpers/define-app.js';
+import addAuthHeader from './common/add-auth-header.js';
+import auth from './auth/index.js';
+import triggers from './triggers/index.js';
+import dynamicData from './dynamic-data/index.js';
+import actions from './actions/index.js';
+import dynamicFields from './dynamic-fields/index.js';
+
+export default defineApp({
+  name: 'ClickUp',
+  key: 'clickup',
+  baseUrl: 'https://clickup.com',
+  apiBaseUrl: 'https://api.clickup.com/api',
+  iconUrl: '{BASE_URL}/apps/clickup/assets/favicon.svg',
+  authDocUrl: 'https://automatisch.io/docs/apps/clickup/connection',
+  primaryColor: 'FD71AF',
+  supportsConnections: true,
+  beforeRequest: [addAuthHeader],
+  auth,
+  triggers,
+  dynamicData,
+  actions,
+  dynamicFields,
+});

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

@@ -0,0 +1,6 @@
+import newFolders from './new-folders/index.js';
+import newLists from './new-lists/index.js';
+import newTasks from './new-tasks/index.js';
+import updatedTask from './updated-task/index.js';
+
+export default [newFolders, newLists, newTasks, updatedTask];

packages/backend/src/apps/clickup/triggers/new-folders/index.js

@@ -0,0 +1,105 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New folders',
+  key: 'newFolder',
+  type: 'webhook',
+  description: 'Triggers when a new folder is created.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: $.request.body.folder_id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const sampleEventData = {
+      event: 'folderCreated',
+      folder_id: '90180382912',
+      webhook_id: Crypto.randomUUID(),
+    };
+
+    const dataItem = {
+      raw: sampleEventData,
+      meta: {
+        internalId: '',
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const { workspaceId, spaceId } = $.step.parameters;
+
+    const payload = {
+      name: $.flow.id,
+      endpoint: $.webhookUrl,
+      events: ['folderCreated'],
+    };
+
+    if (spaceId) {
+      payload.space_id = spaceId;
+    }
+
+    const { data } = await $.http.post(
+      `/v2/team/${workspaceId}/webhook`,
+      payload
+    );
+
+    await $.flow.setRemoteWebhookId(data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/v2/webhook/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/apps/clickup/triggers/new-lists/index.js

@@ -0,0 +1,129 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New lists',
+  key: 'newLists',
+  type: 'webhook',
+  description: 'Triggers when a new list is created.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Folder',
+      key: 'folderId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.spaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listFolders',
+          },
+          {
+            name: 'parameters.spaceId',
+            value: '{parameters.spaceId}',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: $.request.body.list_id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const sampleEventData = {
+      event: 'listCreated',
+      list_id: '901800588812',
+      webhook_id: Crypto.randomUUID(),
+    };
+
+    const dataItem = {
+      raw: sampleEventData,
+      meta: {
+        internalId: sampleEventData.webhook_id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const { workspaceId, spaceId, folderId } = $.step.parameters;
+
+    const payload = {
+      name: $.flow.id,
+      endpoint: $.webhookUrl,
+      events: ['listCreated'],
+      space_id: spaceId,
+    };
+
+    if (folderId) {
+      payload.folder_id = folderId;
+    }
+
+    const { data } = await $.http.post(
+      `/v2/team/${workspaceId}/webhook`,
+      payload
+    );
+
+    await $.flow.setRemoteWebhookId(data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/v2/webhook/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/apps/clickup/triggers/new-tasks/index.js

@@ -0,0 +1,186 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New tasks',
+  key: 'newTasks',
+  type: 'webhook',
+  description: 'Triggers when a new task is created.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Folder',
+      key: 'folderId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.spaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listFolders',
+          },
+          {
+            name: 'parameters.spaceId',
+            value: '{parameters.spaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'List',
+      key: 'listId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.folderId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listLists',
+          },
+          {
+            name: 'parameters.folderId',
+            value: '{parameters.folderId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Task',
+      key: 'taskId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.listId'],
+      description:
+        'Choose an optional task to determine when this flow should be activated. In this scenario, only subtasks will initiate this flow.',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listTasks',
+          },
+          {
+            name: 'parameters.listId',
+            value: '{parameters.listId}',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: $.request.body.task_id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const sampleEventData = {
+      event: 'taskCreated',
+      task_id: '86enn7pg7',
+      webhook_id: Crypto.randomUUID(),
+      history_items: [],
+    };
+
+    const dataItem = {
+      raw: sampleEventData,
+      meta: {
+        internalId: sampleEventData.webhook_id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const { workspaceId, spaceId, folderId, listId, taskId } =
+      $.step.parameters;
+
+    const payload = {
+      name: $.flow.id,
+      endpoint: $.webhookUrl,
+      events: ['taskCreated'],
+      space_id: spaceId,
+    };
+
+    if (folderId) {
+      payload.folder_id = folderId;
+    }
+
+    if (listId) {
+      payload.list_id = listId;
+    }
+
+    if (taskId) {
+      payload.task_id = taskId;
+    }
+
+    const { data } = await $.http.post(
+      `/v2/team/${workspaceId}/webhook`,
+      payload
+    );
+
+    await $.flow.setRemoteWebhookId(data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/v2/webhook/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/apps/clickup/triggers/updated-task/index.js

@@ -0,0 +1,172 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'Updated task',
+  key: 'updatedTask',
+  type: 'webhook',
+  description: 'Triggers when a task is updated.',
+  arguments: [
+    {
+      label: 'Workspace',
+      key: 'workspaceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listWorkspaces',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Space',
+      key: 'spaceId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.workspaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpaces',
+          },
+          {
+            name: 'parameters.workspaceId',
+            value: '{parameters.workspaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Folder',
+      key: 'folderId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.spaceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listFolders',
+          },
+          {
+            name: 'parameters.spaceId',
+            value: '{parameters.spaceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'List',
+      key: 'listId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.folderId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listLists',
+          },
+          {
+            name: 'parameters.folderId',
+            value: '{parameters.folderId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'What Changed?',
+      key: 'whatChanged',
+      type: 'dropdown',
+      required: false,
+      variables: true,
+      options: [
+        { label: 'Status', value: 'taskStatusUpdated' },
+        { label: 'Assignee Added', value: 'taskAssigneeUpdated' },
+        { label: 'Priority', value: 'taskPriorityUpdated' },
+        { label: 'Tag Added', value: 'taskTagUpdated' },
+      ],
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const sampleEventData = {
+      event: 'taskUpdated',
+      task_id: '86enn7pg7',
+      webhook_id: Crypto.randomUUID(),
+      history_items: [],
+    };
+
+    const dataItem = {
+      raw: sampleEventData,
+      meta: {
+        internalId: sampleEventData.webhook_id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const { workspaceId, spaceId, folderId, listId, whatChanged } =
+      $.step.parameters;
+
+    const payload = {
+      name: $.flow.id,
+      endpoint: $.webhookUrl,
+      space_id: spaceId,
+    };
+
+    payload.events = [whatChanged || 'taskUpdated'];
+
+    if (folderId) {
+      payload.folder_id = folderId;
+    }
+
+    if (listId) {
+      payload.list_id = listId;
+    }
+
+    const { data } = await $.http.post(
+      `/v2/team/${workspaceId}/webhook`,
+      payload
+    );
+
+    await $.flow.setRemoteWebhookId(data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/v2/webhook/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/apps/code/actions/index.js

@@ -0,0 +1,3 @@
+import runJavascript from './run-javascript/index.js';
+
+export default [runJavascript];

packages/backend/src/apps/code/actions/run-javascript/index.js

@@ -0,0 +1,84 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Run Javascript',
+  key: 'runJavascript',
+  description:
+    'Run browser Javascript code. You can not use NodeJS specific features and npm packages.',
+  arguments: [
+    {
+      label: 'Inputs',
+      key: 'inputs',
+      type: 'dynamic',
+      required: false,
+      description:
+        'To be able to use data from previous steps, you need to expose them as input entries. You can access these input values in your code by using the `inputs` argument.',
+      value: [
+        {
+          key: '',
+          value: '',
+        },
+      ],
+      fields: [
+        {
+          label: 'Key',
+          key: 'key',
+          type: 'string',
+          required: true,
+          variables: true,
+        },
+        {
+          label: 'Value',
+          key: 'value',
+          type: 'string',
+          required: true,
+          variables: true,
+          valueType: 'parse',
+        },
+      ],
+    },
+    {
+      label: 'Code Snippet',
+      key: 'codeSnippet',
+      type: 'code',
+      required: true,
+      variables: false,
+      value:
+        'const code = async (inputs) => { \n  // E.g. if you have an input called username,\n  // you can access its value by calling inputs.username\n  // Return value will be used as output of this step.\n\n  return true;\n};',
+    },
+  ],
+
+  async run($) {
+    const { inputs = [], codeSnippet } = $.step.parameters;
+
+    const objectifiedInput = {};
+    for (const input of inputs) {
+      if (input.key) {
+        objectifiedInput[input.key] = input.value;
+      }
+    }
+
+    const ivm = (await import('isolated-vm')).default;
+    const isolate = new ivm.Isolate({ memoryLimit: 128 });
+
+    try {
+      const context = await isolate.createContext();
+      await context.global.set(
+        'inputs',
+        new ivm.ExternalCopy(objectifiedInput).copyInto()
+      );
+
+      const compiledCodeSnippet = await isolate.compileScript(
+        `${codeSnippet}; code(inputs);`
+      );
+      const codeFunction = await compiledCodeSnippet.run(context, {
+        reference: true,
+        promise: true,
+      });
+
+      $.setActionItem({ raw: { output: await codeFunction.copy() } });
+    } finally {
+      isolate.dispose();
+    }
+  },
+});

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

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="800px" height="800px" viewBox="0 0 512 512">
+  <polyline points="160 368 32 256 160 144" style="fill:none;stroke:#000000;stroke-linecap:round;stroke-linejoin:round;stroke-width:32px"/>
+  <polyline points="352 368 480 256 352 144" style="fill:none;stroke:#000000;stroke-linecap:round;stroke-linejoin:round;stroke-width:32px"/>
+  <line x1="304" y1="96" x2="208" y2="416" style="fill:none;stroke:#000000;stroke-linecap:round;stroke-linejoin:round;stroke-width:32px"/>
+</svg>

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

@@ -0,0 +1,14 @@
+import defineApp from '../../helpers/define-app.js';
+import actions from './actions/index.js';
+
+export default defineApp({
+  name: 'Code',
+  key: 'code',
+  baseUrl: '',
+  apiBaseUrl: '',
+  iconUrl: '{BASE_URL}/apps/code/assets/favicon.svg',
+  authDocUrl: '{DOCS_URL}/apps/code/connection',
+  primaryColor: '000000',
+  supportsConnections: false,
+  actions,
+});

packages/backend/src/apps/github/actions/create-issue/index.js

@@ -10,7 +10,7 @@ export default defineAction({
       label: 'Repo',
       key: 'repo',
       type: 'dropdown',
-      required: false,
+      required: true,
       variables: true,
       source: {
         type: 'query',

packages/backend/src/apps/google-sheets/actions/find-worksheet/index.js

@@ -0,0 +1,175 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Find worksheet',
+  key: 'findWorksheet',
+  description:
+    'Finds a worksheet by title. Optionally, create a worksheet if none are found.',
+  arguments: [
+    {
+      label: 'Drive',
+      key: 'driveId',
+      type: 'dropdown',
+      required: false,
+      description:
+        'The Google Drive where your spreadsheet resides. If nothing is selected, then your personal Google Drive will be used.',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listDrives',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Spreadsheet',
+      key: 'spreadsheetId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.driveId'],
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSpreadsheets',
+          },
+          {
+            name: 'parameters.driveId',
+            value: '{parameters.driveId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Title',
+      key: 'title',
+      type: 'string',
+      required: true,
+      description:
+        'The worksheet title needs to match exactly, and the search is case-sensitive.',
+      variables: true,
+    },
+    {
+      label: 'Create worksheet if none are found.',
+      key: 'createWorksheet',
+      type: 'dropdown',
+      required: false,
+      options: [
+        { label: 'Yes', value: true },
+        { label: 'No', value: false },
+      ],
+      additionalFields: {
+        type: 'query',
+        name: 'getDynamicFields',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listCreateWorksheetFields',
+          },
+          {
+            name: 'parameters.createWorksheet',
+            value: '{parameters.createWorksheet}',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const createWorksheet = $.step.parameters.createWorksheet;
+
+    async function findWorksheet() {
+      const {
+        data: { sheets },
+      } = await $.http.get(`/v4/spreadsheets/${$.step.parameters.spreadsheetId}`);
+
+      const selectedSheet = sheets.find(
+        (sheet) => sheet.properties.title === $.step.parameters.title
+      );
+
+      return selectedSheet;
+    }
+
+    const selectedSheet = await findWorksheet();
+
+    if (selectedSheet) {
+      $.setActionItem({
+        raw: selectedSheet,
+      });
+
+      return;
+    }
+
+    if (createWorksheet) {
+      const headers = $.step.parameters.headers;
+      const headerValues = headers.map((entry) => entry.header);
+
+      const body = {
+        requests: [
+          {
+            addSheet: {
+              properties: {
+                title: $.step.parameters.title,
+              },
+            },
+          },
+        ],
+      };
+
+      const { data } = await $.http.post(
+        `/v4/spreadsheets/${$.step.parameters.spreadsheetId}:batchUpdate`,
+        body
+      );
+
+      if (headerValues.length) {
+        const body = {
+          requests: [
+            {
+              updateCells: {
+                rows: [
+                  {
+                    values: headerValues.map((header) => ({
+                      userEnteredValue: { stringValue: header },
+                    })),
+                  },
+                ],
+                fields: '*',
+                start: {
+                  sheetId:
+                    data.replies[data.replies.length - 1].addSheet.properties
+                      .sheetId,
+                  rowIndex: 0,
+                  columnIndex: 0,
+                },
+              },
+            },
+          ],
+        };
+
+        await $.http.post(
+          `/v4/spreadsheets/${$.step.parameters.spreadsheetId}:batchUpdate`,
+          body
+        );
+
+        const createdSheet = await findWorksheet();
+
+        $.setActionItem({
+          raw: createdSheet,
+        });
+
+        return;
+      }
+    }
+
+    $.setActionItem({
+      raw: null,
+    });
+  },
+});

packages/backend/src/apps/google-sheets/actions/index.js

@@ -1,5 +1,11 @@
 import createSpreadsheet from './create-spreadsheet/index.js';
 import createSpreadsheetRow from './create-spreadsheet-row/index.js';
 import createWorksheet from './create-worksheet/index.js';
+import findWorksheet from './find-worksheet/index.js';
 
-export default [createSpreadsheet, createSpreadsheetRow, createWorksheet];
+export default [
+  createSpreadsheet,
+  createSpreadsheetRow,
+  createWorksheet,
+  findWorksheet,
+];

packages/backend/src/apps/google-sheets/dynamic-fields/index.js

@@ -1,3 +1,4 @@
 import listSheetHeaders from './list-sheet-headers/index.js';
+import listCreateWorksheetFields from './list-create-worksheet-fields/index.js';
 
-export default [listSheetHeaders];
+export default [listSheetHeaders, listCreateWorksheetFields];

packages/backend/src/apps/google-sheets/dynamic-fields/list-create-worksheet-fields/index.js

@@ -0,0 +1,26 @@
+export default {
+  name: 'List create worksheet fields',
+  key: 'listCreateWorksheetFields',
+
+  async run($) {
+    if ($.step.parameters.createWorksheet) {
+      return [
+        {
+          label: 'Headers',
+          key: 'headers',
+          type: 'dynamic',
+          required: false,
+          fields: [
+            {
+              label: 'Header',
+              key: 'header',
+              type: 'string',
+              required: true,
+              variables: true,
+            },
+          ],
+        },
+      ];
+    }
+  },
+};

packages/backend/src/apps/http-request/actions/custom-request/index.js

@@ -145,6 +145,13 @@ export default defineAction({
       responseData = Buffer.from(responseData).toString('base64');
     }
 
-    $.setActionItem({ raw: { data: responseData } });
+    $.setActionItem({
+      raw: {
+        data: responseData,
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText
+      }
+    });
   },
 });

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

@@ -0,0 +1 @@
+<svg xmlns:xlink="http://www.w3.org/1999/xlink" class="jff-logo-img" width="53" height="59" viewBox="0 0 53 59" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"><path d="M14.4509 55.1332C15.5462 56.1951 14.7721 58.0143 13.2168 58.0143H3.4831C1.56265 58.0143 0 56.4995 0 54.6377V45.2017C0 43.6939 1.87664 42.9436 2.97195 44.0054L14.4509 55.1332Z" fill="#0A1551"></path><path d="M29.6655 55.8676C26.7843 53.0052 26.7843 48.3642 29.6655 45.5018L40.0638 35.1713C42.945 32.3089 47.6164 32.3089 50.4976 35.1713C53.3788 38.0338 53.3788 42.6747 50.4976 45.5371L40.0993 55.8676C37.2181 58.73 32.5468 58.73 29.6655 55.8676Z" fill="#FFB629"></path><path d="M2.1968 29.9101C-0.684414 27.0476 -0.684413 22.4067 2.1968 19.5443L19.696 2.14685C22.5772 -0.71559 27.2486 -0.715594 30.1298 2.14685C33.011 5.00929 33.011 9.65022 30.1298 12.5127L12.6306 29.9101C9.74937 32.7725 5.078 32.7725 2.1968 29.9101Z" fill="#0099FF"></path><path d="M16.5015 42.3095C13.6203 39.4471 13.6203 34.8062 16.5015 31.9437L40.1461 8.45322C43.0273 5.59079 47.6986 5.59079 50.5798 8.45322C53.4611 11.3157 53.4611 15.9566 50.5798 18.819L26.9353 42.3095C24.0541 45.1719 19.3827 45.1719 16.5015 42.3095Z" fill="#FF6100"></path></svg>

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

@@ -0,0 +1,30 @@
+import verifyCredentials from './verify-credentials.js';
+import isStillVerified from './is-still-verified.js';
+
+export default {
+  fields: [
+    {
+      key: 'apiUrl',
+      label: 'API URL',
+      type: 'string',
+      required: false,
+      readOnly: false,
+      value: 'https://api.jotform.com',
+      placeholder: 'https://${subdomain}.jotform.com/api',
+      clickToCopy: true,
+    },
+    {
+      key: 'apiKey',
+      label: 'API Key',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      clickToCopy: false,
+    },
+  ],
+
+  verifyCredentials,
+  isStillVerified,
+};

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

@@ -0,0 +1,8 @@
+import getCurrentUser from '../common/get-current-user.js';
+
+const isStillVerified = async ($) => {
+  const user = await getCurrentUser($);
+  return !!user.username;
+};
+
+export default isStillVerified;

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

@@ -0,0 +1,12 @@
+import getCurrentUser from '../common/get-current-user.js';
+
+const verifyCredentials = async ($) => {
+  const user = await getCurrentUser($);
+
+  await $.auth.set({
+    screenName: user.name,
+    apiKey: $.auth.data.apiKey,
+  });
+};
+
+export default verifyCredentials;

packages/backend/src/apps/jotform/common/add-auth-header.js

@@ -0,0 +1,9 @@
+const addAuthHeader = ($, requestConfig) => {
+  if ($.auth.data?.apiKey) {
+    requestConfig.headers['APIKEY'] = `${$.auth.data.apiKey}`;
+  }
+
+  return requestConfig;
+};
+
+export default addAuthHeader;

packages/backend/src/apps/jotform/common/get-current-user.js

@@ -0,0 +1,7 @@
+const getCurrentUser = async ($) => {
+  const response = await $.http.get('/user');
+  const currentUser = response.data.content;
+  return currentUser;
+};
+
+export default getCurrentUser;

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

@@ -0,0 +1,11 @@
+const setBaseUrl = ($, requestConfig) => {
+  if ($.auth.data.apiUrl) {
+    requestConfig.baseURL = $.auth.data.apiUrl;
+  } else if ($.app.apiBaseUrl) {
+    requestConfig.baseURL = $.app.apiBaseUrl;
+  }
+
+  return requestConfig;
+};
+
+export default setBaseUrl;

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

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

packages/backend/src/apps/jotform/dynamic-data/list-forms/index.js

@@ -0,0 +1,41 @@
+export default {
+  name: 'List forms',
+  key: 'listForms',
+
+  async run($) {
+    const forms = {
+      data: [],
+    };
+    let hasMore = false;
+
+    const params = {
+      limit: 1000,
+      offset: 0,
+      orderby: 'created_at',
+    };
+
+    do {
+      const { data } = await $.http.get('/user/forms', { params });
+      params.offset = params.offset + params.limit;
+
+      if (data.content?.length) {
+        for (const form of data.content) {
+          if (form.status === 'ENABLED') {
+            forms.data.push({
+              value: form.id,
+              name: form.title,
+            });
+          }
+        }
+      }
+
+      if (data.resultSet.count >= data.resultSet.limit) {
+        hasMore = true;
+      } else {
+        hasMore = false;
+      }
+    } while (hasMore);
+
+    return forms;
+  },
+};

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

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

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

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

packages/backend/src/apps/jotform/triggers/new-submissions/index.js

@@ -0,0 +1,109 @@
+import Crypto from 'crypto';
+import { URLSearchParams } from 'url';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New submissions',
+  key: 'newSubmissions',
+  type: 'webhook',
+  description:
+    'Triggers when a new submission has been added to a specific form.',
+  arguments: [
+    {
+      label: 'Form',
+      key: 'formId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listForms',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const sampleEventData = {
+      ip: '127.0.0.1',
+      type: 'WEB',
+      appID: '',
+      event: '',
+      action: '',
+      formID: Crypto.randomUUID(),
+      parent: '',
+      pretty: 'Name:test, E-mail:user@automatisch.io',
+      teamID: '',
+      unread: '',
+      product: '',
+      subject: '',
+      isSilent: '',
+      username: 'username',
+      deviceIDs: 'Array',
+      formTitle: 'Opt-In Form-Get Free Email Updates!',
+      fromTable: '',
+      customBody: '',
+      documentID: '',
+      rawRequest: '',
+      webhookURL: '',
+      customTitle: '',
+      trackAction: 'Array',
+      customParams: '',
+      submissionID: Crypto.randomUUID(),
+      customBodyParams: 'Array',
+      customTitleParams: 'Array',
+    };
+
+    const dataItem = {
+      raw: sampleEventData,
+      meta: {
+        internalId: sampleEventData.submissionID,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const formId = $.step.parameters.formId;
+
+    const params = new URLSearchParams({
+      webhookURL: $.webhookUrl,
+    });
+
+    const { data } = await $.http.post(
+      `/form/${formId}/webhooks`,
+      params.toString()
+    );
+
+    await $.flow.setRemoteWebhookId(data.content[0]);
+  },
+
+  async unregisterHook($) {
+    const formId = $.step.parameters.formId;
+
+    const { data } = await $.http.get(`/form/${formId}/webhooks`);
+
+    const webhookURLs = Object.values(data.content);
+    const webhookId = webhookURLs.findIndex((url) => url === $.webhookUrl);
+
+    await $.http.delete(`/form/${formId}/webhooks/${webhookId}`);
+  },
+});

packages/backend/src/apps/mailchimp/actions/create-campaign/index.js

@@ -0,0 +1,180 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Create campaign',
+  key: 'createCampaign',
+  description: 'Creates a new campaign draft.',
+  arguments: [
+    {
+      label: 'Campaign Name',
+      key: 'campaignName',
+      type: 'string',
+      required: false,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'Audience',
+      key: 'audienceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listAudiences',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Segment or Tag',
+      key: 'segmentOrTagId',
+      type: 'dropdown',
+      required: false,
+      dependsOn: ['parameters.audienceId'],
+      description:
+        'Choose the specific segment or tag to which you"d like to direct the campaign. If no segment or tag is chosen, the campaign will be distributed to the entire audience previously selected.',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listSegmentsOrTags',
+          },
+          {
+            name: 'parameters.audienceId',
+            value: '{parameters.audienceId}',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Email Subject',
+      key: 'emailSubject',
+      type: 'string',
+      required: true,
+      description: '',
+      variables: true,
+    },
+    {
+      label: 'Preview Text',
+      key: 'previewText',
+      type: 'string',
+      required: false,
+      description:
+        'The snippet will be visible in the inbox following the subject line.',
+      variables: true,
+    },
+    {
+      label: 'From Name',
+      key: 'fromName',
+      type: 'string',
+      required: true,
+      description: 'The "from" name on the campaign (not an email address).',
+      variables: true,
+    },
+    {
+      label: 'From Email Address',
+      key: 'fromEmailAddress',
+      type: 'string',
+      required: true,
+      description: 'The reply-to email address for the campaign.',
+      variables: true,
+    },
+    {
+      label: 'To Name',
+      key: 'toName',
+      type: 'string',
+      required: false,
+      description:
+        'Supports *|MERGETAGS|* for recipient name, such as *|FNAME|*, *|LNAME|*, *|FNAME|* *|LNAME|*, etc.',
+      variables: true,
+    },
+    {
+      label: 'Template',
+      key: 'templateId',
+      type: 'dropdown',
+      required: false,
+      description:
+        'Select either a template or provide HTML email content, you cannot provide both. If both fields are left blank, the campaign draft will have no content.',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listTemplates',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Email Content (HTML)',
+      key: 'emailContent',
+      type: 'string',
+      required: false,
+      description:
+        'Select either a template or provide HTML email content, you cannot provide both. If both fields are left blank, the campaign draft will have no content.',
+      variables: true,
+    },
+  ],
+
+  async run($) {
+    const {
+      campaignName,
+      audienceId,
+      segmentOrTagId,
+      emailSubject,
+      previewText,
+      fromName,
+      fromEmailAddress,
+      toName,
+      templateId,
+      emailContent,
+    } = $.step.parameters;
+
+    const body = {
+      type: 'regular',
+      recipients: {
+        list_id: audienceId,
+        segment_opts: {
+          saved_segment_id: Number(segmentOrTagId),
+        },
+      },
+      settings: {
+        subject_line: emailSubject,
+        reply_to: fromEmailAddress,
+        title: campaignName,
+        preview_text: previewText,
+        from_name: fromName,
+        to_name: toName,
+      },
+    };
+
+    const { data: campaign } = await $.http.post('/3.0/campaigns', body);
+
+    const campaignBody = {
+      template: {
+        id: Number(templateId),
+      },
+      html: emailContent,
+    };
+
+    const { data } = await $.http.put(
+      `/3.0/campaigns/${campaign.id}/content`,
+      campaignBody
+    );
+
+    $.setActionItem({
+      raw: data,
+    });
+  },
+});

packages/backend/src/apps/mailchimp/actions/index.js

@@ -0,0 +1,4 @@
+import createCampaign from './create-campaign/index.js';
+import sendCampaign from './send-campaign/index.js';
+
+export default [createCampaign, sendCampaign];

packages/backend/src/apps/mailchimp/actions/send-campaign/index.js

@@ -0,0 +1,39 @@
+import defineAction from '../../../../helpers/define-action.js';
+
+export default defineAction({
+  name: 'Send campaign',
+  key: 'sendCampaign',
+  description: 'Sends a campaign draft.',
+  arguments: [
+    {
+      label: 'Campaign',
+      key: 'campaignId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listCampaigns',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const campaignId = $.step.parameters.campaignId;
+
+    await $.http.post(`/3.0/campaigns/${campaignId}/actions/send`);
+
+    $.setActionItem({
+      raw: {
+        output: 'sent',
+      },
+    });
+  },
+});

packages/backend/src/apps/mailchimp/auth/generate-auth-url.js

@@ -0,0 +1,19 @@
+import { URLSearchParams } from 'url';
+
+export default async function generateAuthUrl($) {
+  const oauthRedirectUrlField = $.app.auth.fields.find(
+    (field) => field.key == 'oAuthRedirectUrl'
+  );
+  const redirectUri = oauthRedirectUrlField.value;
+  const searchParams = new URLSearchParams({
+    response_type: 'code',
+    client_id: $.auth.data.clientId,
+    redirect_uri: redirectUri,
+  });
+
+  const url = `https://login.mailchimp.com/oauth2/authorize?${searchParams.toString()}`;
+
+  await $.auth.set({
+    url,
+  });
+}

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

@@ -0,0 +1,46 @@
+import generateAuthUrl from './generate-auth-url.js';
+import verifyCredentials from './verify-credentials.js';
+import isStillVerified from './is-still-verified.js';
+
+export default {
+  fields: [
+    {
+      key: 'oAuthRedirectUrl',
+      label: 'OAuth Redirect URL',
+      type: 'string',
+      required: true,
+      readOnly: true,
+      value: '{WEB_APP_URL}/app/mailchimp/connections/add',
+      placeholder: null,
+      description:
+        'When asked to input a redirect URL in Mailchimp, enter the URL above.',
+      clickToCopy: true,
+    },
+    {
+      key: 'clientId',
+      label: 'Client ID',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: null,
+      clickToCopy: false,
+    },
+    {
+      key: 'clientSecret',
+      label: 'Client Secret',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: null,
+      clickToCopy: false,
+    },
+  ],
+
+  generateAuthUrl,
+  verifyCredentials,
+  isStillVerified,
+};

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

@@ -0,0 +1,8 @@
+import getCurrentUser from '../common/get-current-user.js';
+
+const isStillVerified = async ($) => {
+  const currentUser = await getCurrentUser($);
+  return !!currentUser.user_id;
+};
+
+export default isStillVerified;

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

@@ -0,0 +1,40 @@
+import getCurrentUser from '../common/get-current-user.js';
+
+const verifyCredentials = async ($) => {
+  const oauthRedirectUrlField = $.app.auth.fields.find(
+    (field) => field.key == 'oAuthRedirectUrl'
+  );
+  const redirectUri = oauthRedirectUrlField.value;
+  const params = new URLSearchParams({
+    grant_type: 'authorization_code',
+    client_id: $.auth.data.clientId,
+    client_secret: $.auth.data.clientSecret,
+    redirect_uri: redirectUri,
+    code: $.auth.data.code,
+  });
+
+  const { data } = await $.http.post(
+    'https://login.mailchimp.com/oauth2/token',
+    params.toString()
+  );
+
+  await $.auth.set({
+    accessToken: data.access_token,
+    tokenType: data.token_type,
+  });
+
+  const currentUser = await getCurrentUser($);
+
+  await $.auth.set({
+    clientId: $.auth.data.clientId,
+    clientSecret: $.auth.data.clientSecret,
+    scope: $.auth.data.scope,
+    idToken: data.id_token,
+    expiresIn: data.expires_in,
+    refreshToken: data.refresh_token,
+    serverPrefix: currentUser.dc,
+    screenName: currentUser.login.login_name,
+  });
+};
+
+export default verifyCredentials;

packages/backend/src/apps/mailchimp/common/add-auth-header.js

@@ -0,0 +1,12 @@
+const addAuthHeader = ($, requestConfig) => {
+  if (
+    !requestConfig.additionalProperties?.skipAddingAuthHeader &&
+    $.auth.data?.accessToken
+  ) {
+    requestConfig.headers.Authorization = `Bearer ${$.auth.data.accessToken}`;
+  }
+
+  return requestConfig;
+};
+
+export default addAuthHeader;

packages/backend/src/apps/mailchimp/common/get-current-user.js

@@ -0,0 +1,18 @@
+const getCurrentUser = async ($) => {
+  const { data: currentUser } = await $.http.get(
+    'https://login.mailchimp.com/oauth2/metadata',
+    {
+      headers: {
+        Authorization: `OAuth ${$.auth.data.accessToken}`,
+      },
+      additionalProperties: {
+        skipAddingAuthHeader: true,
+        skipAddingBaseUrl: true,
+      },
+    }
+  );
+
+  return currentUser;
+};
+
+export default getCurrentUser;

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

@@ -0,0 +1,10 @@
+const setBaseUrl = ($, requestConfig) => {
+  const serverPrefix = $.auth.data.serverPrefix;
+  if (!requestConfig.additionalProperties?.skipAddingBaseUrl && serverPrefix) {
+    requestConfig.baseURL = `https://${serverPrefix}.api.mailchimp.com`;
+  }
+
+  return requestConfig;
+};
+
+export default setBaseUrl;

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

@@ -0,0 +1,6 @@
+import listAudiences from './list-audiences/index.js';
+import listCampaigns from './list-campaigns/index.js';
+import listTags from './list-segments-or-tags/index.js';
+import listTemplates from './list-templates/index.js';
+
+export default [listAudiences, listCampaigns, listTags, listTemplates];

packages/backend/src/apps/mailchimp/dynamic-data/list-audiences/index.js

@@ -0,0 +1,40 @@
+export default {
+  name: 'List audiences',
+  key: 'listAudiences',
+
+  async run($) {
+    const audiences = {
+      data: [],
+    };
+    let hasMore = false;
+
+    const params = {
+      sort_field: 'date_created',
+      sort_dir: 'DESC',
+      count: 1000,
+      offset: 0,
+    };
+
+    do {
+      const { data } = await $.http.get('/3.0/lists', { params });
+      params.offset = params.offset + params.count;
+
+      if (data?.lists) {
+        for (const audience of data.lists) {
+          audiences.data.push({
+            value: audience.id,
+            name: audience.name,
+          });
+        }
+      }
+
+      if (data.total_items > params.offset) {
+        hasMore = true;
+      } else {
+        hasMore = false;
+      }
+    } while (hasMore);
+
+    return audiences;
+  },
+};

packages/backend/src/apps/mailchimp/dynamic-data/list-campaigns/index.js

@@ -0,0 +1,42 @@
+export default {
+  name: 'List campaigns',
+  key: 'listCampaigns',
+
+  async run($) {
+    const campaigns = {
+      data: [],
+    };
+    let hasMore = false;
+    const audienceId = $.step.parameters.audienceId;
+
+    const params = {
+      list_id: audienceId,
+      sort_field: 'create_time',
+      sort_dir: 'DESC',
+      count: 1000,
+      offset: 0,
+    };
+
+    do {
+      const { data } = await $.http.get('/3.0/campaigns', { params });
+      params.offset = params.offset + params.count;
+
+      if (data?.campaigns) {
+        for (const campaign of data.campaigns) {
+          campaigns.data.push({
+            value: campaign.id,
+            name: campaign.settings.title || campaign.settings.subject_line || 'Unnamed campaign',
+          });
+        }
+      }
+
+      if (data.total_items > params.offset) {
+        hasMore = true;
+      } else {
+        hasMore = false;
+      }
+    } while (hasMore);
+
+    return campaigns;
+  },
+};

packages/backend/src/apps/mailchimp/dynamic-data/list-segments-or-tags/index.js

@@ -0,0 +1,44 @@
+export default {
+  name: 'List segments or tags',
+  key: 'listSegmentsOrTags',
+
+  async run($) {
+    const segmentsOrTags = {
+      data: [],
+    };
+    const audienceId = $.step.parameters.audienceId;
+
+    if (!audienceId) {
+      return segmentsOrTags;
+    }
+
+    const {
+      data: { tags: allTags },
+    } = await $.http.get(`/3.0/lists/${audienceId}/tag-search`);
+
+    const {
+      data: { segments },
+    } = await $.http.get(`/3.0/lists/${audienceId}/segments`);
+
+    const mergedArray = [...allTags, ...segments].reduce(
+      (accumulator, current) => {
+        if (!accumulator.some((item) => item.id === current.id)) {
+          accumulator.push(current);
+        }
+        return accumulator;
+      },
+      []
+    );
+
+    if (mergedArray?.length) {
+      for (const tagOrSegment of mergedArray) {
+        segmentsOrTags.data.push({
+          value: tagOrSegment.id,
+          name: tagOrSegment.name,
+        });
+      }
+    }
+
+    return segmentsOrTags;
+  },
+};

packages/backend/src/apps/mailchimp/dynamic-data/list-templates/index.js

@@ -0,0 +1,30 @@
+export default {
+  name: 'List templates',
+  key: 'listTemplates',
+
+  async run($) {
+    const templates = {
+      data: [],
+    };
+
+    const params = {
+      sort_field: 'date_created',
+      sort_dir: 'DESC',
+      count: 1000,
+      offset: 0,
+    };
+
+    const { data } = await $.http.get('/3.0/templates', { params });
+
+    if (data?.templates) {
+      for (const template of data.templates) {
+        templates.data.push({
+          value: template.id,
+          name: template.name,
+        });
+      }
+    }
+
+    return templates;
+  },
+};

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

@@ -0,0 +1,23 @@
+import defineApp from '../../helpers/define-app.js';
+import addAuthHeader from './common/add-auth-header.js';
+import setBaseUrl from './common/set-base-url.js';
+import auth from './auth/index.js';
+import triggers from './triggers/index.js';
+import dynamicData from './dynamic-data/index.js';
+import actions from './actions/index.js';
+
+export default defineApp({
+  name: 'Mailchimp',
+  key: 'mailchimp',
+  baseUrl: 'https://mailchimp.com',
+  apiBaseUrl: '',
+  iconUrl: '{BASE_URL}/apps/mailchimp/assets/favicon.svg',
+  authDocUrl: 'https://automatisch.io/docs/apps/mailchimp/connection',
+  primaryColor: '000000',
+  supportsConnections: true,
+  beforeRequest: [setBaseUrl, addAuthHeader],
+  auth,
+  triggers,
+  dynamicData,
+  actions,
+});

packages/backend/src/apps/mailchimp/triggers/email-opened/index.js

@@ -0,0 +1,101 @@
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'Email opened',
+  key: 'emailOpened',
+  pollInterval: 15,
+  description:
+    'Triggers when a recipient opens an email as part of a particular campaign.',
+  arguments: [
+    {
+      label: 'Audience',
+      key: 'audienceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listAudiences',
+          },
+        ],
+      },
+    },
+    {
+      label: 'Campaign Type',
+      key: 'campaignType',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      options: [
+        {
+          label: 'Campaign',
+          value: 'campaign',
+        },
+      ],
+    },
+    {
+      label: 'Campaign',
+      key: 'campaignId',
+      type: 'dropdown',
+      required: true,
+      dependsOn: ['parameters.audienceId'],
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listCampaigns',
+          },
+          {
+            name: 'parameters.audienceId',
+            value: '{parameters.audienceId}',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const campaignId = $.step.parameters.campaignId;
+    let hasMore = false;
+
+    const params = {
+      count: 1000,
+      offset: 0,
+    };
+
+    do {
+      const { data } = await $.http.get(
+        `/3.0/reports/${campaignId}/open-details`,
+        { params }
+      );
+      params.offset = params.offset + params.count;
+
+      if (data.members?.length) {
+        for (const member of data.members) {
+          $.pushTriggerItem({
+            raw: member,
+            meta: {
+              internalId: member.email_id,
+            },
+          });
+        }
+      }
+
+      if (data.total_items > params.offset) {
+        hasMore = true;
+      } else {
+        hasMore = false;
+      }
+    } while (hasMore);
+  },
+});

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

@@ -0,0 +1,5 @@
+import emailOpened from './email-opened/index.js';
+import newSubscribers from './new-subscribers/index.js';
+import newUnsubscribers from './new-unsubscribers/index.js';
+
+export default [emailOpened, newSubscribers, newUnsubscribers];

packages/backend/src/apps/mailchimp/triggers/new-subscribers/index.js

@@ -0,0 +1,105 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New subscribers',
+  key: 'newSubscribers',
+  type: 'webhook',
+  description: 'Triggers when a new subscriber is appended to an audience.',
+  arguments: [
+    {
+      label: 'Audience',
+      key: 'audienceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listAudiences',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const audienceId = $.step.parameters.audienceId;
+
+    const computedWebhookEvent = {
+      data: {
+        id: Crypto.randomUUID(),
+        email: 'user@automatisch.io',
+        ip_opt: '127.0.0.1',
+        merges: {
+          EMAIL: 'user@automatisch.io',
+          FNAME: 'FNAME',
+          LNAME: 'LNAME',
+          PHONE: '',
+          ADDRESS: '',
+          BIRTHDAY: '',
+        },
+        web_id: Crypto.randomUUID(),
+        list_id: audienceId,
+        email_type: 'html',
+      },
+      type: 'subscribe',
+      fired_at: new Date().toLocaleString(),
+    };
+
+    const dataItem = {
+      raw: computedWebhookEvent,
+      meta: {
+        internalId: '',
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const audienceId = $.step.parameters.audienceId;
+
+    const payload = {
+      url: $.webhookUrl,
+      events: {
+        subscribe: true,
+      },
+      sources: {
+        user: true,
+        admin: true,
+        api: true,
+      },
+    };
+
+    const response = await $.http.post(
+      `/3.0/lists/${audienceId}/webhooks`,
+      payload
+    );
+
+    await $.flow.setRemoteWebhookId(response.data.id);
+  },
+
+  async unregisterHook($) {
+    const audienceId = $.step.parameters.audienceId;
+
+    await $.http.delete(
+      `/3.0/lists/${audienceId}/webhooks/${$.flow.remoteWebhookId}`
+    );
+  },
+});

packages/backend/src/apps/mailchimp/triggers/new-unsubscribers/index.js

@@ -0,0 +1,108 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'New unsubscribers',
+  key: 'newUnsubscribers',
+  type: 'webhook',
+  description: 'Triggers when any existing subscriber opts out of an audience.',
+  arguments: [
+    {
+      label: 'Audience',
+      key: 'audienceId',
+      type: 'dropdown',
+      required: true,
+      description: '',
+      variables: true,
+      source: {
+        type: 'query',
+        name: 'getDynamicData',
+        arguments: [
+          {
+            name: 'key',
+            value: 'listAudiences',
+          },
+        ],
+      },
+    },
+  ],
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const audienceId = $.step.parameters.audienceId;
+
+    const computedWebhookEvent = {
+      data: {
+        id: Crypto.randomUUID(),
+        email: 'user@automatisch.io',
+        action: 'unsub',
+        ip_opt: '127.0.0.1',
+        merges: {
+          EMAIL: 'user@automatisch.io',
+          FNAME: 'FNAME',
+          LNAME: 'LNAME',
+          PHONE: '',
+          ADDRESS: '',
+          BIRTHDAY: '',
+        },
+        reason: 'manual',
+        web_id: Crypto.randomUUID(),
+        list_id: audienceId,
+        email_type: 'html',
+        campaign_id: Crypto.randomUUID(),
+      },
+      type: 'unsubscribe',
+      fired_at: new Date().toLocaleString(),
+    };
+
+    const dataItem = {
+      raw: computedWebhookEvent,
+      meta: {
+        internalId: '',
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const audienceId = $.step.parameters.audienceId;
+
+    const payload = {
+      url: $.webhookUrl,
+      events: {
+        unsubscribe: true,
+      },
+      sources: {
+        user: true,
+        admin: true,
+        api: true,
+      },
+    };
+
+    const response = await $.http.post(
+      `/3.0/lists/${audienceId}/webhooks`,
+      payload
+    );
+
+    await $.flow.setRemoteWebhookId(response.data.id);
+  },
+
+  async unregisterHook($) {
+    const audienceId = $.step.parameters.audienceId;
+
+    await $.http.delete(
+      `/3.0/lists/${audienceId}/webhooks/${$.flow.remoteWebhookId}`
+    );
+  },
+});

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

@@ -0,0 +1,33 @@
+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: 'apiKey',
+      label: 'API Key',
+      type: 'string',
+      required: true,
+      readOnly: false,
+      value: null,
+      placeholder: null,
+      description: 'MailerLite API key of your account.',
+      clickToCopy: false,
+    },
+  ],
+
+  verifyCredentials,
+  isStillVerified,
+};

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

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

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

@@ -0,0 +1,10 @@
+const verifyCredentials = async ($) => {
+  await $.http.get('/campaigns');
+
+  await $.auth.set({
+    screenName: $.auth.data.screenName,
+    apiKey: $.auth.data.apiKey,
+  });
+};
+
+export default verifyCredentials;

packages/backend/src/apps/mailerlite/common/add-auth-header.js

@@ -0,0 +1,9 @@
+const addAuthHeader = ($, requestConfig) => {
+  if ($.auth.data?.apiKey) {
+    requestConfig.headers.Authorization = `Bearer ${$.auth.data.apiKey}`;
+  }
+
+  return requestConfig;
+};
+
+export default addAuthHeader;

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

@@ -0,0 +1,18 @@
+import defineApp from '../../helpers/define-app.js';
+import addAuthHeader from './common/add-auth-header.js';
+import auth from './auth/index.js';
+import triggers from './triggers/index.js';
+
+export default defineApp({
+  name: 'MailerLite',
+  key: 'mailerlite',
+  iconUrl: '{BASE_URL}/apps/mailerlite/assets/favicon.svg',
+  authDocUrl: 'https://automatisch.io/docs/apps/mailerlite/connection',
+  supportsConnections: true,
+  baseUrl: 'https://www.mailerlite.com',
+  apiBaseUrl: 'https://connect.mailerlite.com/api',
+  primaryColor: '09C269',
+  beforeRequest: [addAuthHeader],
+  auth,
+  triggers,
+});

packages/backend/src/apps/mailerlite/triggers/campaign-sent/index.js

@@ -0,0 +1,55 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'Campaign sent',
+  key: 'campaignSent',
+  type: 'webhook',
+  description: 'Triggers when a campaign has been activated.',
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const computedWebhookEvent = {
+      id: Crypto.randomUUID(),
+      date: new Date().toISOString(),
+      name: 'Name',
+      preview_url: '',
+      total_recipients: 1,
+    };
+
+    const dataItem = {
+      raw: computedWebhookEvent,
+      meta: {
+        internalId: computedWebhookEvent.id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const payload = {
+      name: $.flow.id,
+      events: ['campaign.sent'],
+      url: $.webhookUrl,
+    };
+
+    const { data } = await $.http.post('/webhooks', payload);
+
+    await $.flow.setRemoteWebhookId(data.data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/webhooks/${$.flow.remoteWebhookId}`);
+  },
+});

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

@@ -0,0 +1,11 @@
+import campaignSent from './campaign-sent/index.js';
+import spamComplaint from './spam-complaint/index.js';
+import subscriberCreated from './subscriber-created/index.js';
+import subscriberUnsubscribed from './subscriber-unsubscribed/index.js';
+
+export default [
+  campaignSent,
+  spamComplaint,
+  subscriberCreated,
+  subscriberUnsubscribed,
+];

packages/backend/src/apps/mailerlite/triggers/spam-complaint/index.js

@@ -0,0 +1,78 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'Spam complaint',
+  key: 'spamComplaint',
+  type: 'webhook',
+  description: 'Triggers when a subscriber reports an email as spam.',
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const computedWebhookEvent = {
+      id: Crypto.randomUUID(),
+      sent: 1,
+      email: 'user@automatisch.io',
+      fields: {
+        city: 'City',
+        name: 'Name',
+        phone: '',
+        state: 'State',
+        z_i_p: null,
+        company: 'Company',
+        country: 'Country',
+        last_name: 'Last Name',
+      },
+      source: '',
+      status: 'junk',
+      optin_ip: null,
+      forget_at: null,
+      open_rate: 0,
+      click_rate: 0,
+      created_at: new Date().toISOString(),
+      deleted_at: null,
+      ip_address: null,
+      updated_at: new Date().toISOString(),
+      opens_count: 0,
+      opted_in_at: null,
+      clicks_count: 0,
+      subscribed_at: new Date().toISOString(),
+      unsubscribed_at: null,
+    };
+
+    const dataItem = {
+      raw: computedWebhookEvent,
+      meta: {
+        internalId: computedWebhookEvent.id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const payload = {
+      name: $.flow.id,
+      events: ['subscriber.spam_reported'],
+      url: $.webhookUrl,
+    };
+
+    const { data } = await $.http.post('/webhooks', payload);
+
+    await $.flow.setRemoteWebhookId(data.data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/webhooks/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/apps/mailerlite/triggers/subscriber-created/index.js

@@ -0,0 +1,78 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'Subscriber created',
+  key: 'subscriberCreated',
+  type: 'webhook',
+  description: 'Triggers when a new subscriber is added to your mailing list.',
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const computedWebhookEvent = {
+      id: Crypto.randomUUID(),
+      sent: null,
+      email: 'user@automatisch.io',
+      fields: {
+        city: 'City',
+        name: 'Name',
+        phone: '',
+        state: 'State',
+        z_i_p: null,
+        company: 'Company',
+        country: 'Country',
+        last_name: 'Last Name',
+      },
+      source: 'manual',
+      status: 'active',
+      optin_ip: null,
+      forget_at: null,
+      open_rate: 0,
+      click_rate: 0,
+      created_at: new Date().toISOString(),
+      deleted_at: null,
+      ip_address: null,
+      updated_at: new Date().toISOString(),
+      opens_count: null,
+      opted_in_at: null,
+      clicks_count: null,
+      subscribed_at: new Date().toISOString(),
+      unsubscribed_at: null,
+    };
+
+    const dataItem = {
+      raw: computedWebhookEvent,
+      meta: {
+        internalId: computedWebhookEvent.id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const payload = {
+      name: $.flow.id,
+      events: ['subscriber.created'],
+      url: $.webhookUrl,
+    };
+
+    const { data } = await $.http.post('/webhooks', payload);
+
+    await $.flow.setRemoteWebhookId(data.data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/webhooks/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/apps/mailerlite/triggers/subscriber-unsubscribed/index.js

@@ -0,0 +1,79 @@
+import Crypto from 'crypto';
+import defineTrigger from '../../../../helpers/define-trigger.js';
+
+export default defineTrigger({
+  name: 'Subscriber unsubscribed',
+  key: 'subscriberUnsubscribed',
+  type: 'webhook',
+  description:
+    'Triggers when a subscriber has unsubscribed from your mailing list.',
+
+  async run($) {
+    const dataItem = {
+      raw: $.request.body,
+      meta: {
+        internalId: Crypto.randomUUID(),
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async testRun($) {
+    const computedWebhookEvent = {
+      id: Crypto.randomUUID(),
+      sent: 1,
+      email: 'user@automatisch.io',
+      fields: {
+        city: 'City',
+        name: 'Name',
+        phone: '',
+        state: 'State',
+        z_i_p: null,
+        company: 'Company',
+        country: 'Country',
+        last_name: 'Last Name',
+      },
+      source: 'manual',
+      status: 'unsubscribed',
+      optin_ip: null,
+      forget_at: null,
+      open_rate: 100,
+      click_rate: 0,
+      created_at: new Date().toISOString(),
+      deleted_at: null,
+      ip_address: null,
+      updated_at: new Date().toISOString(),
+      opens_count: 1,
+      opted_in_at: null,
+      clicks_count: 0,
+      subscribed_at: new Date().toISOString(),
+      unsubscribed_at: new Date().toISOString(),
+    };
+
+    const dataItem = {
+      raw: computedWebhookEvent,
+      meta: {
+        internalId: computedWebhookEvent.id,
+      },
+    };
+
+    $.pushTriggerItem(dataItem);
+  },
+
+  async registerHook($) {
+    const payload = {
+      name: $.flow.id,
+      events: ['subscriber.unsubscribed'],
+      url: $.webhookUrl,
+    };
+
+    const { data } = await $.http.post('/webhooks', payload);
+
+    await $.flow.setRemoteWebhookId(data.data.id);
+  },
+
+  async unregisterHook($) {
+    await $.http.delete(`/webhooks/${$.flow.remoteWebhookId}`);
+  },
+});

packages/backend/src/config/app.js

@@ -52,7 +52,7 @@ const appConfig = {
   isDev: appEnv === 'development',
   isTest: appEnv === 'test',
   isProd: appEnv === 'production',
-  version: '0.12.0',
+  version: '0.13.1',
   postgresDatabase: process.env.POSTGRES_DATABASE || 'automatisch_development',
   postgresSchema: process.env.POSTGRES_SCHEMA || 'public',
   postgresPort: parseInt(process.env.POSTGRES_PORT || '5432'),
@@ -66,10 +66,17 @@ const appConfig = {
   appSecretKey: process.env.APP_SECRET_KEY || '',
   serveWebAppSeparately,
   redisHost: process.env.REDIS_HOST || '127.0.0.1',
+  redisName: process.env.REDIS_NAME || 'mymaster',
   redisPort: parseInt(process.env.REDIS_PORT || '6379'),
   redisUsername: process.env.REDIS_USERNAME,
   redisPassword: process.env.REDIS_PASSWORD,
+  redisDb: parseInt(process.env.REDIS_DB || '0'),
+  redisRole: process.env.REDIS_ROLE || 'master',
   redisTls: process.env.REDIS_TLS === 'true',
+  redisSentinelHost: process.env.REDIS_SENTINEL_HOST,
+  redisSentinelUsername: process.env.REDIS_SENTINEL_USERNAME,
+  redisSentinelPassword: process.env.REDIS_SENTINEL_PASSWORD,
+  redisSentinelPort: parseInt(process.env.REDIS_SENTINEL_PORT || '26379'),
   enableBullMQDashboard: process.env.ENABLE_BULLMQ_DASHBOARD === 'true',
   bullMQDashboardUsername: process.env.BULLMQ_DASHBOARD_USERNAME,
   bullMQDashboardPassword: process.env.BULLMQ_DASHBOARD_PASSWORD,

packages/backend/src/config/redis.js

@@ -1,14 +1,30 @@
 import appConfig from './app.js';
 
 const redisConfig = {
-  host: appConfig.redisHost,
-  port: appConfig.redisPort,
   username: appConfig.redisUsername,
   password: appConfig.redisPassword,
+  db: appConfig.redisDb,
   enableOfflineQueue: false,
   enableReadyCheck: true,
 };
 
+if (appConfig.redisSentinelHost) {
+  redisConfig.sentinels = [
+    {
+      host: appConfig.redisSentinelHost,
+      port: appConfig.redisSentinelPort,
+    }
+  ];
+
+  redisConfig.sentinelUsername = appConfig.redisSentinelUsername;
+  redisConfig.sentinelPassword = appConfig.redisSentinelPassword;
+  redisConfig.name = appConfig.redisName;
+  redisConfig.role = appConfig.redisRole;
+} else {
+  redisConfig.host = appConfig.redisHost;
+  redisConfig.port = appConfig.redisPort;
+}
+
 if (appConfig.redisTls) {
   redisConfig.tls = {};
 }

packages/backend/src/controllers/api/v1/access-tokens/revoke-access-token.js

@@ -11,5 +11,5 @@ export default async (request, response) => {
 
   await accessToken.revoke();
 
-  response.status(204).send();
+  response.status(204).end();
 };

packages/backend/src/controllers/api/v1/admin/apps/create-auth-client.ee.js

@@ -0,0 +1,25 @@
+import { renderObject } from '../../../../../helpers/renderer.js';
+import AppConfig from '../../../../../models/app-config.js';
+
+export default async (request, response) => {
+  const appConfig = await AppConfig.query()
+    .findOne({ key: request.params.appKey })
+    .throwIfNotFound();
+
+  const appAuthClient = await appConfig
+    .$relatedQuery('appAuthClients')
+    .insert(appAuthClientParams(request));
+
+  renderObject(response, appAuthClient, { status: 201 });
+};
+
+const appAuthClientParams = (request) => {
+  const { active, appKey, name, formattedAuthDefaults } = request.body;
+
+  return {
+    active,
+    appKey,
+    name,
+    formattedAuthDefaults,
+  };
+};

packages/backend/src/controllers/api/v1/admin/apps/create-auth-client.ee.test.js

@@ -0,0 +1,94 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+
+import app from '../../../../../app.js';
+import createAuthTokenByUserId from '../../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../../test/factories/user.js';
+import { createRole } from '../../../../../../test/factories/role.js';
+import createAppAuthClientMock from '../../../../../../test/mocks/rest/api/v1/admin/apps/create-auth-client.js';
+import { createAppConfig } from '../../../../../../test/factories/app-config.js';
+import * as license from '../../../../../helpers/license.ee.js';
+
+describe('POST /api/v1/admin/apps/:appKey/auth-clients', () => {
+  let currentUser, adminRole, token;
+
+  beforeEach(async () => {
+    vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+
+    adminRole = await createRole({ key: 'admin' });
+    currentUser = await createUser({ roleId: adminRole.id });
+
+    token = await createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return created response for valid app config', async () => {
+    await createAppConfig({
+      key: 'gitlab',
+    });
+
+    const appAuthClient = {
+      active: true,
+      appKey: 'gitlab',
+      name: 'First auth client',
+      formattedAuthDefaults: {
+        clientid: 'sample client ID',
+        clientSecret: 'sample client secret',
+        instanceUrl: 'https://gitlab.com',
+        oAuthRedirectUrl: 'http://localhost:3001/app/gitlab/connection/add',
+      },
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/apps/gitlab/auth-clients')
+      .set('Authorization', token)
+      .send(appAuthClient)
+      .expect(201);
+
+    const expectedPayload = createAppAuthClientMock(appAuthClient);
+    expect(response.body).toMatchObject(expectedPayload);
+  });
+
+  it('should return not found response for not existing app config', async () => {
+    const appAuthClient = {
+      active: true,
+      appKey: 'gitlab',
+      name: 'First auth client',
+      formattedAuthDefaults: {
+        clientid: 'sample client ID',
+        clientSecret: 'sample client secret',
+        instanceUrl: 'https://gitlab.com',
+        oAuthRedirectUrl: 'http://localhost:3001/app/gitlab/connection/add',
+      },
+    };
+
+    await request(app)
+      .post('/api/v1/admin/apps/gitlab/auth-clients')
+      .set('Authorization', token)
+      .send(appAuthClient)
+      .expect(404);
+  });
+
+  it('should return bad request response for missing required fields', async () => {
+    await createAppConfig({
+      key: 'gitlab',
+    });
+
+    const appAuthClient = {
+      appKey: 'gitlab',
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/apps/gitlab/auth-clients')
+      .set('Authorization', token)
+      .send(appAuthClient)
+      .expect(422);
+
+    expect(response.body.meta.type).toEqual('ModelValidation');
+    expect(response.body.errors).toMatchObject({
+      name: ["must have required property 'name'"],
+      formattedAuthDefaults: [
+        "must have required property 'formattedAuthDefaults'",
+      ],
+    });
+  });
+});

packages/backend/src/controllers/api/v1/admin/apps/create-config.ee.js

@@ -0,0 +1,21 @@
+import { renderObject } from '../../../../../helpers/renderer.js';
+import AppConfig from '../../../../../models/app-config.js';
+
+export default async (request, response) => {
+  const createdAppConfig = await AppConfig.query().insertAndFetch(
+    appConfigParams(request)
+  );
+
+  renderObject(response, createdAppConfig, { status: 201 });
+};
+
+const appConfigParams = (request) => {
+  const { allowCustomConnection, shared, disabled } = request.body;
+
+  return {
+    key: request.params.appKey,
+    allowCustomConnection,
+    shared,
+    disabled,
+  };
+};

packages/backend/src/controllers/api/v1/admin/apps/create-config.ee.test.js

@@ -0,0 +1,67 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+
+import app from '../../../../../app.js';
+import createAuthTokenByUserId from '../../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../../test/factories/user.js';
+import { createRole } from '../../../../../../test/factories/role.js';
+import createAppConfigMock from '../../../../../../test/mocks/rest/api/v1/admin/apps/create-config.js';
+import { createAppConfig } from '../../../../../../test/factories/app-config.js';
+import * as license from '../../../../../helpers/license.ee.js';
+
+describe('POST /api/v1/admin/apps/:appKey/config', () => {
+  let currentUser, adminRole, token;
+
+  beforeEach(async () => {
+    vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);
+
+    adminRole = await createRole({ key: 'admin' });
+    currentUser = await createUser({ roleId: adminRole.id });
+
+    token = await createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return created app config', async () => {
+    const appConfig = {
+      allowCustomConnection: true,
+      shared: true,
+      disabled: false,
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/apps/gitlab/config')
+      .set('Authorization', token)
+      .send(appConfig)
+      .expect(201);
+
+    const expectedPayload = createAppConfigMock({
+      ...appConfig,
+      key: 'gitlab',
+    });
+    expect(response.body).toMatchObject(expectedPayload);
+  });
+
+  it('should return HTTP 422 for already existing app config', async () => {
+    const appConfig = {
+      key: 'gitlab',
+      allowCustomConnection: true,
+      shared: true,
+      disabled: false,
+    };
+
+    await createAppConfig(appConfig);
+
+    const response = await request(app)
+      .post('/api/v1/admin/apps/gitlab/config')
+      .set('Authorization', token)
+      .send({
+        disabled: false,
+      })
+      .expect(422);
+
+    expect(response.body.meta.type).toEqual('UniqueViolationError');
+    expect(response.body.errors).toMatchObject({
+      key: ["'key' must be unique."],
+    });
+  });
+});

packages/backend/src/controllers/api/v1/automatisch/info.js

@@ -1,13 +1,17 @@
 import appConfig from '../../../../config/app.js';
 import { hasValidLicense } from '../../../../helpers/license.ee.js';
 import { renderObject } from '../../../../helpers/renderer.js';
+import Config from '../../../../models/config.js';
 
 export default async (request, response) => {
+  const installationCompleted = await Config.isInstallationCompleted();
+
   const info = {
-    isCloud: appConfig.isCloud,
-    isMation: appConfig.isMation,
-    isEnterprise: await hasValidLicense(),
     docsUrl: appConfig.docsUrl,
+    installationCompleted,
+    isCloud: appConfig.isCloud,
+    isEnterprise: await hasValidLicense(),
+    isMation: appConfig.isMation,
   };
 
   renderObject(response, info);

packages/backend/src/controllers/api/v1/automatisch/info.test.js

@@ -1,12 +1,14 @@
 import { vi, expect, describe, it } from 'vitest';
 import request from 'supertest';
 import appConfig from '../../../../config/app.js';
+import Config from '../../../../models/config.js';
 import app from '../../../../app.js';
 import infoMock from '../../../../../test/mocks/rest/api/v1/automatisch/info.js';
 import * as license from '../../../../helpers/license.ee.js';
 
 describe('GET /api/v1/automatisch/info', () => {
   it('should return Automatisch info', async () => {
+    vi.spyOn(Config, 'isInstallationCompleted').mockResolvedValue(true);
     vi.spyOn(appConfig, 'isCloud', 'get').mockReturnValue(false);
     vi.spyOn(appConfig, 'isMation', 'get').mockReturnValue(false);
     vi.spyOn(license, 'hasValidLicense').mockResolvedValue(true);

packages/backend/src/controllers/api/v1/automatisch/version.test.js

@@ -10,7 +10,7 @@ describe('GET /api/v1/automatisch/version', () => {
 
     const expectedPayload = {
       data: {
-        version: '0.12.0',
+        version: '0.13.1',
       },
       meta: {
         count: 1,

packages/backend/src/controllers/api/v1/connections/verify-connection.js

@@ -0,0 +1,14 @@
+import { renderObject } from '../../../../helpers/renderer.js';
+
+export default async (request, response) => {
+  let connection = await request.currentUser
+    .$relatedQuery('connections')
+    .findOne({
+      id: request.params.connectionId,
+    })
+    .throwIfNotFound();
+
+  connection = await connection.verifyAndUpdateConnection();
+
+  renderObject(response, connection);
+};