snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/twenty-config/constants/config-test-keys.constants.ts

@@ -0,0 +1,16 @@
+import { type ConfigVariables } from 'src/engine/core-modules/twenty-config/config-variables';
+
+type ConfigKey = keyof ConfigVariables;
+
+export const TEST_KEY_DEFAULT: ConfigKey = 'IS_ATTACHMENT_PREVIEW_ENABLED';
+export const TEST_KEY_NOTIFICATION: ConfigKey =
+  'WORKSPACE_INACTIVE_DAYS_BEFORE_NOTIFICATION';
+export const TEST_KEY_SOFT_DELETION: ConfigKey =
+  'WORKSPACE_INACTIVE_DAYS_BEFORE_SOFT_DELETION';
+export const TEST_KEY_DELETION: ConfigKey =
+  'WORKSPACE_INACTIVE_DAYS_BEFORE_DELETION';
+export const TEST_KEY_METRICS: ConfigKey =
+  'HEALTH_METRICS_TIME_WINDOW_IN_MINUTES';
+export const TEST_KEY_ENV_ONLY: ConfigKey = 'PG_DATABASE_URL';
+export const TEST_KEY_NONEXISTENT = 'NONEXISTENT_CONFIG_KEY';
+export const TEST_KEY_STRING_VALUE: ConfigKey = 'EMAIL_FROM_NAME';

packages/twenty-server/test/integration/twenty-config/twenty-config.integration-spec.ts

@@ -0,0 +1,489 @@
+import {
+  TEST_KEY_DEFAULT,
+  TEST_KEY_DELETION,
+  TEST_KEY_ENV_ONLY,
+  TEST_KEY_METRICS,
+  TEST_KEY_NONEXISTENT,
+  TEST_KEY_NOTIFICATION,
+  TEST_KEY_SOFT_DELETION,
+  TEST_KEY_STRING_VALUE,
+} from 'test/integration/twenty-config/constants/config-test-keys.constants';
+
+import { createConfigVariable } from './utils/create-config-variable.util';
+import { deleteConfigVariable } from './utils/delete-config-variable.util';
+import { getConfigVariable } from './utils/get-config-variable.util';
+import { getConfigVariablesGrouped } from './utils/get-config-variables-grouped.util';
+import { makeUnauthenticatedAPIRequest } from './utils/make-unauthenticated-api-request.util';
+import { updateConfigVariable } from './utils/update-config-variable.util';
+
+describe('TwentyConfig Integration', () => {
+  afterAll(async () => {
+    await deleteConfigVariable({
+      input: { key: TEST_KEY_NOTIFICATION },
+    }).catch(() => {});
+    await deleteConfigVariable({
+      input: { key: TEST_KEY_SOFT_DELETION },
+    }).catch(() => {});
+    await deleteConfigVariable({
+      input: { key: TEST_KEY_DELETION },
+    }).catch(() => {});
+    await deleteConfigVariable({
+      input: { key: TEST_KEY_METRICS },
+    }).catch(() => {});
+  });
+
+  describe('Basic config operations', () => {
+    it('should get config variable with DEFAULT source when not overridden', async () => {
+      const result = await getConfigVariable({
+        input: {
+          key: TEST_KEY_DEFAULT,
+        },
+      });
+
+      expect(result.data.getDatabaseConfigVariable).toBeDefined();
+      expect(result.data.getDatabaseConfigVariable.source).toBe('DEFAULT');
+    });
+
+    it('should show DATABASE source when overridden and DEFAULT after deletion', async () => {
+      const defaultResult = await getConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+        },
+      });
+
+      expect(defaultResult.data.getDatabaseConfigVariable.source).toBe(
+        'DEFAULT',
+      );
+
+      const overrideValue = 999;
+
+      await createConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+          value: overrideValue,
+        },
+      });
+
+      const overrideResult = await getConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+        },
+      });
+
+      expect(overrideResult.data.getDatabaseConfigVariable.source).toBe(
+        'DATABASE',
+      );
+      expect(overrideResult.data.getDatabaseConfigVariable.value).toBe(
+        overrideValue,
+      );
+
+      const newOverrideValue = 888;
+
+      await updateConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+          value: newOverrideValue,
+        },
+      });
+
+      const updatedResult = await getConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+        },
+      });
+
+      expect(updatedResult.data.getDatabaseConfigVariable.source).toBe(
+        'DATABASE',
+      );
+      expect(updatedResult.data.getDatabaseConfigVariable.value).toBe(
+        newOverrideValue,
+      );
+
+      await deleteConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+        },
+      });
+
+      const afterDeleteResult = await getConfigVariable({
+        input: {
+          key: TEST_KEY_NOTIFICATION,
+        },
+      });
+
+      expect(afterDeleteResult.data.getDatabaseConfigVariable.source).toBe(
+        'DEFAULT',
+      );
+    });
+  });
+
+  describe('Create operations', () => {
+    it('should be able to create and retrieve config variables', async () => {
+      const testKey = TEST_KEY_SOFT_DELETION;
+      const testValue = 777;
+
+      const createResult = await createConfigVariable({
+        input: {
+          key: testKey,
+          value: testValue,
+        },
+      });
+
+      expect(createResult.data.createDatabaseConfigVariable).toBe(true);
+
+      const getResult = await getConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(getResult.data.getDatabaseConfigVariable.value).toBe(testValue);
+      expect(getResult.data.getDatabaseConfigVariable.source).toBe('DATABASE');
+
+      await deleteConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+    });
+
+    it('should reject creating config variables with invalid types', async () => {
+      const result = await createConfigVariable({
+        input: {
+          key: TEST_KEY_DEFAULT,
+          value: 'not-a-boolean',
+        },
+        expectToFail: true,
+      });
+
+      expect(result.errors).toBeDefined();
+      expect(result.errors[0].message).toContain('Expected boolean');
+    });
+  });
+
+  describe('Update operations', () => {
+    it('should be able to update existing config variables', async () => {
+      const testKey = TEST_KEY_DELETION;
+      const initialValue = 555;
+      const updatedValue = 666;
+
+      await createConfigVariable({
+        input: {
+          key: testKey,
+          value: initialValue,
+        },
+      });
+
+      const initialResult = await getConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(initialResult.data.getDatabaseConfigVariable.source).toBe(
+        'DATABASE',
+      );
+      expect(initialResult.data.getDatabaseConfigVariable.value).toBe(
+        initialValue,
+      );
+
+      const updateResult = await updateConfigVariable({
+        input: {
+          key: testKey,
+          value: updatedValue,
+        },
+      });
+
+      expect(updateResult.data.updateDatabaseConfigVariable).toBe(true);
+
+      const getResult = await getConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(getResult.data.getDatabaseConfigVariable.source).toBe('DATABASE');
+      expect(getResult.data.getDatabaseConfigVariable.value).toBe(updatedValue);
+
+      await deleteConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+    });
+
+    it('should handle concurrent updates to the same config variable', async () => {
+      const testKey = TEST_KEY_METRICS;
+      const initialValue = 5;
+      const newValue1 = 10;
+      const newValue2 = 20;
+
+      await createConfigVariable({
+        input: {
+          key: testKey,
+          value: initialValue,
+        },
+      });
+
+      const update1 = updateConfigVariable({
+        input: {
+          key: testKey,
+          value: newValue1,
+        },
+      });
+
+      const update2 = updateConfigVariable({
+        input: {
+          key: testKey,
+          value: newValue2,
+        },
+      });
+
+      await Promise.all([update1, update2]);
+
+      const getResult = await getConfigVariable({
+        input: { key: testKey },
+      });
+
+      expect([newValue1, newValue2]).toContain(
+        getResult.data.getDatabaseConfigVariable.value,
+      );
+
+      await deleteConfigVariable({
+        input: { key: testKey },
+      });
+    });
+
+    it('should reject updating config variables with invalid types', async () => {
+      await createConfigVariable({
+        input: {
+          key: TEST_KEY_DEFAULT,
+          value: true,
+        },
+      });
+
+      const updateResult = await updateConfigVariable({
+        input: {
+          key: TEST_KEY_DEFAULT,
+          value: 'not-a-boolean',
+        },
+        expectToFail: true,
+      });
+
+      expect(updateResult.errors).toBeDefined();
+      expect(updateResult.errors[0].message).toContain('Expected boolean');
+
+      await deleteConfigVariable({
+        input: { key: TEST_KEY_DEFAULT },
+      });
+    });
+  });
+
+  describe('Delete operations', () => {
+    it('should return to DEFAULT source after deleting a variable', async () => {
+      const testKey = TEST_KEY_DELETION;
+      const testValue = 333;
+
+      await createConfigVariable({
+        input: {
+          key: testKey,
+          value: testValue,
+        },
+      });
+
+      const beforeDelete = await getConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(beforeDelete.data.getDatabaseConfigVariable).toBeDefined();
+      expect(beforeDelete.data.getDatabaseConfigVariable.source).toBe(
+        'DATABASE',
+      );
+      expect(beforeDelete.data.getDatabaseConfigVariable.value).toBe(testValue);
+
+      const deleteResult = await deleteConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(deleteResult.data.deleteDatabaseConfigVariable).toBe(true);
+
+      const afterDelete = await getConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(afterDelete.data.getDatabaseConfigVariable).toBeDefined();
+      expect(afterDelete.data.getDatabaseConfigVariable.source).toBe('DEFAULT');
+    });
+  });
+
+  describe('Listing operations', () => {
+    it('should be able to get all config variables grouped', async () => {
+      const testKey = TEST_KEY_METRICS;
+      const testValue = 444;
+
+      await createConfigVariable({
+        input: {
+          key: testKey,
+          value: testValue,
+        },
+      });
+
+      const result = await getConfigVariablesGrouped();
+
+      expect(result.data.getConfigVariablesGrouped).toBeDefined();
+      expect(result.data.getConfigVariablesGrouped.groups).toBeInstanceOf(
+        Array,
+      );
+
+      const allVariables = result.data.getConfigVariablesGrouped.groups.flatMap(
+        // @ts-expect-error legacy noImplicitAny
+        (group) => group.variables,
+      );
+      const testVariable = allVariables.find(
+        // @ts-expect-error legacy noImplicitAny
+        (variable) => variable.name === testKey,
+      );
+
+      expect(testVariable).toBeDefined();
+      expect(testVariable.value).toBe(testValue);
+      expect(testVariable.source).toBe('DATABASE');
+
+      await deleteConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should reject modifications to environment-only variables', async () => {
+      const result = await createConfigVariable({
+        input: {
+          key: TEST_KEY_ENV_ONLY,
+          value: 'postgres://test:test@localhost:5432/test',
+        },
+        expectToFail: true,
+      });
+
+      expect(result.errors).toBeDefined();
+      expect(result.errors[0].message).toContain(
+        `Cannot create environment-only variable: ${TEST_KEY_ENV_ONLY}`,
+      );
+    });
+
+    it('should reject operations on non-existent config variables', async () => {
+      const result = await getConfigVariable({
+        input: {
+          key: TEST_KEY_NONEXISTENT,
+        },
+        expectToFail: true,
+      });
+
+      expect(result.errors).toBeDefined();
+      expect(result.errors[0].message).toContain(
+        `Config variable "${TEST_KEY_NONEXISTENT}" does not exist in ConfigVariables`,
+      );
+    });
+
+    it('should reject config operations from non-admin users', async () => {
+      const graphqlQuery = `
+        query GetDatabaseConfigVariable {
+          getDatabaseConfigVariable(key: "${TEST_KEY_DEFAULT}") {
+            key
+            value
+            source
+          }
+        }
+      `;
+
+      const response = await makeUnauthenticatedAPIRequest(graphqlQuery);
+
+      expect(response.body.errors).toBeDefined();
+      expect(response.body.errors[0].message).toContain(
+        'Cannot query field "key" on type "ConfigVariable"',
+      );
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle large numeric config values', async () => {
+      const testKey = TEST_KEY_METRICS;
+      const largeValue = 9999;
+
+      await createConfigVariable({
+        input: {
+          key: testKey,
+          value: largeValue,
+        },
+      });
+
+      const getResult = await getConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+
+      expect(getResult.data.getDatabaseConfigVariable.value).toBe(largeValue);
+
+      await deleteConfigVariable({
+        input: {
+          key: testKey,
+        },
+      });
+    });
+
+    it('should handle empty string config values', async () => {
+      const testKey = TEST_KEY_STRING_VALUE;
+      const emptyValue = '';
+
+      await createConfigVariable({
+        input: {
+          key: testKey,
+          value: emptyValue,
+        },
+      });
+
+      const getResult = await getConfigVariable({
+        input: { key: testKey },
+      });
+
+      expect(getResult.data.getDatabaseConfigVariable.value).toBe(emptyValue);
+
+      await deleteConfigVariable({
+        input: { key: testKey },
+      });
+    });
+
+    it('should preserve types correctly when retrieving config variables', async () => {
+      const booleanKey = TEST_KEY_DEFAULT;
+      const booleanValue = false;
+
+      await createConfigVariable({
+        input: {
+          key: booleanKey,
+          value: booleanValue,
+        },
+      });
+
+      const boolResult = await getConfigVariable({
+        input: { key: booleanKey },
+      });
+
+      const retrievedValue = boolResult.data.getDatabaseConfigVariable.value;
+
+      expect(typeof retrievedValue).toBe('boolean');
+      expect(retrievedValue).toBe(booleanValue);
+
+      await deleteConfigVariable({
+        input: { key: booleanKey },
+      });
+    });
+  });
+});

packages/twenty-server/test/integration/twenty-config/types/perform-twenty-config-query.type.ts

@@ -0,0 +1,4 @@
+export type PerformTwentyConfigQueryParams<T> = {
+  input: T;
+  expectToFail?: boolean;
+};

packages/twenty-server/test/integration/twenty-config/utils/create-config-variable.query-factory.util.ts

@@ -0,0 +1,24 @@
+import { gql } from 'graphql-tag';
+import { type ConfigVariableValue } from 'twenty-shared/types';
+
+export type CreateConfigVariableFactoryInput = {
+  key: string;
+  value: ConfigVariableValue;
+};
+
+export const createConfigVariableQueryFactory = ({
+  key,
+  value,
+}: CreateConfigVariableFactoryInput) => {
+  return {
+    query: gql`
+      mutation CreateDatabaseConfigVariable($key: String!, $value: JSON!) {
+        createDatabaseConfigVariable(key: $key, value: $value)
+      }
+    `,
+    variables: {
+      key,
+      value,
+    },
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/create-config-variable.util.ts

@@ -0,0 +1,33 @@
+import { type PerformTwentyConfigQueryParams } from 'test/integration/twenty-config/types/perform-twenty-config-query.type';
+
+import {
+  type CreateConfigVariableFactoryInput,
+  createConfigVariableQueryFactory,
+} from './create-config-variable.query-factory.util';
+import { makeAdminPanelAPIRequest } from './make-admin-panel-api-request.util';
+
+export const createConfigVariable = async ({
+  input,
+  expectToFail = false,
+}: PerformTwentyConfigQueryParams<CreateConfigVariableFactoryInput>) => {
+  const graphqlOperation = createConfigVariableQueryFactory({
+    key: input.key,
+    value: input.value,
+  });
+
+  const response = await makeAdminPanelAPIRequest(graphqlOperation);
+
+  if (!expectToFail) {
+    expect(response.body.data).toBeDefined();
+    expect(response.body.errors).toBeUndefined();
+    expect(response.body.data.createDatabaseConfigVariable).toBeDefined();
+  } else {
+    // For failure cases, we'll check in the individual tests
+  }
+
+  return {
+    data: response.body.data,
+    errors: response.body.errors,
+    rawResponse: response,
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/delete-config-variable.query-factory.util.ts

@@ -0,0 +1,20 @@
+import { gql } from 'graphql-tag';
+
+export type DeleteConfigVariableFactoryInput = {
+  key: string;
+};
+
+export const deleteConfigVariableQueryFactory = ({
+  key,
+}: DeleteConfigVariableFactoryInput) => {
+  return {
+    query: gql`
+      mutation DeleteDatabaseConfigVariable($key: String!) {
+        deleteDatabaseConfigVariable(key: $key)
+      }
+    `,
+    variables: {
+      key,
+    },
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/delete-config-variable.util.ts

@@ -0,0 +1,28 @@
+import { type PerformTwentyConfigQueryParams } from 'test/integration/twenty-config/types/perform-twenty-config-query.type';
+
+import {
+  type DeleteConfigVariableFactoryInput,
+  deleteConfigVariableQueryFactory,
+} from './delete-config-variable.query-factory.util';
+import { makeAdminPanelAPIRequest } from './make-admin-panel-api-request.util';
+
+export const deleteConfigVariable = async ({
+  input,
+  expectToFail = false,
+}: PerformTwentyConfigQueryParams<DeleteConfigVariableFactoryInput>) => {
+  const graphqlOperation = deleteConfigVariableQueryFactory({
+    key: input.key,
+  });
+
+  const response = await makeAdminPanelAPIRequest(graphqlOperation);
+
+  if (!expectToFail) {
+    expect(response.body.data).toBeDefined();
+    expect(response.body.errors).toBeUndefined();
+    expect(response.body.data.deleteDatabaseConfigVariable).toBeDefined();
+  } else {
+    expect(response.body.errors).toBeDefined();
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/twenty-config/utils/get-config-variable.query-factory.util.ts

@@ -0,0 +1,29 @@
+import { gql } from 'graphql-tag';
+
+export type GetConfigVariableFactoryInput = {
+  key: string;
+};
+
+export const getConfigVariableQueryFactory = ({
+  key,
+}: GetConfigVariableFactoryInput) => {
+  return {
+    query: gql`
+      query GetDatabaseConfigVariable($key: String!) {
+        getDatabaseConfigVariable(key: $key) {
+          name
+          description
+          value
+          isSensitive
+          isEnvOnly
+          type
+          options
+          source
+        }
+      }
+    `,
+    variables: {
+      key,
+    },
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/get-config-variable.util.ts

@@ -0,0 +1,31 @@
+import { type PerformTwentyConfigQueryParams } from 'test/integration/twenty-config/types/perform-twenty-config-query.type';
+
+import {
+  type GetConfigVariableFactoryInput,
+  getConfigVariableQueryFactory,
+} from './get-config-variable.query-factory.util';
+import { makeAdminPanelAPIRequest } from './make-admin-panel-api-request.util';
+
+export const getConfigVariable = async ({
+  input,
+  expectToFail = false,
+}: PerformTwentyConfigQueryParams<GetConfigVariableFactoryInput>) => {
+  const graphqlOperation = getConfigVariableQueryFactory({
+    key: input.key,
+  });
+
+  const response = await makeAdminPanelAPIRequest(graphqlOperation);
+
+  if (!expectToFail) {
+    expect(response.body.data).toBeDefined();
+    expect(response.body.data.getDatabaseConfigVariable).toBeDefined();
+  } else {
+    // For failure cases, we'll check in the individual tests
+  }
+
+  return {
+    data: response.body.data,
+    errors: response.body.errors,
+    rawResponse: response,
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/get-config-variables-grouped.query-factory.util.ts

@@ -0,0 +1,27 @@
+import { gql } from 'graphql-tag';
+
+export const getConfigVariablesGroupedQueryFactory = () => {
+  return {
+    query: gql`
+      query GetConfigVariablesGrouped {
+        getConfigVariablesGrouped {
+          groups {
+            name
+            description
+            isHiddenOnLoad
+            variables {
+              name
+              description
+              value
+              isSensitive
+              isEnvOnly
+              type
+              options
+              source
+            }
+          }
+        }
+      }
+    `,
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/get-config-variables-grouped.util.ts

@@ -0,0 +1,18 @@
+import { getConfigVariablesGroupedQueryFactory } from './get-config-variables-grouped.query-factory.util';
+import { makeAdminPanelAPIRequest } from './make-admin-panel-api-request.util';
+
+export const getConfigVariablesGrouped = async (expectToFail = false) => {
+  const graphqlOperation = getConfigVariablesGroupedQueryFactory();
+
+  const response = await makeAdminPanelAPIRequest(graphqlOperation);
+
+  if (!expectToFail) {
+    expect(response.body.data).toBeDefined();
+    expect(response.body.errors).toBeUndefined();
+    expect(response.body.data.getConfigVariablesGrouped).toBeDefined();
+  } else {
+    expect(response.body.errors).toBeDefined();
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};

packages/twenty-server/test/integration/twenty-config/utils/make-admin-panel-api-request.util.ts

@@ -0,0 +1,24 @@
+import { type ASTNode, print } from 'graphql';
+import request from 'supertest';
+
+/* global APP_PORT, APPLE_JANE_ADMIN_ACCESS_TOKEN */
+
+type GraphqlOperation = {
+  query: ASTNode;
+  variables?: Record<string, unknown>;
+};
+
+export const makeAdminPanelAPIRequest = (
+  graphqlOperation: GraphqlOperation,
+) => {
+  const client = request(`http://localhost:${APP_PORT}`);
+
+  return client
+    .post('/admin-panel')
+    .set('Authorization', `Bearer ${APPLE_JANE_ADMIN_ACCESS_TOKEN}`)
+    .send({
+      query: print(graphqlOperation.query),
+      variables: graphqlOperation.variables || {},
+    })
+    .expect(200);
+};

packages/twenty-server/test/integration/twenty-config/utils/make-unauthenticated-api-request.util.ts

@@ -0,0 +1,12 @@
+import request from 'supertest';
+
+export const makeUnauthenticatedAPIRequest = async (query: string) => {
+  const client = request(`http://localhost:${APP_PORT}`);
+
+  return client
+    .post('/admin-panel')
+    .send({
+      query,
+    })
+    .expect(200);
+};

packages/twenty-server/test/integration/twenty-config/utils/update-config-variable.query-factory.util.ts

@@ -0,0 +1,24 @@
+import { gql } from 'graphql-tag';
+import { type ConfigVariableValue } from 'twenty-shared/types';
+
+export type UpdateConfigVariableFactoryInput = {
+  key: string;
+  value: ConfigVariableValue;
+};
+
+export const updateConfigVariableQueryFactory = ({
+  key,
+  value,
+}: UpdateConfigVariableFactoryInput) => {
+  return {
+    query: gql`
+      mutation UpdateDatabaseConfigVariable($key: String!, $value: JSON!) {
+        updateDatabaseConfigVariable(key: $key, value: $value)
+      }
+    `,
+    variables: {
+      key,
+      value,
+    },
+  };
+};

packages/twenty-server/test/integration/twenty-config/utils/update-config-variable.util.ts

@@ -0,0 +1,29 @@
+import { type PerformTwentyConfigQueryParams } from 'test/integration/twenty-config/types/perform-twenty-config-query.type';
+
+import { makeAdminPanelAPIRequest } from './make-admin-panel-api-request.util';
+import {
+  type UpdateConfigVariableFactoryInput,
+  updateConfigVariableQueryFactory,
+} from './update-config-variable.query-factory.util';
+
+export const updateConfigVariable = async ({
+  input,
+  expectToFail = false,
+}: PerformTwentyConfigQueryParams<UpdateConfigVariableFactoryInput>) => {
+  const graphqlOperation = updateConfigVariableQueryFactory({
+    key: input.key,
+    value: input.value,
+  });
+
+  const response = await makeAdminPanelAPIRequest(graphqlOperation);
+
+  if (!expectToFail) {
+    expect(response.body.data).toBeDefined();
+    expect(response.body.errors).toBeUndefined();
+    expect(response.body.data.updateDatabaseConfigVariable).toBeDefined();
+  } else {
+    expect(response.body.errors).toBeDefined();
+  }
+
+  return { data: response.body.data, errors: response.body.errors };
+};