fix: implement boolean field normalization in SQL conversion and add e2e tests for logical formulas

Author: nichenqin

apps/nestjs-backend/src/db-provider/select-query/postgres/select-query.postgres.spec.ts

@@ -1,9 +1,13 @@
 /* eslint-disable sonarjs/no-duplicate-string */
-import { TableDomain } from '@teable/core';
+import { CellValueType, DbFieldType, FieldType, TableDomain } from '@teable/core';
+import type { IFieldVo } from '@teable/core';
+import knex from 'knex';
 import { beforeEach, describe, expect, it } from 'vitest';
 
+import { createFieldInstanceByVo } from '../../../features/field/model/factory';
 import type { IFieldSelectName } from '../../../features/record/query-builder/field-select.type';
 import type { ISelectFormulaConversionContext } from '../../../features/record/query-builder/sql-conversion.visitor';
+import { PostgresProvider } from '../../postgres.provider';
 import { SelectQueryPostgres } from './select-query.postgres';
 
 describe('SelectQueryPostgres unit-aware date helpers', () => {
@@ -267,3 +271,69 @@ describe('SelectQueryPostgres unit-aware date helpers', () => {
     });
   });
 });
+
+describe('Select formula boolean normalization', () => {
+  const knexClient = knex({ client: 'pg' });
+  const provider = new PostgresProvider(knexClient);
+
+  const booleanFieldVo: IFieldVo = {
+    id: 'fldBoolean001',
+    name: 'Boolean Flag',
+    type: FieldType.Checkbox,
+    options: {},
+    dbFieldName: 'bool_col',
+    dbFieldType: DbFieldType.Boolean,
+    cellValueType: CellValueType.Boolean,
+    isLookup: false,
+    isComputed: false,
+    isMultipleCellValue: false,
+  };
+
+  const textFieldVo: IFieldVo = {
+    id: 'fldText001',
+    name: 'Text Field',
+    type: FieldType.SingleLineText,
+    options: {},
+    dbFieldName: 'text_col',
+    dbFieldType: DbFieldType.Text,
+    cellValueType: CellValueType.String,
+    isLookup: false,
+    isComputed: false,
+    isMultipleCellValue: false,
+  };
+
+  const booleanField = createFieldInstanceByVo(booleanFieldVo);
+  const textField = createFieldInstanceByVo(textFieldVo);
+
+  const table = new TableDomain({
+    id: 'tblBoolean',
+    name: 'Boolean Table',
+    dbTableName: 'boolean_table',
+    lastModifiedTime: '1970-01-01T00:00:00.000Z',
+    fields: [booleanField, textField],
+  });
+
+  const buildContext = (): ISelectFormulaConversionContext => ({
+    table,
+    tableAlias: 'main',
+    selectionMap: new Map<string, IFieldSelectName>([
+      [booleanField.id, '"main"."bool_col"'],
+      [textField.id, '"main"."text_col"'],
+    ]),
+    timeZone: 'UTC',
+    preferRawFieldReferences: true,
+  });
+
+  it('casts boolean field references before PostgreSQL COALESCE', () => {
+    const sql = provider.convertFormulaToSelectQuery('AND({fldBoolean001})', buildContext());
+
+    expect(sql).toContain('(("main"."bool_col"))::boolean');
+    expect(sql).toContain('COALESCE');
+  });
+
+  it('does not cast non-boolean field references', () => {
+    const sql = provider.convertFormulaToSelectQuery('AND({fldText001})', buildContext());
+
+    expect(sql).not.toContain('::boolean');
+  });
+});

apps/nestjs-backend/src/features/record/query-builder/sql-conversion.visitor.ts

@@ -818,7 +818,7 @@ abstract class BaseSqlConversionVisitor<
         if (driver === DriverClient.Sqlite) {
           return `(COALESCE((${valueSql}), 0) != 0)`;
         }
-        return `(COALESCE((${valueSql}), FALSE))`;
+        return `(COALESCE(${this.normalizeBooleanFieldReference(valueSql, exprCtx) ?? valueSql}, FALSE))`;
       case 'number': {
         if (driver === DriverClient.Sqlite) {
           const numericExpr = this.safeCastToNumeric(valueSql);
@@ -848,6 +848,30 @@ abstract class BaseSqlConversionVisitor<
     }
   }
 
+  /**
+   * Coerce direct field references carrying boolean semantics into a proper boolean scalar.
+   * This keeps the SQL maintainable by leveraging schema metadata rather than runtime pg_typeof checks.
+   */
+  private normalizeBooleanFieldReference(valueSql: string, exprCtx: ExprContext): string | null {
+    if (!(exprCtx instanceof FieldReferenceCurlyContext)) {
+      return null;
+    }
+
+    const fieldId = exprCtx.text.slice(1, -1);
+    const fieldInfo = this.context.table?.getField(fieldId);
+    if (!fieldInfo) {
+      return null;
+    }
+
+    const isBooleanField =
+      fieldInfo.dbFieldType === DbFieldType.Boolean || fieldInfo.cellValueType === 'boolean';
+    if (!isBooleanField) {
+      return null;
+    }
+
+    return `((${valueSql}))::boolean`;
+  }
+
   private isBlankLikeExpression(ctx: ExprContext): boolean {
     if (ctx instanceof StringLiteralContext) {
       const raw = ctx.text;

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

@@ -1323,6 +1323,60 @@ describe('OpenAPI formula (e2e)', () => {
       expect(values.not).toBe(true);
     });
 
+    it('should evaluate logical formulas referencing boolean checkbox fields', async () => {
+      const checkboxField = await createField(table1Id, {
+        name: 'logical-checkbox',
+        type: FieldType.Checkbox,
+        options: {},
+      });
+
+      const booleanFormulaField = await createField(table1Id, {
+        name: 'logical-checkbox-formula',
+        type: FieldType.Formula,
+        options: {
+          expression: `AND({${checkboxField.id}}, {${numberFieldRo.id}} > 0)`,
+        },
+      });
+
+      const { records } = await createRecords(table1Id, {
+        fieldKeyType: FieldKeyType.Name,
+        records: [
+          {
+            fields: {
+              [checkboxField.name]: true,
+              [numberFieldRo.name]: 5,
+              [textFieldRo.name]: 'flagged',
+            },
+          },
+        ],
+      });
+
+      const recordId = records[0].id;
+      const initialValue = records[0].fields[booleanFormulaField.name];
+      expect(typeof initialValue).toBe('boolean');
+      expect(initialValue).toBe(true);
+
+      const uncheckedRecord = await updateRecord(table1Id, recordId, {
+        fieldKeyType: FieldKeyType.Name,
+        record: {
+          fields: {
+            [checkboxField.name]: null,
+          },
+        },
+      });
+      expect(uncheckedRecord.fields[booleanFormulaField.name]).toBe(false);
+
+      const recheckedRecord = await updateRecord(table1Id, recordId, {
+        fieldKeyType: FieldKeyType.Name,
+        record: {
+          fields: {
+            [checkboxField.name]: true,
+          },
+        },
+      });
+      expect(recheckedRecord.fields[booleanFormulaField.name]).toBe(true);
+    });
+
     it('should treat numeric IF fallbacks with blank branches as nulls', async () => {
       const numericCondition = await createField(table1Id, {
         name: 'numeric-condition',