Merge pull request #2366 from teableio/fix/T1506-create-system-formula

fix: ensure system field formulas evaluate on create T1506

Author: nichenqin

apps/nestjs-backend/src/features/record/record-modify/record-create.service.ts

@@ -1,11 +1,12 @@
 import { Injectable } from '@nestjs/common';
 import type { IMakeOptional, TableDomain } from '@teable/core';
-import { CellFormat, FieldKeyType, HttpErrorCode, generateRecordId } from '@teable/core';
+import { CellFormat, FieldKeyType, FieldType, HttpErrorCode, generateRecordId } from '@teable/core';
 import type { ICreateRecordsRo, ICreateRecordsVo } from '@teable/openapi';
 import { ThresholdConfig, IThresholdConfig } from '../../../configs/threshold.config';
 import { CustomHttpException } from '../../../custom.exception';
 import { BatchService } from '../../calculation/batch.service';
 import { LinkService } from '../../calculation/link.service';
+import type { ICellContext } from '../../calculation/utils/changes';
 import { TableDomainQueryService } from '../../table-domain';
 import { ComputedOrchestratorService } from '../computed/services/computed-orchestrator.service';
 import type { IRecordInnerRo } from '../record.service';
@@ -85,10 +86,11 @@ export class RecordCreateService {
     await this.linkService.getDerivateByLink(table.id, createCtxs, undefined, projectionByTable);
     const changes = this.shared.compressAndFilterChanges(table, createCtxs);
     const opsMap = this.shared.formatChangesToOps(changes);
+    const computedCtxs = this.appendSystemFieldContextsForCreate(table, recordIds, createCtxs);
     // Publish computed values (with old/new) around base updates
     await this.computedOrchestrator.computeCellChangesForRecords(
       table.id,
-      createCtxs,
+      computedCtxs,
       async (tables) => {
         await this.batchService.updateRecords(opsMap, undefined, undefined, tables);
       }
@@ -131,4 +133,39 @@ export class RecordCreateService {
 
     return projectionIds.size ? { [table.id]: Array.from(projectionIds) } : undefined;
   }
+
+  private appendSystemFieldContextsForCreate(
+    table: TableDomain,
+    recordIds: string[],
+    cellContexts: ICellContext[]
+  ): ICellContext[] {
+    if (!recordIds.length) return cellContexts;
+
+    const systemFieldIds = table.fieldList
+      .filter(
+        (field) =>
+          field.type === FieldType.CreatedTime ||
+          field.type === FieldType.CreatedBy ||
+          field.type === FieldType.LastModifiedTime ||
+          field.type === FieldType.LastModifiedBy ||
+          field.type === FieldType.AutoNumber
+      )
+      .map((field) => field.id);
+
+    if (!systemFieldIds.length) return cellContexts;
+
+    const existing = new Set(cellContexts.map((ctx) => `${ctx.recordId}:${ctx.fieldId}`));
+    const extraContexts: ICellContext[] = [];
+
+    for (const recordId of recordIds) {
+      for (const fieldId of systemFieldIds) {
+        const key = `${recordId}:${fieldId}`;
+        if (existing.has(key)) continue;
+        existing.add(key);
+        extraContexts.push({ recordId, fieldId });
+      }
+    }
+
+    return extraContexts.length ? cellContexts.concat(extraContexts) : cellContexts;
+  }
 }

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

@@ -6575,6 +6575,79 @@ describe('OpenAPI formula (e2e)', () => {
       expect(olderRecord.data.fields[formulaField.name]).toEqual('Older');
     });
 
+    it('should evaluate formula referencing created time on record create', async () => {
+      const createdTimeField = await createField(table.id, {
+        name: 'Created time',
+        type: FieldType.CreatedTime,
+      });
+
+      const formulaField = await createField(table.id, {
+        name: 'Created age (days)',
+        type: FieldType.Formula,
+        options: {
+          expression: `DATETIME_DIFF(NOW(), {${createdTimeField.id}}, "day")`,
+          timeZone: 'UTC',
+        },
+      });
+
+      const created = await createRecords(table.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [{ fields: {} }],
+      });
+
+      const record = await getRecord(table.id, created.records[0].id);
+      expect(record.data.fields[formulaField.name]).toEqual(0);
+    });
+
+    it('should evaluate formula referencing created by on record create', async () => {
+      const createdByField = await createField(table.id, {
+        name: 'Created by',
+        type: FieldType.CreatedBy,
+      });
+
+      const formulaField = await createField(table.id, {
+        name: 'Creator Name',
+        type: FieldType.Formula,
+        options: {
+          expression: `{${createdByField.id}}`,
+        },
+      });
+
+      const created = await createRecords(table.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [{ fields: {} }],
+      });
+
+      const record = await getRecord(table.id, created.records[0].id);
+      const createdByValue = record.data.fields[createdByField.name] as { title?: string } | null;
+      expect(createdByValue?.title).toBeTruthy();
+      expect(record.data.fields[formulaField.name]).toEqual(createdByValue?.title);
+    });
+
+    it('should evaluate formula referencing auto number on record create', async () => {
+      const autoNumberField = await createField(table.id, {
+        name: 'Auto number',
+        type: FieldType.AutoNumber,
+      });
+
+      const formulaField = await createField(table.id, {
+        name: 'Auto number x2',
+        type: FieldType.Formula,
+        options: {
+          expression: `{${autoNumberField.id}} * 2`,
+        },
+      });
+
+      const created = await createRecords(table.id, {
+        fieldKeyType: FieldKeyType.Id,
+        records: [{ fields: {} }],
+      });
+
+      const record = await getRecord(table.id, created.records[0].id);
+      const autoNumberValue = record.data.fields[autoNumberField.name] as number;
+      expect(record.data.fields[formulaField.name]).toEqual(autoNumberValue * 2);
+    });
+
     it('should evaluate timezone-aware formatting formulas referencing fields', async () => {
       const dateField = await createField(table.id, {
         name: 'tz source',