Merge pull request #2353 from teableio/fix/T1466-formula-timezone

fix(T1466): default formula timeZone and add NOW formula test

Author: nichenqin

apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts

@@ -772,13 +772,17 @@ export class FieldSupplementService {
 
     const formatting =
       (fieldRo.options as IFormulaFieldOptions)?.formatting ?? getDefaultFormatting(cellValueType);
+    const timeZone =
+      (fieldRo.options as IFormulaFieldOptions)?.timeZone ??
+      Intl.DateTimeFormat().resolvedOptions().timeZone;
 
     return {
       ...fieldRo,
       name: fieldRo.name ?? 'Calculation',
       options: {
         ...fieldRo.options,
         ...(formatting ? { formatting } : {}),
+        timeZone,
       },
       cellValueType,
       isMultipleCellValue,

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

@@ -285,7 +285,7 @@ export class FieldSelectVisitor implements IFieldVisitor<IFieldSelectName> {
       }
 
       const expression = field.getExpression();
-      const timezone = field.options.timeZone;
+      const timezone = field.options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
 
       // In raw/propagation context (used by UPDATE ... FROM SELECT), avoid referencing
       // the physical generated column directly, since it may have been dropped by

apps/nestjs-backend/test/field-converting.e2e-spec.ts

@@ -238,6 +238,7 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
       const { newField } = await expectUpdate(table1, sourceFieldRo, newFieldRo);
       expect(newField.options).toEqual({
         expression: '"text"',
+        timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
       });
     });
 

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

@@ -202,12 +202,14 @@ describe('OpenAPI FieldController (e2e)', () => {
     });
 
     it('formula field', async () => {
+      const defaultTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
       const stringFormulaField = await createFieldByType(FieldType.Formula, {
         expression: '"A"',
       });
       expect(stringFormulaField.name).toEqual('Calculation');
       expect(stringFormulaField.options).toEqual({
         expression: '"A"',
+        timeZone: defaultTimeZone,
       });
 
       const numberFormulaField = await createFieldByType(FieldType.Formula, {
@@ -216,13 +218,15 @@ describe('OpenAPI FieldController (e2e)', () => {
       expect(numberFormulaField.options).toEqual({
         expression: '1 + 1',
         formatting: { type: NumberFormattingType.Decimal, precision: 2 },
+        timeZone: defaultTimeZone,
       });
 
       const booleanFormulaField = await createFieldByType(FieldType.Formula, {
         expression: 'true',
       });
       expect(booleanFormulaField.options).toEqual({
         expression: 'true',
+        timeZone: defaultTimeZone,
       });
 
       const datetimeField = await createFieldByType(FieldType.Date);
@@ -234,8 +238,9 @@ describe('OpenAPI FieldController (e2e)', () => {
         formatting: {
           date: DateFormattingPreset.ISO,
           time: TimeFormatting.None,
-          timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+          timeZone: defaultTimeZone,
         },
+        timeZone: defaultTimeZone,
       });
     });
 

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

@@ -6496,6 +6496,85 @@ describe('OpenAPI formula (e2e)', () => {
       expect(record2.data.fields[field2.name]).toEqual(27);
     });
 
+    it('should default formula timeZone when missing', async () => {
+      const inputIso = '2024-02-28T00:00:00+09:00';
+      const defaultTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+
+      const field = await createField(table.id, {
+        type: FieldType.Formula,
+        options: {
+          expression: `DAY("${inputIso}")`,
+        },
+      });
+
+      const fieldOptions = field.options as { timeZone?: string } | undefined;
+      expect(fieldOptions?.timeZone).toEqual(defaultTimeZone);
+
+      const record = await getRecord(table.id, table.records[0].id);
+      const expectedDay = Number(
+        new Intl.DateTimeFormat('en-GB', {
+          timeZone: defaultTimeZone,
+          day: '2-digit',
+        }).format(new Date(inputIso))
+      );
+
+      expect(record.data.fields[field.name]).toEqual(expectedDay);
+    });
+
+    it('should bucket Created On records using NOW() formula', async () => {
+      const createdOnField = await createField(table.id, {
+        name: 'Created On',
+        type: FieldType.Date,
+        options: {
+          formatting: {
+            date: DateFormattingPreset.ISO,
+            time: TimeFormatting.Hour24,
+            timeZone: 'UTC',
+          },
+        },
+      });
+
+      const formulaField = await createField(table.id, {
+        name: 'Pitch Day',
+        type: FieldType.Formula,
+        options: {
+          expression: `IF(DATETIME_DIFF(NOW(), {${createdOnField.id}}, "day")<1, "Today", IF(DATETIME_DIFF(NOW(), {${createdOnField.id}}, "day")<2, "Yesterday", "Older"))`,
+          timeZone: 'UTC',
+        },
+      });
+
+      const now = Date.now();
+      const records = await createRecords(table.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [
+          {
+            fields: {
+              [createdOnField.id]: new Date(now - 2 * 60 * 60 * 1000).toISOString(),
+            },
+          },
+          {
+            fields: {
+              [createdOnField.id]: new Date(now - 26 * 60 * 60 * 1000).toISOString(),
+            },
+          },
+          {
+            fields: {
+              [createdOnField.id]: new Date(now - 3 * 24 * 60 * 60 * 1000).toISOString(),
+            },
+          },
+        ],
+      });
+
+      const todayRecord = await getRecord(table.id, records.records[0].id);
+      expect(todayRecord.data.fields[formulaField.name]).toEqual('Today');
+
+      const yesterdayRecord = await getRecord(table.id, records.records[1].id);
+      expect(yesterdayRecord.data.fields[formulaField.name]).toEqual('Yesterday');
+
+      const olderRecord = await getRecord(table.id, records.records[2].id);
+      expect(olderRecord.data.fields[formulaField.name]).toEqual('Older');
+    });
+
     it('should evaluate timezone-aware formatting formulas referencing fields', async () => {
       const dateField = await createField(table.id, {
         name: 'tz source',

packages/core/src/formula/functions/date-time.spec.ts

@@ -36,9 +36,14 @@ describe('DateTime', () => {
     const todayFunc = new Today();
 
     it('should return the current date', () => {
-      const result = todayFunc.eval();
+      const timeZone = 'America/Los_Angeles';
+      const result = todayFunc.eval([], {
+        record: {} as IRecord,
+        dependencies: {},
+        timeZone,
+      });
 
-      expect(result).toBe(dayjs().startOf('d').toISOString());
+      expect(result).toBe(dayjs().tz(timeZone).startOf('d').toISOString());
     });
   });
 

packages/core/src/formula/functions/date-time.ts

@@ -91,13 +91,13 @@ export class Today extends DateTimeFunc {
     return { type: CellValueType.DateTime };
   }
 
-  eval(): string | null {
-    return dayjs().startOf('d').toISOString();
+  eval(_params: TypedValue[], context: IFormulaContext): string | null {
+    return dayjs().tz(context.timeZone).startOf('d').toISOString();
   }
 }
 
 export class Now extends DateTimeFunc {
-  name = FunctionName.Today;
+  name = FunctionName.Now;
 
   acceptValueType = new Set([]);
 
@@ -111,8 +111,8 @@ export class Now extends DateTimeFunc {
     return { type: CellValueType.DateTime };
   }
 
-  eval(): string | null {
-    return dayjs().toISOString();
+  eval(_params: TypedValue[], context: IFormulaContext): string | null {
+    return dayjs().tz(context.timeZone).toISOString();
   }
 }