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/db/migrations/20240822111546_add_prevent_users_from_updating_their_profiles_user_management_in_config.js

@@ -1,12 +0,0 @@
-export async function up(knex) {
-  await knex('config').insert({
-    key: 'userManagement.preventUsersFromUpdatingTheirProfile',
-    value: {
-      data: false
-    }
-  });
-};
-
-export async function down(knex) {
-  await knex('config').where({ key: 'userManagement.preventUsersFromUpdatingTheirProfile' }).delete();
-};

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

@@ -6,10 +6,21 @@ function getParameterEntries(parameters) {
   return Object.entries(parameters);
 }
 
-function computeParameterEntries(parameterEntries, executionSteps) {
+function getFieldByKey(key, fields = []) {
+  return fields.find((field) => field.key === key);
+};
+
+function getParameterValueType(parameterKey, fields) {
+  const field = getFieldByKey(parameterKey, fields);
+  const defaultValueType = 'string';
+
+  return field?.valueType || defaultValueType;
+}
+
+function computeParameterEntries(parameterEntries, fields, executionSteps) {
   const defaultComputedParameters = {};
   return parameterEntries.reduce((result, [key, value]) => {
-    const parameterComputedValue = computeParameter(value, executionSteps);
+    const parameterComputedValue = computeParameter(key, value, fields, executionSteps);
 
     return {
       ...result,
@@ -18,14 +29,21 @@ function computeParameterEntries(parameterEntries, executionSteps) {
   }, defaultComputedParameters);
 }
 
-function computeParameter(value, executionSteps) {
+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(value, executionSteps);
+    const computedStringParameter = computeStringParameter(key, value, fields, executionSteps);
     return computedStringParameter;
   }
 
   if (Array.isArray(value)) {
-    const computedArrayParameter = computeArrayParameter(value, executionSteps);
+    const computedArrayParameter = computeArrayParameter(key, value, fields, executionSteps);
     return computedArrayParameter;
   }
 
@@ -107,7 +125,7 @@ function autoParseComputedVariable(computedVariable) {
   }
 }
 
-function computeStringParameter(stringValue, executionSteps) {
+function computeStringParameter(key, stringValue, fields, executionSteps) {
   const parts = splitByVariable(stringValue);
 
   const computedValue = parts
@@ -122,17 +140,26 @@ function computeStringParameter(stringValue, executionSteps) {
     })
     .join('');
 
-  const autoParsedValue = autoParseComputedVariable(computedValue);
+  const autoParse = shouldAutoParse(key, fields);
+  if (autoParse) {
+    const autoParsedValue = autoParseComputedVariable(computedValue);
 
-  return autoParsedValue;
+    return autoParsedValue;
+  }
+
+  return computedValue;
 }
 
-function computeArrayParameter(arrayValue, executionSteps) {
-  return arrayValue.map((item) => computeParameters(item, executionSteps));
+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, executionSteps) {
+export default function computeParameters(parameters, fields, executionSteps) {
   const parameterEntries = getParameterEntries(parameters);
 
-  return computeParameterEntries(parameterEntries, executionSteps);
+  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

@@ -11,7 +11,6 @@ export class FlowEditorPage extends AuthenticatedPage {
   constructor(page) {
     super(page);
 
-    this.page = page;
     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');
@@ -77,7 +76,8 @@ export class FlowEditorPage extends AuthenticatedPage {
   }
 
   async testAndContinue() {
-    await this.continueButton.last().click();
+    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

@@ -20,14 +20,16 @@ test.describe('Webhook flow', () => {
 
     await flowEditorPage.chooseAppAndEvent('Webhook', 'Respond with');
 
-    await expect(flowEditorPage.continueButton.last()).not.toBeEnabled();
+    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.last()).not.toBeEnabled();
+    await expect(flowEditorPage.continueButton).toHaveCount(1);
+    await expect(flowEditorPage.continueButton).not.toBeEnabled();
 
     await page
       .getByTestId('parameters.body-power-input')
@@ -54,15 +56,16 @@ test.describe('Webhook flow', () => {
     const asyncWebhookUrl = await flowEditorPage.createWebhookTrigger(false);
 
     await flowEditorPage.chooseAppAndEvent('Webhook', 'Respond with');
-
-    await expect(flowEditorPage.continueButton.last()).not.toBeEnabled();
+    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.last()).not.toBeEnabled();
+    await expect(flowEditorPage.continueButton).toHaveCount(1);
+    await expect(flowEditorPage.continueButton).not.toBeEnabled();
 
     await page
       .getByTestId('parameters.body-power-input')

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

@@ -7,7 +7,6 @@ import DialogContentText from '@mui/material/DialogContentText';
 import DialogTitle from '@mui/material/DialogTitle';
 import * as React from 'react';
 import { useNavigate, useSearchParams } from 'react-router-dom';
-import { useQueryClient } from '@tanstack/react-query';
 
 import { AppPropType } from 'propTypes/propTypes';
 import AppAuthClientsDialog from 'components/AppAuthClientsDialog/index.ee';
@@ -18,6 +17,7 @@ import useFormatMessage from 'hooks/useFormatMessage';
 import { generateExternalLink } from 'helpers/translationValues';
 import { Form } from './style';
 import useAppAuth from 'hooks/useAppAuth';
+import { useQueryClient } from '@tanstack/react-query';
 
 function AddAppConnection(props) {
   const { application, connectionId, onClose } = props;

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/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/LoginForm/index.jsx

@@ -12,7 +12,6 @@ import TextField from 'components/TextField';
 import useFormatMessage from 'hooks/useFormatMessage';
 import useCreateAccessToken from 'hooks/useCreateAccessToken';
 import useEnqueueSnackbar from 'hooks/useEnqueueSnackbar';
-import usePreventUsersFromUpdatingTheirProfile from 'hooks/usePreventUsersFromUpdatingTheirProfile';
 
 function LoginForm() {
   const isCloud = useCloud();
@@ -20,7 +19,6 @@ function LoginForm() {
   const formatMessage = useFormatMessage();
   const enqueueSnackbar = useEnqueueSnackbar();
   const authentication = useAuthentication();
-  const preventUsersFromUpdatingTheirProfile = usePreventUsersFromUpdatingTheirProfile();
   const { mutateAsync: createAccessToken, isPending: loading } =
     useCreateAccessToken();
 
@@ -86,7 +84,7 @@ function LoginForm() {
           sx={{ mb: 1 }}
         />
 
-        {isCloud && !preventUsersFromUpdatingTheirProfile && (
+        {isCloud && (
           <Link
             component={RouterLink}
             to={URLS.FORGOT_PASSWORD}

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

@@ -40,10 +40,6 @@ function Switch(props) {
         <FormControlLabel
           className={className}
           {...FormControlLabelProps}
-          componentsProps={{
-            typography: {
-              display: 'flex',
-          }}}
           control={
             <MuiSwitch
               {...switchProps}

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 data-test="flow-test-substep-no-output" 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;
+}

packages/web/src/hooks/usePreventUsersFromUpdatingTheirProfile.js

@@ -1,13 +0,0 @@
-import useAutomatischConfig from 'hooks/useAutomatischConfig';
-
-export default function usePreventUsersFromUpdatingTheirProfile() {
-  const { data, isSuccess } =
-    useAutomatischConfig();
-  const automatischConfig = data?.data;
-
-  const preventUsersFromUpdatingTheirProfile = isSuccess ? automatischConfig['userManagement.preventUsersFromUpdatingTheirProfile'] : false;
-
-  console.log('preventUsersFromUpdatingTheirProfile', preventUsersFromUpdatingTheirProfile, automatischConfig)
-
-  return preventUsersFromUpdatingTheirProfile;
-}

packages/web/src/locales/en.json

@@ -259,26 +259,20 @@
   "userInterfacePage.primaryLightColorFieldLabel": "Primary light color",
   "userInterfacePage.svgDataFieldLabel": "Logo SVG code",
   "userInterfacePage.submit": "Update",
-  "authenticationPage.title": "Authentication",
-  "authenticationConfig.title": "User management",
-  "authenticationConfig.userManagementPreventUsersFromUpdatingTheirProfile": "Prevent users from updating their profile",
-  "authenticationConfig.userManagementPreventUsersFromUpdatingTheirProfileTooltip": "This will prevent users from updating their full name, email and password. This is useful when you want to manage users from your own identity provider.",
-  "authenticationConfig.save": "Save",
-  "authenticationConfig.successfullySaved": "The configuration has been saved.",
-  "samlAuthenticationPage.title": "Single Sign-On with SAML",
-  "samlAuthenticationForm.active": "Active",
-  "samlAuthenticationForm.name": "Name",
-  "samlAuthenticationForm.certificate": "Certificate",
-  "samlAuthenticationForm.signatureAlgorithm": "Signature algorithm",
-  "samlAuthenticationForm.issuer": "Issuer",
-  "samlAuthenticationForm.entryPoint": "Entry point",
-  "samlAuthenticationForm.firstnameAttributeName": "Firstname attribute name",
-  "samlAuthenticationForm.surnameAttributeName": "Surname attribute name",
-  "samlAuthenticationForm.emailAttributeName": "Email attribute name",
-  "samlAuthenticationForm.roleAttributeName": "Role attribute name",
-  "samlAuthenticationForm.defaultRole": "Default role",
-  "samlAuthenticationForm.successfullySaved": "The provider has been saved.",
-  "samlAuthenticationForm.save": "Save",
+  "authenticationPage.title": "Single Sign-On with SAML",
+  "authenticationForm.active": "Active",
+  "authenticationForm.name": "Name",
+  "authenticationForm.certificate": "Certificate",
+  "authenticationForm.signatureAlgorithm": "Signature algorithm",
+  "authenticationForm.issuer": "Issuer",
+  "authenticationForm.entryPoint": "Entry point",
+  "authenticationForm.firstnameAttributeName": "Firstname attribute name",
+  "authenticationForm.surnameAttributeName": "Surname attribute name",
+  "authenticationForm.emailAttributeName": "Email attribute name",
+  "authenticationForm.roleAttributeName": "Role attribute name",
+  "authenticationForm.defaultRole": "Default role",
+  "authenticationForm.successfullySaved": "The provider has been saved.",
+  "authenticationForm.save": "Save",
   "roleMappingsForm.title": "Role mappings",
   "roleMappingsForm.remoteRoleName": "Remote role name",
   "roleMappingsForm.role": "Role",

packages/web/src/pages/Authentication/AuthenticationConfig.jsx

@@ -1,98 +0,0 @@
-import { useMutation } from '@apollo/client';
-import LoadingButton from '@mui/lab/LoadingButton';
-import Stack from '@mui/material/Stack';
-import Switch from 'components/Switch';
-import Typography from '@mui/material/Typography';
-import Tooltip from '@mui/material/Tooltip';
-import useEnqueueSnackbar from 'hooks/useEnqueueSnackbar';
-import InfoOutlinedIcon from '@mui/icons-material/InfoOutlined';
-
-import Form from 'components/Form';
-import useFormatMessage from 'hooks/useFormatMessage';
-import useAutomatischConfig from 'hooks/useAutomatischConfig';
-import { UPDATE_CONFIG } from 'graphql/mutations/update-config.ee';
-import { useQueryClient } from '@tanstack/react-query';
-
-function AuthenticationConfig() {
-  const formatMessage = useFormatMessage();
-  const enqueueSnackbar = useEnqueueSnackbar();
-  const queryClient = useQueryClient();
-  const { data, isLoading: isAutomatischConfigLoading } =
-    useAutomatischConfig();
-  const automatischConfig = data?.data;
-
-  const [
-    updateConfig,
-    { loading: updateConfigLoading },
-  ] = useMutation(UPDATE_CONFIG);
-
-  const handleSubmit = async (values) => {
-    try {
-      await updateConfig({
-        variables: {
-          input: {
-            'userManagement.preventUsersFromUpdatingTheirProfile': values.userManagement.preventUsersFromUpdatingTheirProfile,
-          },
-        },
-      });
-
-      await queryClient.invalidateQueries({
-        queryKey: ['automatisch', 'config'],
-      });
-
-      enqueueSnackbar(formatMessage('authenticationConfig.successfullySaved'), {
-        variant: 'success',
-        SnackbarProps: {
-          'data-test': 'snackbar-update-role-mappings-success',
-        },
-      });
-    } catch (error) {
-      throw new Error('Failed while saving!');
-    }
-  };
-
-  if (isAutomatischConfigLoading) {
-    return null;
-  }
-
-  return (
-    <>
-      <Typography variant="h4">
-        {formatMessage('authenticationConfig.title')}
-      </Typography>
-
-      <Form defaultValues={automatischConfig} onSubmit={handleSubmit}>
-        <Stack direction="column" spacing={2}>
-          <Switch
-            name="userManagement.preventUsersFromUpdatingTheirProfile"
-            label={<>
-              {formatMessage('authenticationConfig.userManagementPreventUsersFromUpdatingTheirProfile')}
-
-              <Tooltip
-                title={formatMessage('authenticationConfig.userManagementPreventUsersFromUpdatingTheirProfileTooltip')}
-                sx={{ ml: 1 }}
-              >
-                <InfoOutlinedIcon />
-              </Tooltip>
-            </>}
-          />
-
-          <LoadingButton
-            type="submit"
-            variant="contained"
-            color="primary"
-            sx={{ boxShadow: 2 }}
-            loading={updateConfigLoading}
-          >
-            {formatMessage('authenticationConfig.save')}
-          </LoadingButton>
-        </Stack>
-      </Form>
-    </>
-  );
-}
-
-AuthenticationConfig.propTypes = {
-};
-
-export default AuthenticationConfig;

packages/web/src/pages/Authentication/RoleMappings.jsx

@@ -1,6 +1,7 @@
 import PropTypes from 'prop-types';
 import { useMutation } from '@apollo/client';
 import LoadingButton from '@mui/lab/LoadingButton';
+import Divider from '@mui/material/Divider';
 import Stack from '@mui/material/Stack';
 import Typography from '@mui/material/Typography';
 import useEnqueueSnackbar from 'hooks/useEnqueueSnackbar';
@@ -84,6 +85,7 @@ function RoleMappings({ provider, providerLoading }) {
 
   return (
     <>
+      <Divider sx={{ pt: 2 }} />
       <Typography variant="h3">
         {formatMessage('roleMappingsForm.title')}
       </Typography>

packages/web/src/pages/Authentication/SamlConfiguration.jsx

@@ -75,7 +75,7 @@ function SamlConfiguration({ provider, providerLoading }) {
         },
       });
 
-      enqueueSnackbar(formatMessage('samlAuthenticationForm.successfullySaved'), {
+      enqueueSnackbar(formatMessage('authenticationForm.successfullySaved'), {
         variant: 'success',
         SnackbarProps: {
           'data-test': 'snackbar-save-saml-provider-success',
@@ -98,18 +98,18 @@ function SamlConfiguration({ provider, providerLoading }) {
       <Stack direction="column" gap={2}>
         <Switch
           name="active"
-          label={formatMessage('samlAuthenticationForm.active')}
+          label={formatMessage('authenticationForm.active')}
         />
         <TextField
           required={true}
           name="name"
-          label={formatMessage('samlAuthenticationForm.name')}
+          label={formatMessage('authenticationForm.name')}
           fullWidth
         />
         <TextField
           required={true}
           name="certificate"
-          label={formatMessage('samlAuthenticationForm.certificate')}
+          label={formatMessage('authenticationForm.certificate')}
           fullWidth
           multiline
         />
@@ -126,44 +126,44 @@ function SamlConfiguration({ provider, providerLoading }) {
           renderInput={(params) => (
             <MuiTextField
               {...params}
-              label={formatMessage('samlAuthenticationForm.signatureAlgorithm')}
+              label={formatMessage('authenticationForm.signatureAlgorithm')}
             />
           )}
         />
         <TextField
           required={true}
           name="issuer"
-          label={formatMessage('samlAuthenticationForm.issuer')}
+          label={formatMessage('authenticationForm.issuer')}
           fullWidth
         />
         <TextField
           required={true}
           name="entryPoint"
-          label={formatMessage('samlAuthenticationForm.entryPoint')}
+          label={formatMessage('authenticationForm.entryPoint')}
           fullWidth
         />
         <TextField
           required={true}
           name="firstnameAttributeName"
-          label={formatMessage('samlAuthenticationForm.firstnameAttributeName')}
+          label={formatMessage('authenticationForm.firstnameAttributeName')}
           fullWidth
         />
         <TextField
           required={true}
           name="surnameAttributeName"
-          label={formatMessage('samlAuthenticationForm.surnameAttributeName')}
+          label={formatMessage('authenticationForm.surnameAttributeName')}
           fullWidth
         />
         <TextField
           required={true}
           name="emailAttributeName"
-          label={formatMessage('samlAuthenticationForm.emailAttributeName')}
+          label={formatMessage('authenticationForm.emailAttributeName')}
           fullWidth
         />
         <TextField
           required={true}
           name="roleAttributeName"
-          label={formatMessage('samlAuthenticationForm.roleAttributeName')}
+          label={formatMessage('authenticationForm.roleAttributeName')}
           fullWidth
         />
         <ControlledAutocomplete
@@ -175,7 +175,7 @@ function SamlConfiguration({ provider, providerLoading }) {
           renderInput={(params) => (
             <MuiTextField
               {...params}
-              label={formatMessage('samlAuthenticationForm.defaultRole')}
+              label={formatMessage('authenticationForm.defaultRole')}
             />
           )}
           loading={isRolesLoading}
@@ -187,7 +187,7 @@ function SamlConfiguration({ provider, providerLoading }) {
           sx={{ boxShadow: 2 }}
           loading={loading}
         >
-          {formatMessage('samlAuthenticationForm.save')}
+          {formatMessage('authenticationForm.save')}
         </LoadingButton>
       </Stack>
     </Form>

packages/web/src/pages/Authentication/index.jsx

@@ -2,14 +2,11 @@ import Grid from '@mui/material/Grid';
 import Stack from '@mui/material/Stack';
 import PageTitle from 'components/PageTitle';
 import Container from 'components/Container';
-import Divider from '@mui/material/Divider';
 import useFormatMessage from 'hooks/useFormatMessage';
 import useSamlAuthProvider from 'hooks/useSamlAuthProvider';
-import AuthenticationConfig from './AuthenticationConfig';
 import SamlConfiguration from './SamlConfiguration';
 import RoleMappings from './RoleMappings';
 import useAdminSamlAuthProviders from 'hooks/useAdminSamlAuthProviders.ee';
-
 function AuthenticationPage() {
   const formatMessage = useFormatMessage();
 
@@ -19,37 +16,20 @@ function AuthenticationPage() {
   const { data, isLoading: isProviderLoading } = useSamlAuthProvider({
     samlAuthProviderId,
   });
-
   const provider = data?.data;
 
   return (
     <Container sx={{ py: 3, display: 'flex', justifyContent: 'center' }}>
       <Grid container item xs={12} sm={10} md={9}>
-        <Grid container item xs={12}>
+        <Grid container item xs={12} sx={{ mb: [2, 5] }}>
           <PageTitle>{formatMessage('authenticationPage.title')}</PageTitle>
         </Grid>
-
-        <Grid item xs={12} sx={{ pt: 5, pb: 5 }}>
-          <Stack spacing={5}>
-            <AuthenticationConfig />
-
-            <Divider />
-          </Stack>
-        </Grid>
-
-        <Grid container item xs={12}>
-          <PageTitle variant="h4">{formatMessage('samlAuthenticationPage.title')}</PageTitle>
-        </Grid>
-
         <Grid item xs={12} sx={{ pt: 5, pb: 5 }}>
           <Stack spacing={5}>
             <SamlConfiguration
               provider={provider}
               providerLoading={isProviderLoading}
             />
-
-            <Divider />
-
             <RoleMappings
               provider={provider}
               providerLoading={isProviderLoading}

packages/web/src/pages/Login/index.jsx

@@ -10,7 +10,6 @@ export default function Login() {
       <Container maxWidth="sm">
         <Stack direction="column" gap={2}>
           <LoginForm />
-
           <SsoProviders />
         </Stack>
       </Container>

packages/web/src/routes.jsx

@@ -29,14 +29,12 @@ import adminSettingsRoutes from './adminSettingsRoutes';
 import Notifications from 'pages/Notifications';
 import useAutomatischConfig from 'hooks/useAutomatischConfig';
 import useAuthentication from 'hooks/useAuthentication';
-import usePreventUsersFromUpdatingTheirProfile from 'hooks/usePreventUsersFromUpdatingTheirProfile';
 import useAutomatischInfo from 'hooks/useAutomatischInfo';
 import Installation from 'pages/Installation';
 
 function Routes() {
   const { data: automatischInfo, isSuccess } = useAutomatischInfo();
   const { data: configData } = useAutomatischConfig();
-  const preventUsersFromUpdatingTheirProfile = usePreventUsersFromUpdatingTheirProfile();
   const { isAuthenticated } = useAuthentication();
   const config = configData?.data;
 
@@ -136,14 +134,14 @@ function Routes() {
         }
       />
 
-      {preventUsersFromUpdatingTheirProfile === false && <Route
+      <Route
         path={URLS.FORGOT_PASSWORD}
         element={
           <PublicLayout>
             <ForgotPassword />
           </PublicLayout>
         }
-      />}
+      />
 
       <Route
         path={URLS.RESET_PASSWORD}

packages/web/src/styles/theme.js

@@ -95,11 +95,11 @@ export const defaultTheme = createTheme({
       },
     },
     h4: {
-      fontSize: referenceTheme.typography.pxToRem(28),
+      fontSize: referenceTheme.typography.pxToRem(32),
       lineHeight: 1.3,
       fontWeight: 700,
       [referenceTheme.breakpoints.down('sm')]: {
-        fontSize: referenceTheme.typography.pxToRem(22),
+        fontSize: referenceTheme.typography.pxToRem(16),
       },
     },
     h5: {

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: