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>

packages/backend/package.json

@@ -11,6 +11,7 @@
     "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",

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

@@ -33,6 +33,7 @@ export default defineAction({
           type: 'string',
           required: true,
           variables: true,
+          valueType: 'parse',
         },
       ],
     },

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/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);
+};

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

@@ -0,0 +1,82 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import request from 'supertest';
+import Crypto from 'crypto';
+import app from '../../../../app.js';
+import App from '../../../../models/app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id.js';
+import { createUser } from '../../../../../test/factories/user.js';
+import { createConnection } from '../../../../../test/factories/connection.js';
+import { createPermission } from '../../../../../test/factories/permission.js';
+
+describe('POST /api/v1/connections/:connectionId/verify', () => {
+  let currentUser, currentUserRole, token;
+
+  beforeEach(async () => {
+    currentUser = await createUser();
+    currentUserRole = await currentUser.$relatedQuery('role');
+
+    token = await createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should update the connection as verified for current user', async () => {
+    const currentUserConnection = await createConnection({
+      userId: currentUser.id,
+      key: 'deepl',
+      verified: true,
+    });
+
+    await createPermission({
+      action: 'create',
+      subject: 'Connection',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    vi.spyOn(App, 'findOneByKey').mockImplementation((key) => {
+      if (key !== currentUserConnection.key) return;
+
+      return {
+        auth: {
+          verifyCredentials: vi.fn().mockResolvedValue(),
+        },
+      };
+    });
+
+    const response = await request(app)
+      .post(`/api/v1/connections/${currentUserConnection.id}/verify`)
+      .set('Authorization', token)
+      .expect(200);
+
+    expect(response.body.data.verified).toEqual(true);
+  });
+
+  it('should return not found response for not existing connection UUID', async () => {
+    const notExistingConnectionUUID = Crypto.randomUUID();
+
+    await createPermission({
+      action: 'create',
+      subject: 'Connection',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    await request(app)
+      .post(`/api/v1/connections/${notExistingConnectionUUID}/verify`)
+      .set('Authorization', token)
+      .expect(404);
+  });
+
+  it('should return bad request response for invalid UUID', async () => {
+    await createPermission({
+      action: 'create',
+      subject: 'Connection',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    await request(app)
+      .post('/api/v1/connections/invalidConnectionUUID/verify')
+      .set('Authorization', token)
+      .expect(400);
+  });
+});

packages/backend/src/controllers/api/v1/steps/delete-step.js

@@ -0,0 +1,9 @@
+export default async (request, response) => {
+  const step = await request.currentUser.authorizedSteps
+    .findById(request.params.stepId)
+    .throwIfNotFound();
+
+  await step.delete();
+
+  response.status(204).end();
+};

packages/backend/src/controllers/api/v1/steps/delete-step.test.js

@@ -0,0 +1,134 @@
+import { describe, it, beforeEach } from 'vitest';
+import request from 'supertest';
+import Crypto from 'crypto';
+import app from '../../../../app.js';
+import createAuthTokenByUserId from '../../../../helpers/create-auth-token-by-user-id';
+import { createUser } from '../../../../../test/factories/user';
+import { createConnection } from '../../../../../test/factories/connection';
+import { createFlow } from '../../../../../test/factories/flow';
+import { createStep } from '../../../../../test/factories/step';
+import { createPermission } from '../../../../../test/factories/permission';
+
+describe('DELETE /api/v1/steps/:stepId', () => {
+  let currentUser, currentUserRole, token;
+
+  beforeEach(async () => {
+    currentUser = await createUser();
+    currentUserRole = await currentUser.$relatedQuery('role');
+
+    token = await createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should remove the step of the current user and return no content', async () => {
+    const currentUserFlow = await createFlow({ userId: currentUser.id });
+    const currentUserConnection = await createConnection();
+
+    await createStep({
+      flowId: currentUserFlow.id,
+      connectionId: currentUserConnection.id,
+    });
+
+    const actionStep = await createStep({
+      flowId: currentUserFlow.id,
+      connectionId: currentUserConnection.id,
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    await createPermission({
+      action: 'update',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: ['isCreator'],
+    });
+
+    await request(app)
+      .delete(`/api/v1/steps/${actionStep.id}`)
+      .set('Authorization', token)
+      .expect(204);
+  });
+
+  it('should remove the step of the another user and return no content', async () => {
+    const anotherUser = await createUser();
+    const anotherUserFlow = await createFlow({ userId: anotherUser.id });
+    const anotherUserConnection = await createConnection();
+
+    await createStep({
+      flowId: anotherUserFlow.id,
+      connectionId: anotherUserConnection.id,
+    });
+
+    const actionStep = await createStep({
+      flowId: anotherUserFlow.id,
+      connectionId: anotherUserConnection.id,
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await createPermission({
+      action: 'update',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await request(app)
+      .delete(`/api/v1/steps/${actionStep.id}`)
+      .set('Authorization', token)
+      .expect(204);
+  });
+
+  it('should return not found response for not existing step UUID', async () => {
+    await createPermission({
+      action: 'update',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    const notExistingStepUUID = Crypto.randomUUID();
+
+    await request(app)
+      .delete(`/api/v1/steps/${notExistingStepUUID}`)
+      .set('Authorization', token)
+      .expect(404);
+  });
+
+  it('should return bad request response for invalid step UUID', async () => {
+    await createPermission({
+      action: 'update',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await createPermission({
+      action: 'read',
+      subject: 'Flow',
+      roleId: currentUserRole.id,
+      conditions: [],
+    });
+
+    await request(app)
+      .delete('/api/v1/steps/invalidStepUUID')
+      .set('Authorization', token)
+      .expect(400);
+  });
+});

packages/backend/src/graphql/mutation-resolvers.js

@@ -1,5 +1,3 @@
-import createAppAuthClient from './mutations/create-app-auth-client.ee.js';
-import createAppConfig from './mutations/create-app-config.ee.js';
 import createConnection from './mutations/create-connection.js';
 import createFlow from './mutations/create-flow.js';
 import createRole from './mutations/create-role.ee.js';
@@ -9,7 +7,6 @@ import deleteConnection from './mutations/delete-connection.js';
 import deleteCurrentUser from './mutations/delete-current-user.ee.js';
 import deleteFlow from './mutations/delete-flow.js';
 import deleteRole from './mutations/delete-role.ee.js';
-import deleteStep from './mutations/delete-step.js';
 import duplicateFlow from './mutations/duplicate-flow.js';
 import executeFlow from './mutations/execute-flow.js';
 import generateAuthUrl from './mutations/generate-auth-url.js';
@@ -27,11 +24,12 @@ import updateStep from './mutations/update-step.js';
 import updateUser from './mutations/update-user.ee.js';
 import upsertSamlAuthProvider from './mutations/upsert-saml-auth-provider.ee.js';
 import upsertSamlAuthProvidersRoleMappings from './mutations/upsert-saml-auth-providers-role-mappings.ee.js';
+
+// Converted mutations
+import deleteStep from './mutations/delete-step.js';
 import verifyConnection from './mutations/verify-connection.js';
 
 const mutationResolvers = {
-  createAppAuthClient,
-  createAppConfig,
   createConnection,
   createFlow,
   createRole,

packages/backend/src/graphql/mutations/create-app-auth-client.ee.js

@@ -1,17 +0,0 @@
-import AppConfig from '../../models/app-config.js';
-
-const createAppAuthClient = async (_parent, params, context) => {
-  context.currentUser.can('update', 'App');
-
-  const appConfig = await AppConfig.query()
-    .findById(params.input.appConfigId)
-    .throwIfNotFound();
-
-  const appAuthClient = await appConfig
-    .$relatedQuery('appAuthClients')
-    .insert(params.input);
-
-  return appAuthClient;
-};
-
-export default createAppAuthClient;

packages/backend/src/graphql/mutations/create-app-config.ee.js

@@ -1,18 +0,0 @@
-import App from '../../models/app.js';
-import AppConfig from '../../models/app-config.js';
-
-const createAppConfig = async (_parent, params, context) => {
-  context.currentUser.can('update', 'App');
-
-  const key = params.input.key;
-
-  const app = await App.findOneByKey(key);
-
-  if (!app) throw new Error('The app cannot be found!');
-
-  const appConfig = await AppConfig.query().insert(params.input);
-
-  return appConfig;
-};
-
-export default createAppConfig;

packages/backend/src/graphql/schema.graphql

@@ -2,8 +2,6 @@ type Query {
   placeholderQuery(name: String): Boolean
 }
 type Mutation {
-  createAppConfig(input: CreateAppConfigInput): AppConfig
-  createAppAuthClient(input: CreateAppAuthClientInput): AppAuthClient
   createConnection(input: CreateConnectionInput): Connection
   createFlow(input: CreateFlowInput): Flow
   createRole(input: CreateRoleInput): Role
@@ -550,13 +548,6 @@ type Subject {
   key: String
 }
 
-input CreateAppConfigInput {
-  key: String
-  allowCustomConnection: Boolean
-  shared: Boolean
-  disabled: Boolean
-}
-
 input UpdateAppConfigInput {
   id: String
   allowCustomConnection: Boolean
@@ -571,13 +562,6 @@ type AppAuthClient {
   active: Boolean
 }
 
-input CreateAppAuthClientInput {
-  appConfigId: String
-  name: String
-  formattedAuthDefaults: JSONObject
-  active: Boolean
-}
-
 input UpdateAppAuthClientInput {
   id: String
   name: String

packages/backend/src/helpers/authorization.js

@@ -43,6 +43,10 @@ const authorizationList = {
     action: 'update',
     subject: 'Connection',
   },
+  'POST /api/v1/connections/:connectionId/verify': {
+    action: 'create',
+    subject: 'Connection',
+  },
   'GET /api/v1/apps/:appKey/flows': {
     action: 'read',
     subject: 'Flow',
@@ -63,6 +67,10 @@ const authorizationList = {
     action: 'read',
     subject: 'Execution',
   },
+  'DELETE /api/v1/steps/:stepId': {
+    action: 'update',
+    subject: 'Flow',
+  },
 };
 
 export const authorizeUser = async (request, response, next) => {

packages/backend/src/helpers/compute-parameters.js

@@ -2,67 +2,164 @@ import get from 'lodash.get';
 
 const variableRegExp = /({{step\.[\da-zA-Z-]+(?:\.[^.}{]+)+}})/g;
 
-export default function computeParameters(parameters, executionSteps) {
-  const entries = Object.entries(parameters);
-  return entries.reduce((result, [key, value]) => {
-    if (typeof value === 'string') {
-      const parts = value.split(variableRegExp);
+function getParameterEntries(parameters) {
+  return Object.entries(parameters);
+}
 
-      const computedValue = parts
-        .map((part) => {
-          const isVariable = part.match(variableRegExp);
+function getFieldByKey(key, fields = []) {
+  return fields.find((field) => field.key === key);
+};
 
-          if (isVariable) {
-            const stepIdAndKeyPath = part.replace(/{{step.|}}/g, '');
-            const [stepId, ...keyPaths] = stepIdAndKeyPath.split('.');
-            const keyPath = keyPaths.join('.');
-            const executionStep = executionSteps.find((executionStep) => {
-              return executionStep.stepId === stepId;
-            });
-            const data = executionStep?.dataOut;
-            const dataValue = get(data, keyPath);
+function getParameterValueType(parameterKey, fields) {
+  const field = getFieldByKey(parameterKey, fields);
+  const defaultValueType = 'string';
 
-            // Covers both arrays and objects
-            if (typeof dataValue === 'object') {
-              return JSON.stringify(dataValue);
-            }
+  return field?.valueType || defaultValueType;
+}
 
-            return dataValue;
-          }
-
-          return part;
-        }).join('');
-
-      // challenge the input to see if it is stringifies object or array
-      try {
-        const parsedValue = JSON.parse(computedValue);
-
-        if (typeof parsedValue === 'number') {
-          throw new Error('Use original unparsed value.');
-        }
-
-        return {
-          ...result,
-          [key]: parsedValue,
-        };
-      } catch (error) {
-        return {
-          ...result,
-          [key]: computedValue,
-        };
-      }
-    }
-
-    if (Array.isArray(value)) {
-      return {
-        ...result,
-        [key]: value.map((item) => computeParameters(item, executionSteps)),
-      };
-    }
+function computeParameterEntries(parameterEntries, fields, executionSteps) {
+  const defaultComputedParameters = {};
+  return parameterEntries.reduce((result, [key, value]) => {
+    const parameterComputedValue = computeParameter(key, value, fields, executionSteps);
 
     return {
       ...result,
-      [key]: value,
-    };
-  }, {});
+      [key]: parameterComputedValue,
+    }
+  }, defaultComputedParameters);
+}
+
+function shouldAutoParse(key, fields) {
+  const parameterValueType = getParameterValueType(key, fields);
+  const shouldAutoParse = parameterValueType === 'parse';
+
+  return shouldAutoParse;
+}
+
+function computeParameter(key, value, fields, executionSteps) {
+  if (typeof value === 'string') {
+    const computedStringParameter = computeStringParameter(key, value, fields, executionSteps);
+    return computedStringParameter;
+  }
+
+  if (Array.isArray(value)) {
+    const computedArrayParameter = computeArrayParameter(key, value, fields, executionSteps);
+    return computedArrayParameter;
+  }
+
+  return value;
+}
+
+function splitByVariable(stringValue) {
+  const parts = stringValue.split(variableRegExp);
+
+  return parts;
+}
+
+function isVariable(stringValue) {
+  return stringValue.match(variableRegExp);
+}
+
+function splitVariableByStepIdAndKeyPath(variableValue) {
+  const stepIdAndKeyPath = variableValue.replace(/{{step.|}}/g, '');
+  const [stepId, ...keyPaths] = stepIdAndKeyPath.split('.');
+  const keyPath = keyPaths.join('.');
+
+  return {
+    stepId,
+    keyPath
+  }
+}
+
+function getVariableStepId(variableValue) {
+  const { stepId } = splitVariableByStepIdAndKeyPath(variableValue);
+
+  return stepId;
+}
+
+function getVariableKeyPath(variableValue) {
+  const { keyPath } = splitVariableByStepIdAndKeyPath(variableValue);
+
+  return keyPath
+}
+
+function getVariableExecutionStep(variableValue, executionSteps) {
+  const stepId = getVariableStepId(variableValue);
+
+  const executionStep = executionSteps.find((executionStep) => {
+    return executionStep.stepId === stepId;
+  });
+
+  return executionStep;
+}
+
+function computeVariable(variable, executionSteps) {
+  const keyPath = getVariableKeyPath(variable);
+  const executionStep = getVariableExecutionStep(variable, executionSteps);
+  const data = executionStep?.dataOut;
+  const computedVariable = get(data, keyPath);
+
+  /**
+   * Inline both arrays and objects. Otherwise, variables resolving to
+   * them would be resolved as `[object Object]` or lose their shape.
+   */
+  if (typeof computedVariable === 'object') {
+    return JSON.stringify(computedVariable);
+  }
+
+  return computedVariable;
+}
+
+function autoParseComputedVariable(computedVariable) {
+  // challenge the input to see if it is stringified object or array
+  try {
+    const parsedValue = JSON.parse(computedVariable);
+
+    if (typeof parsedValue === 'number') {
+      throw new Error('Use original unparsed value.');
+    }
+
+    return parsedValue;
+  } catch (error) {
+    return computedVariable;
+  }
+}
+
+function computeStringParameter(key, stringValue, fields, executionSteps) {
+  const parts = splitByVariable(stringValue);
+
+  const computedValue = parts
+    .map((part) => {
+      const variable = isVariable(part);
+
+      if (variable) {
+        return computeVariable(part, executionSteps);
+      }
+
+      return part;
+    })
+    .join('');
+
+  const autoParse = shouldAutoParse(key, fields);
+  if (autoParse) {
+    const autoParsedValue = autoParseComputedVariable(computedValue);
+
+    return autoParsedValue;
+  }
+
+  return computedValue;
+}
+
+function computeArrayParameter(key, arrayValue, fields = [], executionSteps) {
+  return arrayValue.map((item) => {
+    const itemFields = fields.find((field) => field.key === key)?.fields;
+
+    return computeParameters(item, itemFields, executionSteps);
+  });
+}
+
+export default function computeParameters(parameters, fields, executionSteps) {
+  const parameterEntries = getParameterEntries(parameters);
+
+  return computeParameterEntries(parameterEntries, fields, executionSteps);
 }

packages/backend/src/helpers/compute-parameters.test.js

@@ -1,5 +1,6 @@
 import { beforeEach, describe, it, expect } from 'vitest';
 import { createExecutionStep } from '../../test/factories/execution-step.js';
+import { createDropdownArgument, createDynamicArgument, createStringArgument } from '../../test/factories/app.js';
 import computeParameters from './compute-parameters.js';
 
 const computeVariable = (stepId, path) => `{{step.${stepId}.${path}}}`;
@@ -68,7 +69,7 @@ describe('Compute parameters helper', () => {
       key2: `"${computeVariable('non-existent-step-id', 'non-existent-key')}" is the value for non-existent-key`,
     };
 
-    const computedParameters = computeParameters(parameters, executionSteps);
+    const computedParameters = computeParameters(parameters, [], executionSteps);
     const expectedParameters = {
       key1: '',
       key2: '"" is the value for non-existent-key',
@@ -81,20 +82,29 @@ describe('Compute parameters helper', () => {
     it('should resolve empty object', () => {
       const parameters = {};
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, [], executionSteps);
 
       expect(computedParameters).toStrictEqual(parameters);
     });
   });
 
   describe('with string parameters', () => {
+    let stepArguments;
+    beforeEach(() => {
+      stepArguments = [
+        createStringArgument({
+          key: 'key1',
+        }),
+      ];
+    });
+
     it('should resolve as-is without variables', () => {
       const parameters = {
         key1: 'plain text',
         key2: 'plain text',
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
 
       expect(computedParameters).toStrictEqual(parameters);
     });
@@ -106,7 +116,7 @@ describe('Compute parameters helper', () => {
         key3: '  plain text',
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
 
       expect(computedParameters).toStrictEqual(parameters);
     });
@@ -116,23 +126,291 @@ describe('Compute parameters helper', () => {
         key1: `static text  ${computeVariable(executionStepOne.stepId, 'step1Key1')}`,
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
       const expectedParameters = {
         key1: `static text  plain text value for step1Key1`,
       };
 
       expect(computedParameters).toStrictEqual(expectedParameters);
     });
+
+    describe('with variables containing JSON', () => {
+      describe('without explicit valueType defined', () => {
+        let stepArguments;
+        beforeEach(() => {
+          stepArguments = [
+            createStringArgument({
+              key: 'key1',
+            }),
+          ];
+        });
+
+        it('should resolve text + JSON value as-is', () => {
+          const parameters = {
+            key1: 'prepended text {"key": "value"} ',
+          };
+
+          const computedParameters = computeParameters(parameters, executionSteps);
+
+          expect(computedParameters).toStrictEqual(parameters);
+        });
+
+        it('should resolve stringified JSON parsed', () => {
+          const parameters = {
+            key1: '{"key1": "plain text", "key2": "119007199254740999"}',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: '{"key1": "plain text", "key2": "119007199254740999"}',
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should handle arrays at root level', () => {
+          const parameters = {
+            key1: '["value1", "value2"]',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: '["value1", "value2"]',
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should handle arrays in nested level', () => {
+          const parameters = {
+            key1: '{"items": ["value1", "value2"]}',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: '{"items": ["value1", "value2"]}',
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should compute mix variables correctly', () => {
+          const parameters = {
+            key1: `another static text ${computeVariable(executionStepThree.stepId, 'step3Key4.step3Key4ChildKey4')}`,
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: `another static text ["value1","value2"]`,
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should compute variables correctly', () => {
+          const parameters = {
+            key1: `${computeVariable(executionStepThree.stepId, 'step3Key4.step3Key4ChildKey4')}`,
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: '["value1","value2"]',
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should not parse non-primitives in nested arrays', () => {
+          const stepArguments = [
+            createDynamicArgument({
+              key: 'inputs',
+            })
+          ];
+
+          const parameters = {
+            inputs: [
+              {
+                key: 'person',
+                value: '{ "name": "John Doe", "age": 32 }',
+              }
+            ],
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            inputs: [
+              {
+                key: 'person',
+                value: '{ "name": "John Doe", "age": 32 }',
+              }
+            ],
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+      });
+
+      describe(`with valueType as 'parse'`, () => {
+        let stepArguments;
+        beforeEach(() => {
+          stepArguments = [
+            createStringArgument({
+              key: 'key1',
+              valueType: 'parse',
+            }),
+          ];
+        });
+
+        it('should resolve text + JSON value as-is', () => {
+          const parameters = {
+            key1: 'prepended text {"key": "value"} ',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+
+          expect(computedParameters).toStrictEqual(parameters);
+        });
+
+        it('should resolve stringified JSON parsed', () => {
+          const parameters = {
+            key1: '{"key1": "plain text", "key2": "119007199254740999"}',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: {
+              key1: 'plain text',
+              key2: '119007199254740999',
+            },
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should handle arrays at root level', () => {
+          const parameters = {
+            key1: '["value1", "value2"]',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: ['value1', 'value2'],
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should handle arrays in nested level', () => {
+          const parameters = {
+            key1: '{"items": ["value1", "value2"]}',
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: {
+              items: ['value1', 'value2'],
+            }
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should compute and parse mix variables correctly', () => {
+          const parameters = {
+            key1: `another static text ${computeVariable(executionStepThree.stepId, 'step3Key4.step3Key4ChildKey4')}`,
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: `another static text ["value1","value2"]`,
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should compute and parse variables correctly', () => {
+          const parameters = {
+            key1: `${computeVariable(executionStepThree.stepId, 'step3Key4.step3Key4ChildKey4')}`,
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            key1: ["value1", "value2"],
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+
+        it('should compute and parse variables in nested arrays correctly', () => {
+          const stepArguments = [
+            createDynamicArgument({
+              key: 'inputs',
+              fields: [
+                {
+                  label: 'Key',
+                  key: 'key',
+                  required: true,
+                  variables: true,
+                },
+                {
+                  label: 'Value',
+                  key: 'value',
+                  required: true,
+                  variables: true,
+                  valueType: 'parse',
+                }
+              ],
+            })
+          ];
+
+          const parameters = {
+            inputs: [
+              {
+                key: 'person',
+                value: '{ "name": "John Doe", "age": 32 }',
+              }
+            ],
+          };
+
+          const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
+          const expectedParameters = {
+            inputs: [
+              {
+                key: 'person',
+                value: {
+                  name: 'John Doe',
+                  age: 32,
+                }
+              }
+            ],
+          };
+
+          expect(computedParameters).toStrictEqual(expectedParameters);
+        });
+      });
+    });
   });
 
   describe('with number parameters', () => {
+    let stepArguments;
+    beforeEach(() => {
+      stepArguments = [
+        createStringArgument({
+          key: 'key1',
+        }),
+        createStringArgument({
+          key: 'key2',
+        }),
+      ];
+    });
+
     it('should resolve number larger than MAX_SAFE_INTEGER correctly', () => {
       const parameters = {
         // eslint-disable-next-line no-loss-of-precision
         key1: 119007199254740999,
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
 
       expect(computedParameters).toStrictEqual(parameters);
       expect(computedParameters.key1 > Number.MAX_SAFE_INTEGER).toBe(true);
@@ -143,10 +421,9 @@ describe('Compute parameters helper', () => {
         key1: '119007199254740999',
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
 
       expect(computedParameters).toStrictEqual(parameters);
-      expect(parseInt(parameters.key1))
     });
 
     it('should compute variables with int values correctly', () => {
@@ -155,7 +432,7 @@ describe('Compute parameters helper', () => {
         key2: `${computeVariable(executionStepThree.stepId, 'step3Key3')}`
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
       const expectedParameters = {
         key1: `another static text 123123`,
         key2: `123123`
@@ -170,7 +447,7 @@ describe('Compute parameters helper', () => {
         key2: `${computeVariable(executionStepTwo.stepId, 'step2Key3')}`
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
       const expectedParameters = {
         // The expected `key2` is computed wrongly.
         key1: `another static text 6502380617126796383`,
@@ -181,85 +458,30 @@ describe('Compute parameters helper', () => {
     });
   });
 
-  describe('with JSON parameters', () => {
-    it('should resolve text + JSON value as-is', () => {
+  describe('with boolean parameters', () => {
+    let stepArguments;
+    beforeEach(() => {
+      stepArguments = [
+        createDropdownArgument({
+          key: 'key1',
+        }),
+        createDropdownArgument({
+          key: 'key2',
+        }),
+      ];
+    });
+
+    it('should resolve boolean as-is', () => {
       const parameters = {
-        key1: 'prepended text {"key": "value"} ',
+        key1: true,
+        key2: false,
       };
 
-      const computedParameters = computeParameters(parameters, executionSteps);
+      const computedParameters = computeParameters(parameters, stepArguments, executionSteps);
 
       expect(computedParameters).toStrictEqual(parameters);
-    });
-
-    it('should resolve stringified JSON parsed', () => {
-      const parameters = {
-        key1: '{"key1": "plain text", "key2": "119007199254740999"}',
-      };
-
-      const computedParameters = computeParameters(parameters, executionSteps);
-      const expectedParameters = {
-        key1: {
-          key1: 'plain text',
-          key2: '119007199254740999',
-        },
-      };
-
-      expect(computedParameters).toStrictEqual(expectedParameters);
-    });
-
-    it('should handle arrays at root level', () => {
-      const parameters = {
-        key1: '["value1", "value2"]',
-      };
-
-      const computedParameters = computeParameters(parameters, executionSteps);
-      const expectedParameters = {
-        key1: ['value1', 'value2'],
-      };
-
-      expect(computedParameters).toStrictEqual(expectedParameters);
-    });
-
-    it('should handle arrays in nested level', () => {
-      const parameters = {
-        key1: '{"items": ["value1", "value2"]}',
-      };
-
-      const computedParameters = computeParameters(parameters, executionSteps);
-      const expectedParameters = {
-        key1: {
-          items: ['value1', 'value2'],
-        }
-      };
-
-      expect(computedParameters).toStrictEqual(expectedParameters);
-    });
-
-    it('should compute mix variables correctly', () => {
-      const parameters = {
-        key1: `another static text ${computeVariable(executionStepThree.stepId, 'step3Key4.step3Key4ChildKey4')}`,
-      };
-
-      const computedParameters = computeParameters(parameters, executionSteps);
-      const expectedParameters = {
-        key1: `another static text ["value1","value2"]`,
-      };
-
-      expect(computedParameters).toStrictEqual(expectedParameters);
-    });
-
-    it('should compute variables correctly', () => {
-      const parameters = {
-        key1: `${computeVariable(executionStepThree.stepId, 'step3Key4.step3Key4ChildKey4')}`,
-      };
-
-      const computedParameters = computeParameters(parameters, executionSteps);
-      const expectedParameters = {
-        key1: ["value1", "value2"],
-      };
-
-      expect(computedParameters).toStrictEqual(expectedParameters);
+      expect(computedParameters.key1).toBe(true);
+      expect(computedParameters.key2).toBe(false);
     });
   });
 });

packages/backend/src/helpers/error-handler.js

@@ -1,8 +1,13 @@
 import logger from './logger.js';
 import objection from 'objection';
 import * as Sentry from './sentry.ee.js';
-const { NotFoundError, DataError } = objection;
+const { NotFoundError, DataError, ValidationError, UniqueViolationError } =
+  objection;
 import HttpError from '../errors/http.js';
+import {
+  renderObjectionError,
+  renderUniqueViolationError,
+} from './renderer.js';
 
 // Do not remove `next` argument as the function signature will not fit for an error handler middleware
 // eslint-disable-next-line no-unused-vars
@@ -15,6 +20,14 @@ const errorHandler = (error, request, response, next) => {
     response.status(404).end();
   }
 
+  if (error instanceof ValidationError) {
+    renderObjectionError(response, error, 422);
+  }
+
+  if (error instanceof UniqueViolationError) {
+    renderUniqueViolationError(response, error);
+  }
+
   if (error instanceof DataError) {
     response.status(400).end();
   }

packages/backend/src/helpers/renderer.js

@@ -41,7 +41,9 @@ const renderObject = (response, object, options) => {
     },
   };
 
-  return response.json(computedPayload);
+  const status = options?.status || 200;
+
+  return response.status(status).json(computedPayload);
 };
 
 const renderError = (response, errors, status, type) => {
@@ -62,4 +64,31 @@ const renderError = (response, errors, status, type) => {
   return response.status(errorStatus).send(payload);
 };
 
-export { renderObject, renderError };
+const renderUniqueViolationError = (response, error) => {
+  const errors = error.columns.map((column) => ({
+    [column]: [`'${column}' must be unique.`],
+  }));
+
+  return renderError(response, errors, 422, 'UniqueViolationError');
+};
+
+const renderObjectionError = (response, error, status) => {
+  const { statusCode, type, data = {} } = error;
+
+  const computedStatusCode = status || statusCode;
+
+  const computedErrors = Object.entries(data).map(
+    ([fieldName, fieldErrors]) => ({
+      [fieldName]: fieldErrors.map(({ message }) => message),
+    })
+  );
+
+  return renderError(response, computedErrors, computedStatusCode, type);
+};
+
+export {
+  renderObject,
+  renderError,
+  renderObjectionError,
+  renderUniqueViolationError,
+};

packages/backend/src/models/app-config.js

@@ -15,6 +15,8 @@ class AppConfig extends Base {
       allowCustomConnection: { type: 'boolean', default: false },
       shared: { type: 'boolean', default: false },
       disabled: { type: 'boolean', default: false },
+      createdAt: { type: 'string' },
+      updatedAt: { type: 'string' },
     },
   };
 

packages/backend/src/models/connection.js

@@ -171,6 +171,17 @@ class Connection extends Base {
     });
   }
 
+  async verifyAndUpdateConnection() {
+    const app = await this.getApp();
+    const $ = await globalVariable({ connection: this, app });
+    await app.auth.verifyCredentials($);
+
+    return await this.$query().patchAndFetch({
+      verified: true,
+      draft: false,
+    });
+  }
+
   async verifyWebhook(request) {
     if (!this.key) return true;
 

packages/backend/src/models/step.js

@@ -198,6 +198,32 @@ class Step extends Base {
     return existingArguments;
   }
 
+  async getSetupAndDynamicFields() {
+    const setupFields = await this.getSetupFields();
+    const setupAndDynamicFields = [];
+
+    for (const setupField of setupFields) {
+      setupAndDynamicFields.push(setupField);
+
+      const additionalFields = setupField.additionalFields;
+      if (additionalFields) {
+        const keyArgument = additionalFields.arguments.find(
+          (argument) => argument.name === 'key'
+        );
+        const dynamicFieldsKey = keyArgument.value;
+
+        const dynamicFields = await this.createDynamicFields(
+          dynamicFieldsKey,
+          this.parameters
+        );
+
+        setupAndDynamicFields.push(...dynamicFields);
+      }
+    }
+
+    return setupAndDynamicFields;
+  }
+
   async createDynamicFields(dynamicFieldsKey, parameters) {
     const connection = await this.$relatedQuery('connection');
     const flow = await this.$relatedQuery('flow');
@@ -240,8 +266,11 @@ class Step extends Base {
         })
       : [];
 
+    const setupAndDynamicFields = await this.getSetupAndDynamicFields();
+
     const computedParameters = computeParameters(
       $.step.parameters,
+      setupAndDynamicFields,
       priorExecutionSteps
     );
 
@@ -262,6 +291,25 @@ class Step extends Base {
 
     return this;
   }
+
+  async delete() {
+    await this.$relatedQuery('executionSteps').delete();
+    await this.$query().delete();
+
+    const flow = await this.$relatedQuery('flow');
+
+    const nextSteps = await flow
+      .$relatedQuery('steps')
+      .where('position', '>', this.position);
+
+    const nextStepQueries = nextSteps.map(async (nextStep) => {
+      await nextStep.$query().patch({
+        position: nextStep.position - 1,
+      });
+    });
+
+    await Promise.all(nextStepQueries);
+  }
 }
 
 export default Step;

packages/backend/src/routes/api/v1/admin/apps.ee.js

@@ -3,11 +3,22 @@ import asyncHandler from 'express-async-handler';
 import { authenticateUser } from '../../../../helpers/authentication.js';
 import { authorizeAdmin } from '../../../../helpers/authorization.js';
 import { checkIsEnterprise } from '../../../../helpers/check-is-enterprise.js';
+import createConfigAction from '../../../../controllers/api/v1/admin/apps/create-config.ee.js';
 import getAuthClientsAction from '../../../../controllers/api/v1/admin/apps/get-auth-clients.ee.js';
 import getAuthClientAction from '../../../../controllers/api/v1/admin/apps/get-auth-client.ee.js';
+import createAuthClientAction from '../../../../controllers/api/v1/admin/apps/create-auth-client.ee.js';
 
 const router = Router();
 
+
+router.post(
+  '/:appKey/config',
+  authenticateUser,
+  authorizeAdmin,
+  checkIsEnterprise,
+  asyncHandler(createConfigAction)
+);
+
 router.get(
   '/:appKey/auth-clients',
   authenticateUser,
@@ -16,6 +27,14 @@ router.get(
   asyncHandler(getAuthClientsAction)
 );
 
+router.post(
+  '/:appKey/auth-clients',
+  authenticateUser,
+  authorizeAdmin,
+  checkIsEnterprise,
+  asyncHandler(createAuthClientAction)
+);
+
 router.get(
   '/:appKey/auth-clients/:appAuthClientId',
   authenticateUser,

packages/backend/src/routes/api/v1/connections.js

@@ -3,7 +3,8 @@ import asyncHandler from 'express-async-handler';
 import { authenticateUser } from '../../../helpers/authentication.js';
 import { authorizeUser } from '../../../helpers/authorization.js';
 import getFlowsAction from '../../../controllers/api/v1/connections/get-flows.js';
-import createTestAction from '../../../controllers/api/v1/connections/create-test.js';
+import testConnectionAction from '../../../controllers/api/v1/connections/test-connection.js';
+import verifyConnectionAction from '../../../controllers/api/v1/connections/verify-connection.js';
 
 const router = Router();
 
@@ -18,7 +19,14 @@ router.post(
   '/:connectionId/test',
   authenticateUser,
   authorizeUser,
-  asyncHandler(createTestAction)
+  asyncHandler(testConnectionAction)
+);
+
+router.post(
+  '/:connectionId/verify',
+  authenticateUser,
+  authorizeUser,
+  asyncHandler(verifyConnectionAction)
 );
 
 export default router;

packages/backend/src/routes/api/v1/steps.js

@@ -6,6 +6,7 @@ import getConnectionAction from '../../../controllers/api/v1/steps/get-connectio
 import getPreviousStepsAction from '../../../controllers/api/v1/steps/get-previous-steps.js';
 import createDynamicFieldsAction from '../../../controllers/api/v1/steps/create-dynamic-fields.js';
 import createDynamicDataAction from '../../../controllers/api/v1/steps/create-dynamic-data.js';
+import deleteStepAction from '../../../controllers/api/v1/steps/delete-step.js';
 
 const router = Router();
 
@@ -37,4 +38,11 @@ router.post(
   asyncHandler(createDynamicDataAction)
 );
 
+router.delete(
+  '/:stepId',
+  authenticateUser,
+  authorizeUser,
+  asyncHandler(deleteStepAction)
+);
+
 export default router;

packages/backend/src/services/action.js

@@ -31,8 +31,11 @@ export const processAction = async (options) => {
     execution_id: $.execution.id,
   });
 
+  const stepSetupAndDynamicFields = await step.getSetupAndDynamicFields();
+
   const computedParameters = computeParameters(
     $.step.parameters,
+    stepSetupAndDynamicFields,
     priorExecutionSteps
   );
 

packages/backend/test/factories/app.js

@@ -0,0 +1,72 @@
+import { faker } from '@faker-js/faker';
+
+export const createArgument = (params = {}) => {
+  const labelAndKey = faker.lorem.word();
+
+  const argument = {
+    label: labelAndKey,
+    key: labelAndKey,
+    required: false,
+    variables: true,
+    ...params,
+  };
+
+  return argument;
+};
+
+export const createStringArgument = (params = {}) => {
+  const stringArgument = createArgument({
+    ...params,
+    type: 'string',
+  });
+
+  return stringArgument;
+};
+
+export const createDropdownArgument = (params = {}) => {
+  const dropdownArgument = createArgument({
+    options: [
+      {
+        label: 'Yes',
+        value: true,
+      },
+      {
+        label: 'No',
+        value: false,
+      },
+    ],
+    ...params,
+    type: 'dropdown',
+  });
+
+  return dropdownArgument;
+};
+
+export const createDynamicArgument = (params = {}) => {
+  const dynamicArgument = createArgument({
+    value: [
+      {
+        key: '',
+        value: '',
+      },
+    ],
+    fields: [
+      {
+        label: 'Key',
+        key: 'key',
+        required: true,
+        variables: true,
+      },
+      {
+        label: 'Value',
+        key: 'value',
+        required: true,
+        variables: true,
+      }
+    ],
+    ...params,
+    type: 'dynamic',
+  });
+
+  return dynamicArgument;
+};

packages/backend/test/mocks/rest/api/v1/admin/apps/create-auth-client.js

@@ -0,0 +1,17 @@
+const createAppAuthClientMock = (appAuthClient) => {
+  return {
+    data: {
+      name: appAuthClient.name,
+      active: appAuthClient.active,
+    },
+    meta: {
+      count: 1,
+      currentPage: null,
+      isArray: false,
+      totalPages: null,
+      type: 'AppAuthClient',
+    },
+  };
+};
+
+export default createAppAuthClientMock;

packages/backend/test/mocks/rest/api/v1/admin/apps/create-config.js

@@ -0,0 +1,19 @@
+const createAppConfigMock = (appConfig) => {
+  return {
+    data: {
+      key: appConfig.key,
+      allowCustomConnection: appConfig.allowCustomConnection,
+      shared: appConfig.shared,
+      disabled: appConfig.disabled,
+    },
+    meta: {
+      count: 1,
+      currentPage: null,
+      isArray: false,
+      totalPages: null,
+      type: 'AppConfig',
+    },
+  };
+};
+
+export default createAppConfigMock;

packages/backend/test/setup/global-hooks.js

@@ -8,7 +8,9 @@ global.beforeAll(async () => {
   logger.silent = true;
 
   // Remove default roles and permissions before running the test suite
-  await knex.raw('TRUNCATE TABLE config, roles, permissions CASCADE');
+  await knex.raw('TRUNCATE TABLE config CASCADE');
+  await knex.raw('TRUNCATE TABLE roles CASCADE');
+  await knex.raw('TRUNCATE TABLE permissions CASCADE');
 });
 
 global.beforeEach(async () => {

packages/e2e-tests/fixtures/flow-editor-page.js

@@ -1,4 +1,6 @@
 const { AuthenticatedPage } = require('./authenticated-page');
+const { expect } = require('@playwright/test');
+const axios = require('axios');
 
 export class FlowEditorPage extends AuthenticatedPage {
   screenshotPath = '/flow-editor';
@@ -12,14 +14,71 @@ export class FlowEditorPage extends AuthenticatedPage {
     this.appAutocomplete = this.page.getByTestId('choose-app-autocomplete');
     this.eventAutocomplete = this.page.getByTestId('choose-event-autocomplete');
     this.continueButton = this.page.getByTestId('flow-substep-continue-button');
+    this.testAndContinueButton = this.page.getByText('Test & Continue');
     this.connectionAutocomplete = this.page.getByTestId(
       'choose-connection-autocomplete'
     );
-    this.testOuput = this.page.getByTestId('flow-test-substep-output');
+    this.testOutput = this.page.getByTestId('flow-test-substep-output');
+    this.hasNoOutput = this.page.getByTestId('flow-test-substep-no-output');
     this.unpublishFlowButton = this.page.getByTestId('unpublish-flow-button');
     this.publishFlowButton = this.page.getByTestId('publish-flow-button');
     this.infoSnackbar = this.page.getByTestId('flow-cannot-edit-info-snackbar');
     this.trigger = this.page.getByLabel('Trigger on weekends?');
     this.stepCircularLoader = this.page.getByTestId('step-circular-loader');
+    this.flowName = this.page.getByTestId('editableTypography');
+    this.flowNameInput = this.page
+      .getByTestId('editableTypographyInput')
+      .locator('input');
+  }
+
+  async createWebhookTrigger(workSynchronously) {
+    await this.appAutocomplete.click();
+    await this.page.getByRole('option', { name: 'Webhook' }).click();
+
+    await expect(this.eventAutocomplete).toBeVisible();
+    await this.eventAutocomplete.click();
+    await this.page.getByRole('option', { name: 'Catch raw webhook' }).click();
+    await this.continueButton.click();
+    await this.page
+      .getByTestId('parameters.workSynchronously-autocomplete')
+      .click();
+    await this.page
+      .getByRole('option', { name: workSynchronously ? 'Yes' : 'No' })
+      .click();
+    await this.continueButton.click();
+
+    const webhookUrl = this.page.locator('input[name="webhookUrl"]');
+    if (workSynchronously) {
+      await expect(webhookUrl).toHaveValue(/sync/);
+    } else {
+      await expect(webhookUrl).not.toHaveValue(/sync/);
+    }
+
+    const triggerResponse = await axios.get(await webhookUrl.inputValue());
+    await expect(triggerResponse.status).toBe(204);
+
+    await expect(this.testOutput).not.toBeVisible();
+    await this.testAndContinueButton.click();
+    await expect(this.testOutput).toBeVisible();
+    await expect(this.hasNoOutput).not.toBeVisible();
+    await this.continueButton.click();
+
+    return await webhookUrl.inputValue();
+  }
+
+  async chooseAppAndEvent(appName, eventName) {
+    await this.appAutocomplete.click();
+    await this.page.getByRole('option', { name: appName }).click();
+    await expect(this.eventAutocomplete).toBeVisible();
+    await this.eventAutocomplete.click();
+    await this.page.getByRole('option', { name: eventName }).click();
+    await this.continueButton.click();
+  }
+
+  async testAndContinue() {
+    await expect(this.continueButton).toHaveCount(1);
+    await this.continueButton.click();
+    await expect(this.testOutput).toBeVisible();
+    await this.continueButton.click();
   }
 }

packages/e2e-tests/tests/app-integrations/webhook.spec.js

@@ -0,0 +1,85 @@
+const { test, expect } = require('../../fixtures/index');
+const axios = require('axios');
+
+test.describe('Webhook flow', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.getByTestId('create-flow-button').click();
+    await page.waitForURL(
+      /\/editor\/[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}/
+    );
+    await expect(page.getByTestId('flow-step')).toHaveCount(2);
+  });
+
+  test('Create a new flow with a sync Webhook step then a Webhook step', async ({
+    flowEditorPage,
+    page,
+  }) => {
+    await flowEditorPage.flowName.click();
+    await flowEditorPage.flowNameInput.fill('syncWebhook');
+    const syncWebhookUrl = await flowEditorPage.createWebhookTrigger(true);
+
+    await flowEditorPage.chooseAppAndEvent('Webhook', 'Respond with');
+
+    await expect(flowEditorPage.continueButton).toHaveCount(1);
+    await expect(flowEditorPage.continueButton).not.toBeEnabled();
+
+    await page
+      .getByTestId('parameters.statusCode-power-input')
+      .locator('[contenteditable]')
+      .fill('200');
+    await flowEditorPage.clickAway();
+    await expect(flowEditorPage.continueButton).toHaveCount(1);
+    await expect(flowEditorPage.continueButton).not.toBeEnabled();
+
+    await page
+      .getByTestId('parameters.body-power-input')
+      .locator('[contenteditable]')
+      .fill('response from webhook');
+    await flowEditorPage.clickAway();
+    await expect(flowEditorPage.continueButton).toBeEnabled();
+    await flowEditorPage.continueButton.click();
+
+    await flowEditorPage.testAndContinue();
+    await flowEditorPage.publishFlowButton.click();
+
+    const response = await axios.get(syncWebhookUrl);
+    await expect(response.status).toBe(200);
+    await expect(response.data).toBe('response from webhook');
+  });
+
+  test('Create a new flow with an async Webhook step then a Webhook step', async ({
+    flowEditorPage,
+    page,
+  }) => {
+    await flowEditorPage.flowName.click();
+    await flowEditorPage.flowNameInput.fill('asyncWebhook');
+    const asyncWebhookUrl = await flowEditorPage.createWebhookTrigger(false);
+
+    await flowEditorPage.chooseAppAndEvent('Webhook', 'Respond with');
+    await expect(flowEditorPage.continueButton).toHaveCount(1);
+    await expect(flowEditorPage.continueButton).not.toBeEnabled();
+
+    await page
+      .getByTestId('parameters.statusCode-power-input')
+      .locator('[contenteditable]')
+      .fill('200');
+    await flowEditorPage.clickAway();
+    await expect(flowEditorPage.continueButton).toHaveCount(1);
+    await expect(flowEditorPage.continueButton).not.toBeEnabled();
+
+    await page
+      .getByTestId('parameters.body-power-input')
+      .locator('[contenteditable]')
+      .fill('response from webhook');
+    await flowEditorPage.clickAway();
+    await expect(flowEditorPage.continueButton).toBeEnabled();
+    await flowEditorPage.continueButton.click();
+
+    await flowEditorPage.testAndContinue();
+    await flowEditorPage.publishFlowButton.click();
+
+    const response = await axios.get(asyncWebhookUrl);
+    await expect(response.status).toBe(204);
+    await expect(response.data).toBe('');
+  });
+});

packages/e2e-tests/tests/flow-editor/create-flow.spec.js

@@ -2,7 +2,6 @@ const { test, expect } = require('../../fixtures/index');
 
 test('Ensure creating a new flow works', async ({ page }) => {
   await page.getByTestId('create-flow-button').click();
-  await expect(page).toHaveURL(/\/editor\/create/);
   await expect(page).toHaveURL(
     /\/editor\/[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}/
   );
@@ -69,9 +68,9 @@ test(
 
       await test.step('test trigger', async () => {
         await test.step('show sample output', async () => {
-          await expect(flowEditorPage.testOuput).not.toBeVisible();
+          await expect(flowEditorPage.testOutput).not.toBeVisible();
           await flowEditorPage.continueButton.click();
-          await expect(flowEditorPage.testOuput).toBeVisible();
+          await expect(flowEditorPage.testOutput).toBeVisible();
           await flowEditorPage.screenshot({
             path: 'Scheduler trigger test output.png',
           });
@@ -143,12 +142,12 @@ test(
     
       await test.step('test trigger substep', async () => {
         await test.step('show sample output', async () => {
-          await expect(flowEditorPage.testOuput).not.toBeVisible();
+          await expect(flowEditorPage.testOutput).not.toBeVisible();
           await page
             .getByTestId('flow-substep-continue-button')
             .first()
             .click();
-          await expect(flowEditorPage.testOuput).toBeVisible();
+          await expect(flowEditorPage.testOutput).toBeVisible();
           await flowEditorPage.screenshot({
             path: 'Ntfy action test output.png',
           });

packages/web/src/components/AdminApplicationCreateAuthClient/index.jsx

@@ -1,12 +1,11 @@
 import PropTypes from 'prop-types';
 import React, { useCallback, useMemo } from 'react';
-import { useMutation } from '@apollo/client';
 
 import { AppPropType } from 'propTypes/propTypes';
-import { CREATE_APP_CONFIG } from 'graphql/mutations/create-app-config';
-import { CREATE_APP_AUTH_CLIENT } from 'graphql/mutations/create-app-auth-client';
+import useAdminCreateAppConfig from 'hooks/useAdminCreateAppConfig';
 import useAppConfig from 'hooks/useAppConfig.ee';
 import useFormatMessage from 'hooks/useFormatMessage';
+import useAdminCreateAppAuthClient from 'hooks/useAdminCreateAppAuthClient.ee';
 import AdminApplicationAuthClientDialog from 'components/AdminApplicationAuthClientDialog';
 import useAppAuth from 'hooks/useAppAuth';
 
@@ -18,51 +17,38 @@ function AdminApplicationCreateAuthClient(props) {
   const { data: appConfig, isLoading: isAppConfigLoading } =
     useAppConfig(appKey);
 
-  const [
-    createAppConfig,
-    { loading: loadingCreateAppConfig, error: createAppConfigError },
-  ] = useMutation(CREATE_APP_CONFIG, {
-    refetchQueries: ['GetAppConfig'],
-    context: { autoSnackbar: false },
-  });
+  const {
+    mutateAsync: createAppConfig,
+    isPending: isCreateAppConfigPending,
+    error: createAppConfigError
+  } = useAdminCreateAppConfig(props.appKey);
 
-  const [
-    createAppAuthClient,
-    { loading: loadingCreateAppAuthClient, error: createAppAuthClientError },
-  ] = useMutation(CREATE_APP_AUTH_CLIENT, {
-    refetchQueries: ['GetAppAuthClients'],
-    context: { autoSnackbar: false },
-  });
+  const {
+    mutateAsync: createAppAuthClient,
+    isPending: isCreateAppAuthClientPending,
+    error: createAppAuthClientError,
+  } = useAdminCreateAppAuthClient(appKey);
 
   const submitHandler = async (values) => {
     let appConfigId = appConfig?.data?.id;
 
     if (!appConfigId) {
       const { data: appConfigData } = await createAppConfig({
-        variables: {
-          input: {
-            key: appKey,
-            allowCustomConnection: false,
-            shared: false,
-            disabled: false,
-          },
-        },
+        allowCustomConnection: true,
+        shared: false,
+        disabled: false,
       });
 
-      appConfigId = appConfigData.createAppConfig.id;
+      appConfigId = appConfigData.id;
     }
 
     const { name, active, ...formattedAuthDefaults } = values;
 
     await createAppAuthClient({
-      variables: {
-        input: {
-          appConfigId,
-          name,
-          active,
-          formattedAuthDefaults,
-        },
-      },
+      appKey,
+      name,
+      active,
+      formattedAuthDefaults,
     });
 
     onClose();
@@ -103,7 +89,7 @@ function AdminApplicationCreateAuthClient(props) {
       loading={isAppConfigLoading}
       submitHandler={submitHandler}
       authFields={auth?.data?.fields}
-      submitting={loadingCreateAppConfig || loadingCreateAppAuthClient}
+      submitting={isCreateAppConfigPending || isCreateAppAuthClientPending}
       defaultValues={defaultValues}
     />
   );

packages/web/src/components/AdminApplicationSettings/index.jsx

@@ -8,11 +8,11 @@ import Stack from '@mui/material/Stack';
 import LoadingButton from '@mui/lab/LoadingButton';
 import { useMutation } from '@apollo/client';
 
-import { CREATE_APP_CONFIG } from 'graphql/mutations/create-app-config';
 import { UPDATE_APP_CONFIG } from 'graphql/mutations/update-app-config';
 import Form from 'components/Form';
 import { Switch } from './style';
 import useEnqueueSnackbar from 'hooks/useEnqueueSnackbar';
+import useAdminCreateAppConfig from 'hooks/useAdminCreateAppConfig';
 
 function AdminApplicationSettings(props) {
   const formatMessage = useFormatMessage();
@@ -20,12 +20,10 @@ function AdminApplicationSettings(props) {
 
   const { data: appConfig, isLoading: loading } = useAppConfig(props.appKey);
 
-  const [createAppConfig, { loading: loadingCreateAppConfig }] = useMutation(
-    CREATE_APP_CONFIG,
-    {
-      refetchQueries: ['GetAppConfig'],
-    },
-  );
+  const {
+    mutateAsync: createAppConfig,
+    isPending: isCreateAppConfigPending,
+  } = useAdminCreateAppConfig(props.appKey);
 
   const [updateAppConfig, { loading: loadingUpdateAppConfig }] = useMutation(
     UPDATE_APP_CONFIG,
@@ -37,11 +35,7 @@ function AdminApplicationSettings(props) {
   const handleSubmit = async (values) => {
     try {
       if (!appConfig?.data) {
-        await createAppConfig({
-          variables: {
-            input: { key: props.appKey, ...values },
-          },
-        });
+        await createAppConfig(values);
       } else {
         await updateAppConfig({
           variables: {
@@ -108,7 +102,7 @@ function AdminApplicationSettings(props) {
               variant="contained"
               color="primary"
               sx={{ boxShadow: 2, mt: 5 }}
-              loading={loadingCreateAppConfig || loadingUpdateAppConfig}
+              loading={isCreateAppConfigPending || loadingUpdateAppConfig}
               disabled={!isDirty || loading}
             >
               {formatMessage('adminAppsSettings.save')}

packages/web/src/components/AdminApplicationUpdateAuthClient/index.jsx

@@ -16,7 +16,7 @@ function AdminApplicationUpdateAuthClient(props) {
   const { clientId } = useParams();
 
   const { data: adminAppAuthClient, isLoading: isAdminAuthClientLoading } =
-    useAdminAppAuthClient(clientId);
+    useAdminAppAuthClient(application.key, clientId);
 
   const { data: auth } = useAppAuth(application.key);
 

packages/web/src/components/EditableTypography/index.jsx

@@ -41,6 +41,7 @@ function EditableTypography(props) {
   if (editing) {
     component = (
       <TextField
+        data-test="editableTypographyInput"
         onClick={handleTextFieldClick}
         onKeyDown={handleTextFieldKeyDown}
         onBlur={handleTextFieldBlur}

packages/web/src/components/EditorLayout/index.jsx

@@ -101,6 +101,7 @@ export default function EditorLayout() {
 
           {!isFlowLoading && (
             <EditableTypography
+              data-test="editableTypography"
               variant="body1"
               onConfirm={onFlowNameUpdate}
               noWrap

packages/web/src/components/FlowStep/index.jsx

@@ -13,6 +13,7 @@ import CircularProgress from '@mui/material/CircularProgress';
 import CheckCircleIcon from '@mui/icons-material/CheckCircle';
 import { yupResolver } from '@hookform/resolvers/yup';
 import * as yup from 'yup';
+import { isEqual } from 'lodash';
 
 import { EditorContext } from 'contexts/Editor';
 import { StepExecutionsProvider } from 'contexts/StepExecutions';
@@ -177,7 +178,9 @@ function FlowStep(props) {
   }, []);
 
   const handleSubmit = (val) => {
-    handleChange({ step: val });
+    if (!isEqual(step, val)) {
+      handleChange({ step: val });
+    }
   };
 
   const stepValidationSchema = React.useMemo(

packages/web/src/components/PowerInput/data.js

@@ -25,25 +25,40 @@ const process = ({ data, parentKey, index, parentLabel = '' }) => {
         sampleValue: JSON.stringify(sampleValue),
       };
 
-      const arrayItems =  sampleValue.flatMap((item, index) =>
-        process({
+      const arrayItems = sampleValue.flatMap((item, index) => {
+        const itemItself = {
+          label: `${label}.${index}`,
+          value: `${value}.${index}`,
+          sampleValue: JSON.stringify(item),
+        };
+
+        const itemEntries = process({
           data: item,
           parentKey: value,
           index,
           parentLabel: label,
-        }),
-      );
+        });
 
-      // TODO: remove spreading
-      return [arrayItself, ...arrayItems];
+        return [itemItself].concat(itemEntries);
+      });
+
+      return [arrayItself].concat(arrayItems);
     }
 
     if (typeof sampleValue === 'object' && sampleValue !== null) {
-      return process({
+      const objectItself = {
+        label,
+        value,
+        sampleValue: JSON.stringify(sampleValue),
+      };
+
+      const objectEntries = process({
         data: sampleValue,
         parentKey: value,
         parentLabel: label,
       });
+
+      return [objectItself].concat(objectEntries);
     }
 
     return [

packages/web/src/components/TestSubstep/index.jsx

@@ -62,11 +62,11 @@ function TestSubstep(props) {
 
   React.useEffect(
     function resetTestDataOnSubstepToggle() {
-      if (!expanded) {
+      if (!expanded && !loading) {
         reset();
       }
     },
-    [expanded, reset],
+    [expanded, reset, loading],
   );
 
   const handleSubmit = React.useCallback(async () => {
@@ -118,7 +118,11 @@ function TestSubstep(props) {
           )}
 
           {hasNoOutput && (
-            <Alert severity="warning" sx={{ mb: 1, width: '100%' }}>
+            <Alert
+              data-test="flow-test-substep-no-output"
+              severity="warning"
+              sx={{ mb: 1, width: '100%' }}
+            >
               <AlertTitle sx={{ fontWeight: 700 }}>
                 {formatMessage('flowEditor.noTestDataTitle')}
               </AlertTitle>

packages/web/src/graphql/mutations/create-app-auth-client.js

@@ -1,11 +0,0 @@
-import { gql } from '@apollo/client';
-export const CREATE_APP_AUTH_CLIENT = gql`
-  mutation CreateAppAuthClient($input: CreateAppAuthClientInput) {
-    createAppAuthClient(input: $input) {
-      id
-      appConfigId
-      name
-      active
-    }
-  }
-`;

packages/web/src/graphql/mutations/create-app-config.js

@@ -1,12 +0,0 @@
-import { gql } from '@apollo/client';
-export const CREATE_APP_CONFIG = gql`
-  mutation CreateAppConfig($input: CreateAppConfigInput) {
-    createAppConfig(input: $input) {
-      id
-      key
-      allowCustomConnection
-      shared
-      disabled
-    }
-  }
-`;

packages/web/src/hooks/useAdminAppAuthClient.ee.js

@@ -2,17 +2,17 @@ import { useQuery } from '@tanstack/react-query';
 
 import api from 'helpers/api';
 
-export default function useAdminAppAuthClient(id) {
+export default function useAdminAppAuthClient(appKey, id) {
   const query = useQuery({
-    queryKey: ['admin', 'appAuthClients', id],
+    queryKey: ['admin', 'apps', appKey, 'authClients', id],
     queryFn: async ({ signal }) => {
-      const { data } = await api.get(`/v1/admin/app-auth-clients/${id}`, {
+      const { data } = await api.get(`/v1/admin/apps/${appKey}/auth-clients/${id}`, {
         signal,
       });
 
       return data;
     },
-    enabled: !!id,
+    enabled: !!appKey && !!id,
   });
 
   return query;

packages/web/src/hooks/useAdminAppAuthClients.js

@@ -1,9 +1,9 @@
 import { useQuery } from '@tanstack/react-query';
 import api from 'helpers/api';
 
-export default function useAdminAppAuthClient(appKey) {
+export default function useAdminAppAuthClients(appKey) {
   const query = useQuery({
-    queryKey: ['admin', 'apps', appKey, 'auth-clients'],
+    queryKey: ['admin', 'apps', appKey, 'authClients'],
     queryFn: async ({ signal }) => {
       const { data } = await api.get(`/v1/admin/apps/${appKey}/auth-clients`, {
         signal,

packages/web/src/hooks/useAdminCreateAppAuthClient.ee.js

@@ -0,0 +1,21 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import api from 'helpers/api';
+
+export default function useAdminCreateAppAuthClient(appKey) {
+  const queryClient = useQueryClient();
+
+  const query = useMutation({
+    mutationFn: async (payload) => {
+      const { data } = await api.post(`/v1/admin/apps/${appKey}/auth-clients`, payload);
+
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ['admin', 'apps', appKey, 'authClients'],
+      });
+    }
+  });
+
+  return query;
+}

packages/web/src/hooks/useAdminCreateAppConfig.js

@@ -0,0 +1,21 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import api from 'helpers/api';
+
+export default function useAdminCreateAppConfig(appKey) {
+  const queryClient = useQueryClient();
+
+  const query = useMutation({
+    mutationFn: async (payload) => {
+      const { data } = await api.post(`/v1/admin/apps/${appKey}/config`, payload);
+
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ['apps', appKey, 'config'],
+      });
+    }
+  });
+
+  return query;
+}

yarn.lock

@@ -5986,7 +5986,7 @@ brace-expansion@^2.0.1:
   dependencies:
     balanced-match "^1.0.0"
 
-braces@^3.0.1, braces@~3.0.2:
+braces@^3.0.3, braces@~3.0.2:
   version "3.0.3"
   resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789"
   integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==
@@ -11630,12 +11630,12 @@ micro@^10.0.1:
     raw-body "2.4.1"
 
 micromatch@^4.0.2, micromatch@^4.0.4:
-  version "4.0.4"
-  resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz"
-  integrity sha512-pRmzw/XUcwXGpD9aI9q/0XOwLNygjETJ8y0ao0wdqprrzDa4YnxLcz7fQRZr8voh8V10kGhABbNcHVk5wHgWwg==
+  version "4.0.8"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.8.tgz#d66fa18f3a47076789320b9b1af32bd86d9fa202"
+  integrity sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==
   dependencies:
-    braces "^3.0.1"
-    picomatch "^2.2.3"
+    braces "^3.0.3"
+    picomatch "^2.3.1"
 
 mime-db@1.51.0, "mime-db@>= 1.43.0 < 2":
   version "1.51.0"
@@ -13073,9 +13073,9 @@ picocolors@^1.0.0:
   resolved "https://registry.npmjs.org/picocolors/-/picocolors-1.0.0.tgz"
   integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==
 
-picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.2, picomatch@^2.2.3:
+picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.2.2, picomatch@^2.2.3, picomatch@^2.3.1:
   version "2.3.1"
-  resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42"
   integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==
 
 pify@^2.3.0: