[Apps] Fix - app-synced object should be searchable (#19206)

## Summary - **Make app-synced objects searchable**: `isSearchable` was hardcoded to `false` and the `searchVector` field was missing the `GENERATED ALWAYS AS (...)` expression, causing all records to have a `NULL` search vector and be excluded from search results. Fixed by defaulting `isSearchable` to `true` (configurable via the object manifest), computing the `asExpression` from the label identifier field, and allowing the update-field-action-handler to handle the `null` → defined `asExpression` transition. - **Make `isSearchable` updatable on an object**: The property had `toCompare: false` in the entity properties configuration, so updates via the API were silently ignored and never persisted. Fixed by setting `toCompare: true`.
2026-04-02 19:14:37 +02:00
parent 43baf7b91c
commit 2d6c8be7df
34 changed files with 639 additions and 51 deletions
@@ -29,7 +29,7 @@ export const fromObjectManifestToUniversalFlatObjectMetadata = ({
    isSystem: false,
    isUIReadOnly: false,
    isAuditLogged: true,
-    isSearchable: false,
+    isSearchable: objectManifest.isSearchable ?? true,
    duplicateCriteria: null,
    shortcut: null,
    isLabelSyncedWithName: false,
@@ -0,0 +1,149 @@
+import { type ObjectManifest } from 'twenty-shared/application';
+import { FieldMetadataType } from 'twenty-shared/types';
+
+import { computeSearchVectorUniversalSettingsFromObjectManifest } from 'src/engine/core-modules/application/application-manifest/utils/compute-search-vector-universal-settings-from-object-manifest.util';
+
+const buildObjectManifest = (
+  overrides: Partial<ObjectManifest> & {
+    fields: ObjectManifest['fields'];
+    labelIdentifierFieldMetadataUniversalIdentifier: string;
+  },
+): ObjectManifest => ({
+  universalIdentifier: 'obj-uuid-1',
+  nameSingular: 'testObject',
+  namePlural: 'testObjects',
+  labelSingular: 'Test Object',
+  labelPlural: 'Test Objects',
+  ...overrides,
+});
+
+describe('computeSearchVectorUniversalSettingsFromObjectManifest', () => {
+  it('should return asExpression and generatedType for a TEXT label identifier field', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier: 'field-uuid-name',
+        fields: [
+          {
+            universalIdentifier: 'field-uuid-name',
+            name: 'name',
+            label: 'Name',
+            type: FieldMetadataType.TEXT,
+          },
+        ],
+      }),
+    });
+
+    expect(result?.generatedType).toBe('STORED');
+    expect(result?.asExpression).toContain("to_tsvector('simple'");
+    expect(result?.asExpression).toContain('"name"');
+  });
+
+  it('should return asExpression for a FULL_NAME label identifier field', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier: 'field-uuid-name',
+        fields: [
+          {
+            universalIdentifier: 'field-uuid-name',
+            name: 'name',
+            label: 'Name',
+            type: FieldMetadataType.FULL_NAME,
+          },
+        ],
+      }),
+    });
+
+    expect(result?.generatedType).toBe('STORED');
+    expect(result?.asExpression).toContain("to_tsvector('simple'");
+    expect(result?.asExpression).toContain('"nameFirstName"');
+    expect(result?.asExpression).toContain('"nameLastName"');
+  });
+
+  it('should return asExpression for an EMAILS label identifier field', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier: 'field-uuid-email',
+        fields: [
+          {
+            universalIdentifier: 'field-uuid-email',
+            name: 'email',
+            label: 'Email',
+            type: FieldMetadataType.EMAILS,
+          },
+        ],
+      }),
+    });
+
+    expect(result?.generatedType).toBe('STORED');
+    expect(result?.asExpression).toContain("to_tsvector('simple'");
+    expect(result?.asExpression).toContain('"emailPrimaryEmail"');
+  });
+
+  it('should return asExpression for a UUID label identifier field', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier: 'field-uuid-id',
+        fields: [
+          {
+            universalIdentifier: 'field-uuid-id',
+            name: 'externalId',
+            label: 'External ID',
+            type: FieldMetadataType.UUID,
+          },
+        ],
+      }),
+    });
+
+    expect(result?.generatedType).toBe('STORED');
+    expect(result?.asExpression).toContain("to_tsvector('simple'");
+    expect(result?.asExpression).toContain('"externalId"');
+  });
+
+  it('should return null when label identifier field is not found in fields', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier:
+          'non-existent-field-uuid',
+        fields: [
+          {
+            universalIdentifier: 'field-uuid-name',
+            name: 'name',
+            label: 'Name',
+            type: FieldMetadataType.TEXT,
+          },
+        ],
+      }),
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it('should return null when label identifier field has a non-searchable type', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier: 'field-uuid-number',
+        fields: [
+          {
+            universalIdentifier: 'field-uuid-number',
+            name: 'amount',
+            label: 'Amount',
+            type: FieldMetadataType.NUMBER,
+          },
+        ],
+      }),
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it('should return null when fields array is empty', () => {
+    const result = computeSearchVectorUniversalSettingsFromObjectManifest({
+      objectManifest: buildObjectManifest({
+        labelIdentifierFieldMetadataUniversalIdentifier: 'field-uuid-name',
+        fields: [],
+      }),
+    });
+
+    expect(result).toBeNull();
+  });
+});
@@ -1,4 +1,6 @@
 import { type Manifest } from 'twenty-shared/application';
+import { FieldMetadataType } from 'twenty-shared/types';
+import { isDefined } from 'twenty-shared/utils';

 import { fromCommandMenuItemManifestToUniversalFlatCommandMenuItem } from 'src/engine/core-modules/application/application-manifest/converters/from-command-menu-item-manifest-to-universal-flat-command-menu-item.util';
 import { fromFieldManifestToUniversalFlatFieldMetadata } from 'src/engine/core-modules/application/application-manifest/converters/from-field-manifest-to-universal-flat-field-metadata.util';
@@ -11,6 +13,7 @@ import { fromPageLayoutTabManifestToUniversalFlatPageLayoutTab } from 'src/engin
 import { fromPageLayoutWidgetManifestToUniversalFlatPageLayoutWidget } from 'src/engine/core-modules/application/application-manifest/converters/from-page-layout-widget-manifest-to-universal-flat-page-layout-widget.util';
 import { fromRoleManifestToUniversalFlatRole } from 'src/engine/core-modules/application/application-manifest/converters/from-role-manifest-to-universal-flat-role.util';
 import { fromSkillManifestToUniversalFlatSkill } from 'src/engine/core-modules/application/application-manifest/converters/from-skill-manifest-to-universal-flat-skill.util';
+import { computeSearchVectorUniversalSettingsFromObjectManifest } from 'src/engine/core-modules/application/application-manifest/utils/compute-search-vector-universal-settings-from-object-manifest.util';
 import { fromViewFieldGroupManifestToUniversalFlatViewFieldGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-group-manifest-to-universal-flat-view-field-group.util';
 import { fromViewFieldManifestToUniversalFlatViewField } from 'src/engine/core-modules/application/application-manifest/converters/from-view-field-manifest-to-universal-flat-view-field.util';
 import { fromViewFilterGroupManifestToUniversalFlatViewFilterGroup } from 'src/engine/core-modules/application/application-manifest/converters/from-view-filter-group-manifest-to-universal-flat-view-filter-group.util';
@@ -49,12 +52,25 @@ export const computeApplicationManifestAllUniversalFlatEntityMaps = ({
    });

    for (const fieldManifest of objectManifest.fields) {
+      const enrichedFieldManifest =
+        fieldManifest.type === FieldMetadataType.TS_VECTOR &&
+        !isDefined(fieldManifest.universalSettings)
+          ? {
+              ...fieldManifest,
+              objectUniversalIdentifier: objectManifest.universalIdentifier,
+              universalSettings:
+                computeSearchVectorUniversalSettingsFromObjectManifest({
+                  objectManifest,
+                }),
+            }
+          : {
+              ...fieldManifest,
+              objectUniversalIdentifier: objectManifest.universalIdentifier,
+            };
+
      addUniversalFlatEntityToUniversalFlatEntityMapsThroughMutationOrThrow({
        universalFlatEntity: fromFieldManifestToUniversalFlatFieldMetadata({
-          fieldManifest: {
-            ...fieldManifest,
-            objectUniversalIdentifier: objectManifest.universalIdentifier,
-          },
+          fieldManifest: enrichedFieldManifest,
          applicationUniversalIdentifier,
          now,
        }),
@@ -0,0 +1,37 @@
+import { type ObjectManifest } from 'twenty-shared/application';
+import {
+  type FieldMetadataUniversalSettings,
+  FieldMetadataType,
+} from 'twenty-shared/types';
+
+import { getTsVectorColumnExpressionFromFields } from 'src/engine/workspace-manager/utils/get-ts-vector-column-expression.util';
+import { isDefined, isSearchableFieldType } from 'twenty-shared/utils';
+
+export const computeSearchVectorUniversalSettingsFromObjectManifest = ({
+  objectManifest,
+}: {
+  objectManifest: ObjectManifest;
+}): FieldMetadataUniversalSettings<FieldMetadataType.TS_VECTOR> => {
+  const labelIdentifierField = objectManifest.fields.find(
+    (field) =>
+      field.universalIdentifier ===
+      objectManifest.labelIdentifierFieldMetadataUniversalIdentifier,
+  );
+
+  if (
+    !isDefined(labelIdentifierField) ||
+    !isSearchableFieldType(labelIdentifierField.type)
+  ) {
+    return null;
+  }
+
+  return {
+    asExpression: getTsVectorColumnExpressionFromFields([
+      {
+        name: labelIdentifierField.name,
+        type: labelIdentifierField.type,
+      },
+    ]),
+    generatedType: 'STORED',
+  };
+};