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

packages/twenty-server/test/integration/metadata/suites/field-metadata/searchable-field/__snapshots__/create-one-searchable-field-metadata.integration-spec.ts.snap

@@ -0,0 +1,187 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Field metadata creation with isSearchable on a non-searchable object should reject creating a searchable field on a non-searchable object 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "fieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "FIELD_MUTATION_NOT_ALLOWED",
+              "message": "Object is not searchable",
+              "userFriendlyMessage": "Enable search on this object before adding searchable fields",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "searchableFieldOnNonSearchableObject",
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "fieldMetadata",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+      "searchFieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "FIELD_METADATA_NOT_FOUND",
+              "message": "Field metadata not found",
+              "userFriendlyMessage": "Field metadata not found",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "searchFieldMetadata",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+      "viewField": [
+        {
+          "errors": [
+            {
+              "code": "INVALID_VIEW_DATA",
+              "message": "Field metadata not found",
+              "userFriendlyMessage": "Field metadata not found",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "fieldMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+            "viewUniversalIdentifier": Any<String>,
+          },
+          "metadataName": "viewField",
+          "status": "fail",
+          "type": "create",
+        },
+        {
+          "errors": [
+            {
+              "code": "INVALID_VIEW_DATA",
+              "message": "Field metadata not found",
+              "userFriendlyMessage": "Field metadata not found",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "fieldMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+            "viewUniversalIdentifier": Any<String>,
+          },
+          "metadataName": "viewField",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 fieldMetadata, 2 viewFields, 1 searchFieldMetadata",
+    "summary": {
+      "fieldMetadata": 1,
+      "searchFieldMetadata": 1,
+      "totalErrors": 4,
+      "viewField": 2,
+    },
+    "userFriendlyMessage": "Many validation errors",
+  },
+  "message": "Multiple validation errors occurred while creating fields",
+  "name": "GraphQLError",
+}
+`;
+
+exports[`Field metadata creation with isSearchable should reject creating a searchable field of a non-searchable type 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "fieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "INVALID_FIELD_INPUT",
+              "message": "Field type NUMBER is not supported for search",
+              "userFriendlyMessage": "This field type cannot be searched",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "searchableNumberField",
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "fieldMetadata",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+      "searchFieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "FIELD_METADATA_NOT_FOUND",
+              "message": "Field metadata not found",
+              "userFriendlyMessage": "Field metadata not found",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "searchFieldMetadata",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+      "viewField": [
+        {
+          "errors": [
+            {
+              "code": "INVALID_VIEW_DATA",
+              "message": "Field metadata not found",
+              "userFriendlyMessage": "Field metadata not found",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "fieldMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+            "viewUniversalIdentifier": Any<String>,
+          },
+          "metadataName": "viewField",
+          "status": "fail",
+          "type": "create",
+        },
+        {
+          "errors": [
+            {
+              "code": "INVALID_VIEW_DATA",
+              "message": "Field metadata not found",
+              "userFriendlyMessage": "Field metadata not found",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "fieldMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+            "viewUniversalIdentifier": Any<String>,
+          },
+          "metadataName": "viewField",
+          "status": "fail",
+          "type": "create",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 fieldMetadata, 2 viewFields, 1 searchFieldMetadata",
+    "summary": {
+      "fieldMetadata": 1,
+      "searchFieldMetadata": 1,
+      "totalErrors": 4,
+      "viewField": 2,
+    },
+    "userFriendlyMessage": "Many validation errors",
+  },
+  "message": "Multiple validation errors occurred while creating fields",
+  "name": "GraphQLError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/field-metadata/searchable-field/__snapshots__/update-one-searchable-field-metadata.integration-spec.ts.snap

@@ -0,0 +1,112 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Field metadata isSearchable toggling should reject an explicit isSearchable null on the label identifier 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "fieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "FIELD_MUTATION_NOT_ALLOWED",
+              "message": "Label identifier field cannot be removed from search",
+              "userFriendlyMessage": "Label identifier field cannot be removed from search",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "name",
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "fieldMetadata",
+          "status": "fail",
+          "type": "update",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 fieldMetadata",
+    "summary": {
+      "fieldMetadata": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "Label identifier field cannot be removed from search",
+  },
+  "message": "Multiple validation errors occurred while updating field",
+  "name": "GraphQLError",
+}
+`;
+
+exports[`Field metadata isSearchable toggling should reject removing the label identifier from search 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "fieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "FIELD_MUTATION_NOT_ALLOWED",
+              "message": "Label identifier field cannot be removed from search",
+              "userFriendlyMessage": "Label identifier field cannot be removed from search",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "name",
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "fieldMetadata",
+          "status": "fail",
+          "type": "update",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 fieldMetadata",
+    "summary": {
+      "fieldMetadata": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "Label identifier field cannot be removed from search",
+  },
+  "message": "Multiple validation errors occurred while updating field",
+  "name": "GraphQLError",
+}
+`;
+
+exports[`Field metadata isSearchable toggling should reject turning on isSearchable for a non-searchable type 1`] = `
+{
+  "extensions": {
+    "code": "METADATA_VALIDATION_FAILED",
+    "errors": {
+      "fieldMetadata": [
+        {
+          "errors": [
+            {
+              "code": "INVALID_FIELD_INPUT",
+              "message": "Field type NUMBER is not supported for search",
+              "userFriendlyMessage": "This field type cannot be searched",
+            },
+          ],
+          "flatEntityMinimalInformation": {
+            "name": "toggledNumberField",
+            "objectMetadataUniversalIdentifier": Any<String>,
+            "universalIdentifier": Any<String>,
+          },
+          "metadataName": "fieldMetadata",
+          "status": "fail",
+          "type": "update",
+        },
+      ],
+    },
+    "message": "Validation failed for 1 fieldMetadata",
+    "summary": {
+      "fieldMetadata": 1,
+      "totalErrors": 1,
+    },
+    "userFriendlyMessage": "This field type cannot be searched",
+  },
+  "message": "Multiple validation errors occurred while updating field",
+  "name": "GraphQLError",
+}
+`;

packages/twenty-server/test/integration/metadata/suites/field-metadata/searchable-field/create-one-searchable-field-metadata.integration-spec.ts

@@ -0,0 +1,207 @@
+import { createManyOperation } from 'test/integration/graphql/utils/create-many-operation.util';
+import { search } from 'test/integration/graphql/utils/search.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { findManyFieldsMetadata } from 'test/integration/metadata/suites/field-metadata/utils/find-many-fields-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { findOneObjectMetadataWithSearchFieldMetadataList } from 'test/integration/metadata/suites/object-metadata/utils/find-one-object-metadata-with-search-field-metadata-list.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+describe('Field metadata creation with isSearchable', () => {
+  const OBJECT_NAME_SINGULAR = 'searchableCreateObject';
+  const OBJECT_NAME_PLURAL = 'searchableCreateObjects';
+  const SEARCHABLE_FIELD_NAME = 'searchableOnCreateField';
+  const RECORD_SEARCHABLE_VALUE = 'SearchableOnCreateToken11';
+
+  let testObjectMetadataId: string;
+
+  beforeAll(async () => {
+    const {
+      data: {
+        createOneObject: { id: objectMetadataId },
+      },
+    } = await createOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        nameSingular: OBJECT_NAME_SINGULAR,
+        namePlural: OBJECT_NAME_PLURAL,
+        labelSingular: 'Searchable Create Object',
+        labelPlural: 'Searchable Create Objects',
+        icon: 'IconSearch',
+        isLabelSyncedWithName: false,
+      },
+    });
+
+    testObjectMetadataId = objectMetadataId;
+  });
+
+  afterAll(async () => {
+    await updateOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: testObjectMetadataId,
+        updatePayload: { isActive: false },
+      },
+    });
+    await deleteOneObjectMetadata({
+      expectToFail: false,
+      input: { idToDelete: testObjectMetadataId },
+    });
+  });
+
+  it('should create a searchable field whose values reach global search', async () => {
+    const { searchFieldMetadataList: rowsBeforeCreate } =
+      await findOneObjectMetadataWithSearchFieldMetadataList({
+        objectMetadataId: testObjectMetadataId,
+      });
+
+    const maxPositionBeforeCreate = Math.max(
+      ...rowsBeforeCreate.map(
+        (searchFieldMetadata) => searchFieldMetadata.position,
+      ),
+    );
+
+    const {
+      data: { createOneField },
+    } = await createOneFieldMetadata({
+      expectToFail: false,
+      input: {
+        name: SEARCHABLE_FIELD_NAME,
+        label: 'Searchable On Create Field',
+        type: FieldMetadataType.TEXT,
+        objectMetadataId: testObjectMetadataId,
+        isLabelSyncedWithName: false,
+        isSearchable: true,
+      },
+      gqlFields: `id name isSearchable`,
+    });
+
+    expect(createOneField.isSearchable).toBe(true);
+
+    const { searchFieldMetadataList } =
+      await findOneObjectMetadataWithSearchFieldMetadataList({
+        objectMetadataId: testObjectMetadataId,
+      });
+
+    const createdRow = searchFieldMetadataList.find(
+      (searchFieldMetadata) =>
+        searchFieldMetadata.fieldMetadataId === createOneField.id,
+    );
+
+    expect(createdRow).toBeDefined();
+    expect(createdRow?.position).toBe(maxPositionBeforeCreate + 1);
+
+    const { fields } = await findManyFieldsMetadata({
+      expectToFail: false,
+      input: {
+        filter: { id: { eq: createOneField.id } },
+        paging: { first: 1 },
+      },
+      gqlFields: `id isSearchable`,
+    });
+
+    expect(fields[0].node.isSearchable).toBe(true);
+
+    await createManyOperation({
+      objectMetadataSingularName: OBJECT_NAME_SINGULAR,
+      objectMetadataPluralName: OBJECT_NAME_PLURAL,
+      gqlFields: `id name ${SEARCHABLE_FIELD_NAME}`,
+      data: [
+        {
+          name: 'searchable create record',
+          [SEARCHABLE_FIELD_NAME]: RECORD_SEARCHABLE_VALUE,
+        },
+      ],
+      expectToFail: false,
+    });
+
+    const searchBySearchableField = await search({
+      searchInput: RECORD_SEARCHABLE_VALUE,
+      includedObjectNameSingulars: [OBJECT_NAME_SINGULAR],
+      limit: 10,
+      expectToFail: false,
+    });
+
+    expect(searchBySearchableField.data.search.edges.length).toBe(1);
+  });
+
+  it('should reject creating a searchable field of a non-searchable type', async () => {
+    const { errors } = await createOneFieldMetadata({
+      expectToFail: true,
+      input: {
+        name: 'searchableNumberField',
+        label: 'Searchable Number Field',
+        type: FieldMetadataType.NUMBER,
+        objectMetadataId: testObjectMetadataId,
+        isLabelSyncedWithName: false,
+        isSearchable: true,
+      },
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+});
+
+describe('Field metadata creation with isSearchable on a non-searchable object', () => {
+  let nonSearchableObjectMetadataId: string;
+
+  beforeAll(async () => {
+    const {
+      data: {
+        createOneObject: { id: objectMetadataId },
+      },
+    } = await createOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        nameSingular: 'nonSearchableCreateObject',
+        namePlural: 'nonSearchableCreateObjects',
+        labelSingular: 'Non Searchable Create Object',
+        labelPlural: 'Non Searchable Create Objects',
+        icon: 'IconSearchOff',
+        isLabelSyncedWithName: false,
+      },
+    });
+
+    nonSearchableObjectMetadataId = objectMetadataId;
+
+    await updateOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: nonSearchableObjectMetadataId,
+        updatePayload: { isSearchable: false },
+      },
+    });
+  });
+
+  afterAll(async () => {
+    await updateOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: nonSearchableObjectMetadataId,
+        updatePayload: { isActive: false },
+      },
+    });
+    await deleteOneObjectMetadata({
+      expectToFail: false,
+      input: { idToDelete: nonSearchableObjectMetadataId },
+    });
+  });
+
+  it('should reject creating a searchable field on a non-searchable object', async () => {
+    const { errors } = await createOneFieldMetadata({
+      expectToFail: true,
+      input: {
+        name: 'searchableFieldOnNonSearchableObject',
+        label: 'Searchable Field On Non Searchable Object',
+        type: FieldMetadataType.TEXT,
+        objectMetadataId: nonSearchableObjectMetadataId,
+        isLabelSyncedWithName: false,
+        isSearchable: true,
+      },
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+});

packages/twenty-server/test/integration/metadata/suites/field-metadata/searchable-field/update-one-searchable-field-metadata.integration-spec.ts

@@ -0,0 +1,275 @@
+import { createManyOperation } from 'test/integration/graphql/utils/create-many-operation.util';
+import { search } from 'test/integration/graphql/utils/search.util';
+import { createOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/create-one-field-metadata.util';
+import { updateOneFieldMetadata } from 'test/integration/metadata/suites/field-metadata/utils/update-one-field-metadata.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { findOneObjectMetadataWithSearchFieldMetadataList } from 'test/integration/metadata/suites/object-metadata/utils/find-one-object-metadata-with-search-field-metadata-list.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { type UpdateFieldInput } from 'src/engine/metadata-modules/field-metadata/dtos/update-field.input';
+
+describe('Field metadata isSearchable toggling', () => {
+  const OBJECT_NAME_SINGULAR = 'searchableToggleObject';
+  const OBJECT_NAME_PLURAL = 'searchableToggleObjects';
+  const TOGGLED_FIELD_NAME = 'toggledSearchableField';
+  const RECORD_TOGGLED_VALUE = 'SearchableToggleToken11';
+
+  let testObjectMetadataId: string;
+  let toggledFieldMetadataId: string;
+  let labelIdentifierFieldMetadataId: string;
+  let numberFieldMetadataId: string;
+
+  const findSearchFieldMetadataList = async (): Promise<
+    { id: string; fieldMetadataId: string; position: number }[]
+  > => {
+    const objectMetadata =
+      await findOneObjectMetadataWithSearchFieldMetadataList({
+        objectMetadataId: testObjectMetadataId,
+      });
+
+    labelIdentifierFieldMetadataId =
+      objectMetadata.labelIdentifierFieldMetadataId ?? '';
+
+    return objectMetadata.searchFieldMetadataList;
+  };
+
+  beforeAll(async () => {
+    const {
+      data: {
+        createOneObject: { id: objectMetadataId },
+      },
+    } = await createOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        nameSingular: OBJECT_NAME_SINGULAR,
+        namePlural: OBJECT_NAME_PLURAL,
+        labelSingular: 'Searchable Toggle Object',
+        labelPlural: 'Searchable Toggle Objects',
+        icon: 'IconSearch',
+        isLabelSyncedWithName: false,
+      },
+    });
+
+    testObjectMetadataId = objectMetadataId;
+
+    const {
+      data: {
+        createOneField: { id: toggledFieldId },
+      },
+    } = await createOneFieldMetadata({
+      expectToFail: false,
+      input: {
+        name: TOGGLED_FIELD_NAME,
+        label: 'Toggled Searchable Field',
+        type: FieldMetadataType.TEXT,
+        objectMetadataId: testObjectMetadataId,
+        isLabelSyncedWithName: false,
+      },
+      gqlFields: `id`,
+    });
+
+    toggledFieldMetadataId = toggledFieldId;
+
+    const {
+      data: {
+        createOneField: { id: numberFieldId },
+      },
+    } = await createOneFieldMetadata({
+      expectToFail: false,
+      input: {
+        name: 'toggledNumberField',
+        label: 'Toggled Number Field',
+        type: FieldMetadataType.NUMBER,
+        objectMetadataId: testObjectMetadataId,
+        isLabelSyncedWithName: false,
+      },
+      gqlFields: `id`,
+    });
+
+    numberFieldMetadataId = numberFieldId;
+
+    await createManyOperation({
+      objectMetadataSingularName: OBJECT_NAME_SINGULAR,
+      objectMetadataPluralName: OBJECT_NAME_PLURAL,
+      gqlFields: `id name ${TOGGLED_FIELD_NAME}`,
+      data: [
+        {
+          name: 'searchable toggle record',
+          [TOGGLED_FIELD_NAME]: RECORD_TOGGLED_VALUE,
+        },
+      ],
+      expectToFail: false,
+    });
+  });
+
+  afterAll(async () => {
+    await updateOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: testObjectMetadataId,
+        updatePayload: { isActive: false },
+      },
+    });
+    await deleteOneObjectMetadata({
+      expectToFail: false,
+      input: { idToDelete: testObjectMetadataId },
+    });
+  });
+
+  it('should add the field to global search when isSearchable is turned on', async () => {
+    const searchBeforeToggle = await search({
+      searchInput: RECORD_TOGGLED_VALUE,
+      includedObjectNameSingulars: [OBJECT_NAME_SINGULAR],
+      limit: 10,
+      expectToFail: false,
+    });
+
+    expect(searchBeforeToggle.data.search.edges.length).toBe(0);
+
+    const rowsBeforeToggle = await findSearchFieldMetadataList();
+    const maxPositionBeforeToggle = Math.max(
+      ...rowsBeforeToggle.map(
+        (searchFieldMetadata) => searchFieldMetadata.position,
+      ),
+    );
+
+    const {
+      data: { updateOneField },
+    } = await updateOneFieldMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: toggledFieldMetadataId,
+        updatePayload: { isSearchable: true },
+      },
+      gqlFields: `id isSearchable`,
+    });
+
+    expect(updateOneField.isSearchable).toBe(true);
+
+    const searchFieldMetadataList = await findSearchFieldMetadataList();
+    const createdRow = searchFieldMetadataList.find(
+      (searchFieldMetadata) =>
+        searchFieldMetadata.fieldMetadataId === toggledFieldMetadataId,
+    );
+
+    expect(createdRow).toBeDefined();
+    expect(createdRow?.position).toBe(maxPositionBeforeToggle + 1);
+
+    const searchAfterToggle = await search({
+      searchInput: RECORD_TOGGLED_VALUE,
+      includedObjectNameSingulars: [OBJECT_NAME_SINGULAR],
+      limit: 10,
+      expectToFail: false,
+    });
+
+    expect(searchAfterToggle.data.search.edges.length).toBe(1);
+  });
+
+  it('should keep the row untouched when isSearchable stays true', async () => {
+    const rowsBeforeNoop = await findSearchFieldMetadataList();
+    const rowBeforeNoop = rowsBeforeNoop.find(
+      (searchFieldMetadata) =>
+        searchFieldMetadata.fieldMetadataId === toggledFieldMetadataId,
+    );
+
+    await updateOneFieldMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: toggledFieldMetadataId,
+        updatePayload: { isSearchable: true },
+      },
+      gqlFields: `id isSearchable`,
+    });
+
+    const rowsAfterNoop = await findSearchFieldMetadataList();
+    const rowAfterNoop = rowsAfterNoop.find(
+      (searchFieldMetadata) =>
+        searchFieldMetadata.fieldMetadataId === toggledFieldMetadataId,
+    );
+
+    expect(rowAfterNoop).toEqual(rowBeforeNoop);
+  });
+
+  it('should remove the field from global search when isSearchable is turned off', async () => {
+    const {
+      data: { updateOneField },
+    } = await updateOneFieldMetadata({
+      expectToFail: false,
+      input: {
+        idToUpdate: toggledFieldMetadataId,
+        updatePayload: { isSearchable: false },
+      },
+      gqlFields: `id isSearchable`,
+    });
+
+    expect(updateOneField.isSearchable).toBe(false);
+
+    const searchFieldMetadataList = await findSearchFieldMetadataList();
+
+    expect(
+      searchFieldMetadataList.some(
+        (searchFieldMetadata) =>
+          searchFieldMetadata.fieldMetadataId === toggledFieldMetadataId,
+      ),
+    ).toBe(false);
+
+    const searchAfterToggleOff = await search({
+      searchInput: RECORD_TOGGLED_VALUE,
+      includedObjectNameSingulars: [OBJECT_NAME_SINGULAR],
+      limit: 10,
+      expectToFail: false,
+    });
+
+    expect(searchAfterToggleOff.data.search.edges.length).toBe(0);
+  });
+
+  it('should reject removing the label identifier from search', async () => {
+    await findSearchFieldMetadataList();
+
+    const { errors } = await updateOneFieldMetadata({
+      expectToFail: true,
+      input: {
+        idToUpdate: labelIdentifierFieldMetadataId,
+        updatePayload: { isSearchable: false },
+      },
+      gqlFields: `id`,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+
+  it('should reject an explicit isSearchable null on the label identifier', async () => {
+    await findSearchFieldMetadataList();
+
+    const nullIsSearchablePayload = {
+      isSearchable: null,
+    } as unknown as Omit<UpdateFieldInput, 'workspaceId' | 'id'>;
+
+    const { errors } = await updateOneFieldMetadata({
+      expectToFail: true,
+      input: {
+        idToUpdate: labelIdentifierFieldMetadataId,
+        updatePayload: nullIsSearchablePayload,
+      },
+      gqlFields: `id`,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+
+  it('should reject turning on isSearchable for a non-searchable type', async () => {
+    const { errors } = await updateOneFieldMetadata({
+      expectToFail: true,
+      input: {
+        idToUpdate: numberFieldMetadataId,
+        updatePayload: { isSearchable: true },
+      },
+      gqlFields: `id`,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({ errors });
+  });
+});