fix: include dbFieldType for improved JSON handling and add tests for multi-value lookups

Author: nichenqin

apps/nestjs-backend/src/features/record/query-builder/field-select-visitor.ts

@@ -174,7 +174,8 @@ export class FieldSelectVisitor implements IFieldVisitor<IFieldSelectName> {
           const flattenedExpr = this.dialect.flattenLookupCteValue(
             cteName,
             field.id,
-            !!field.isMultipleCellValue
+            !!field.isMultipleCellValue,
+            field.dbFieldType
           );
           if (flattenedExpr) {
             this.state.setSelection(field.id, flattenedExpr);

apps/nestjs-backend/src/features/record/query-builder/providers/pg-record-query-dialect.spec.ts

@@ -0,0 +1,29 @@
+import { DbFieldType } from '@teable/core';
+import type { Knex } from 'knex';
+import { describe, expect, it } from 'vitest';
+import { PgRecordQueryDialect } from './pg-record-query-dialect';
+
+describe('PgRecordQueryDialect#flattenLookupCteValue', () => {
+  const dialect = new PgRecordQueryDialect({} as unknown as Knex);
+
+  it('returns null for single-value lookups', () => {
+    const result = dialect.flattenLookupCteValue(
+      'cte_lookup',
+      'fld_single',
+      false,
+      DbFieldType.Text
+    );
+    expect(result).toBeNull();
+  });
+
+  it('keeps jsonb payloads when field is stored as json', () => {
+    const sql = dialect.flattenLookupCteValue('cte_lookup', 'fld_json', true, DbFieldType.Json);
+    expect(sql).toContain('"cte_lookup"."lookup_fld_json"::jsonb');
+    expect(sql).not.toContain('to_jsonb("cte_lookup"."lookup_fld_json")');
+  });
+
+  it('wraps scalar payloads with to_jsonb for non-json fields', () => {
+    const sql = dialect.flattenLookupCteValue('cte_lookup', 'fld_scalar', true, DbFieldType.Text);
+    expect(sql).toContain('to_jsonb("cte_lookup"."lookup_fld_scalar")');
+  });
+});

apps/nestjs-backend/src/features/record/query-builder/providers/pg-record-query-dialect.ts

@@ -99,11 +99,19 @@ export class PgRecordQueryDialect implements IRecordQueryDialectProvider {
       )`;
   }
 
-  flattenLookupCteValue(cteName: string, fieldId: string, isMultiple: boolean): string | null {
+  flattenLookupCteValue(
+    cteName: string,
+    fieldId: string,
+    isMultiple: boolean,
+    dbFieldType: DbFieldType
+  ): string | null {
     if (!isMultiple) return null;
+    const columnRef = `"${cteName}"."lookup_${fieldId}"`;
+    const normalized =
+      dbFieldType === DbFieldType.Json ? `${columnRef}::jsonb` : `to_jsonb(${columnRef})`;
     return `(
             WITH RECURSIVE f(e) AS (
-              SELECT "${cteName}"."lookup_${fieldId}"::jsonb
+              SELECT ${normalized}
               UNION ALL
               SELECT jsonb_array_elements(f.e)
               FROM f

apps/nestjs-backend/src/features/record/query-builder/providers/sqlite-record-query-dialect.ts

@@ -100,7 +100,12 @@ export class SqliteRecordQueryDialect implements IRecordQueryDialectProvider {
       )`;
   }
 
-  flattenLookupCteValue(_cteName: string, _fieldId: string, _isMultiple: boolean): string | null {
+  flattenLookupCteValue(
+    _cteName: string,
+    _fieldId: string,
+    _isMultiple: boolean,
+    _dbFieldType: DbFieldType
+  ): string | null {
     return null;
   }
 

apps/nestjs-backend/src/features/record/query-builder/record-query-dialect.interface.ts

@@ -175,10 +175,15 @@ export interface IRecordQueryDialectProvider {
    * Return null when no special handling is required.
    * @example
    * ```ts
-   * dialect.flattenLookupCteValue('CTE_main_link', 'fld_123', true) // => WITH RECURSIVE ... jsonb_array_elements ...
+   * dialect.flattenLookupCteValue('CTE_main_link', 'fld_123', true, DbFieldType.Json) // => WITH RECURSIVE ... jsonb_array_elements ...
    * ```
    */
-  flattenLookupCteValue(cteName: string, fieldId: string, isMultiple: boolean): string | null;
+  flattenLookupCteValue(
+    cteName: string,
+    fieldId: string,
+    isMultiple: boolean,
+    dbFieldType: DbFieldType
+  ): string | null;
 
   // JSON aggregation helpers
 

apps/nestjs-backend/test/formula.e2e-spec.ts

@@ -986,6 +986,76 @@ describe('OpenAPI formula (e2e)', () => {
       }
     });
 
+    it('should flatten multi-value lookup formulas returning scalar text', async () => {
+      const foreign = await createTable(baseId, {
+        name: 'formula-lookup-flatten-foreign',
+        fields: [
+          { name: 'Title', type: FieldType.SingleLineText } as IFieldRo,
+          { name: 'Scheduled', type: FieldType.Date } as IFieldRo,
+        ],
+        records: [
+          { fields: { Title: 'Task A', Scheduled: '2025-10-31T08:10:24.894Z' } },
+          { fields: { Title: 'Task B', Scheduled: '2025-11-05T10:00:00.000Z' } },
+        ],
+      });
+      let host: ITableFullVo | undefined;
+      try {
+        const scheduledFieldId = foreign.fields.find((field) => field.name === 'Scheduled')!.id;
+        const taggedFormula = await createField(foreign.id, {
+          name: 'Schedule Tag',
+          type: FieldType.Formula,
+          options: {
+            expression: `CONCATENATE(DATETIME_FORMAT({${scheduledFieldId}}, 'YYYY-MM-DD'), "-tag")`,
+          },
+        });
+
+        host = await createTable(baseId, {
+          name: 'formula-lookup-flatten-host',
+          fields: [{ name: 'Project', type: FieldType.SingleLineText } as IFieldRo],
+          records: [{ fields: { Project: 'Main' } }],
+        });
+
+        const linkField = await createField(host.id, {
+          name: 'Related Tasks',
+          type: FieldType.Link,
+          options: {
+            relationship: Relationship.ManyMany,
+            foreignTableId: foreign.id,
+          } as ILinkFieldOptionsRo,
+        } as IFieldRo);
+
+        const lookupField = await createField(host.id, {
+          name: 'Tagged Schedules',
+          type: FieldType.Formula,
+          isLookup: true,
+          lookupOptions: {
+            foreignTableId: foreign.id,
+            lookupFieldId: taggedFormula.id,
+            linkFieldId: linkField.id,
+          } as ILookupOptionsRo,
+        } as IFieldRo);
+
+        const hostRecordId = host.records[0].id;
+        await updateRecordByApi(
+          host.id,
+          hostRecordId,
+          linkField.id,
+          foreign.records.map((record) => ({ id: record.id }))
+        );
+
+        const updatedRecord = await getRecord(host.id, hostRecordId);
+        expect(updatedRecord.data.fields[lookupField.name]).toEqual([
+          '2025-10-31-tag',
+          '2025-11-05-tag',
+        ]);
+      } finally {
+        if (host) {
+          await permanentDeleteTable(baseId, host.id);
+        }
+        await permanentDeleteTable(baseId, foreign.id);
+      }
+    });
+
     it('should calculate numeric formulas using lookup fields', async () => {
       const foreign = await createTable(baseId, {
         name: 'formula-lookup-numeric-foreign',