Merge pull request #2401 from teableio/sync/ee-20260107-104958

[sync] feat: add e2e tests for conditional lookup number type and field conversion from CreatedTime to Date

Author: nichenqin

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

@@ -1344,6 +1344,10 @@ export class FieldConvertingService {
       return false;
     }
 
+    if (newField.hasError !== oldField.hasError) {
+      return true;
+    }
+
     if (majorFieldKeysChanged(oldField, newField)) {
       return true;
     }
@@ -1384,11 +1388,12 @@ export class FieldConvertingService {
       return;
     }
 
+    const errorStateChanged = newField.hasError !== oldField.hasError;
     const hasMajorChange = majorFieldKeysChanged(oldField, newField);
     const conditionalLookupDiff = this.hasConditionalLookupDiff(newField, oldField);
     const conditionalRollupDiff = this.hasConditionalRollupDiff(newField, oldField);
 
-    if (!hasMajorChange && !conditionalLookupDiff && !conditionalRollupDiff) {
+    if (!errorStateChanged && !hasMajorChange && !conditionalLookupDiff && !conditionalRollupDiff) {
       return;
     }
 

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

@@ -1447,6 +1447,33 @@ export class FieldService implements IReadonlyAdapterService {
     if (oldField.type === newField.type) {
       return;
     }
+
+    const usesPersistedGeneratedColumn = (field: IFieldInstance) => {
+      if (field.isLookup) {
+        return false;
+      }
+
+      const persistedAsGeneratedColumn = (
+        field.meta as { persistedAsGeneratedColumn?: boolean } | undefined
+      )?.persistedAsGeneratedColumn;
+
+      if (persistedAsGeneratedColumn !== undefined) {
+        return persistedAsGeneratedColumn === true;
+      }
+
+      if (field.type === FieldType.CreatedTime) {
+        return true;
+      }
+
+      if (field.type === FieldType.LastModifiedTime) {
+        const maybeLastModified = field as unknown as { isTrackAll?: () => boolean };
+        if (typeof maybeLastModified.isTrackAll === 'function') {
+          return maybeLastModified.isTrackAll();
+        }
+      }
+
+      return false;
+    };
     // If either side is Formula, we must reconcile the physical schema using modifyColumnSchema.
     // This ensures that converting to Formula creates generated columns (or proper projection),
     // and converting back from Formula recreates the original physical column.
@@ -1464,6 +1491,28 @@ export class FieldService implements IReadonlyAdapterService {
       return;
     }
 
+    // Some field types (e.g., CreatedTime / LastModifiedTime(track all)) are persisted as generated columns
+    // without a dbFieldType change. Converting them to a regular field type (e.g., Date) must recreate the
+    // physical column, otherwise UPDATEs will hit "cannot update a generated column".
+    if (oldField.dbFieldType === newField.dbFieldType) {
+      const oldGenerated = usesPersistedGeneratedColumn(oldField);
+      const newGenerated = usesPersistedGeneratedColumn(newField);
+
+      if (oldGenerated || newGenerated) {
+        const tableDomain = await this.tableDomainQueryService.getTableDomainById(tableId);
+        const modifyColumnSql = this.dbProvider.modifyColumnSchema(
+          dbTableName,
+          oldField,
+          newField,
+          tableDomain
+        );
+        for (const sql of modifyColumnSql) {
+          await this.prismaService.txClient().$executeRawUnsafe(sql);
+        }
+        return;
+      }
+    }
+
     await this.handleFormulaUpdate(tableId, dbTableName, oldField, newField);
   }
 

packages/core/src/models/field/derivate/date.field.spec.ts

@@ -160,20 +160,24 @@ describe('DateFieldCore', () => {
   it('should valid cellValue', () => {
     const date = new Date();
     const cellValue = date.toISOString();
+    const cellValueWithoutMs = '2026-01-06T00:00:00+00:00';
     const lookupFieldOne = plainToInstance(DateFieldCore, {
       ...json,
       lookupJson,
       isMultipleCellValue: false,
     });
     expect(field.validateCellValue(cellValue).success).toBe(true);
+    expect(field.validateCellValue(cellValueWithoutMs).success).toBe(true);
     expect(field.validateCellValue(date.getTime()).success).toBe(false);
     expect(field.validateCellValue('xxx').success).toBe(false);
 
     expect(lookupField.validateCellValue([cellValue]).success).toBe(true);
+    expect(lookupField.validateCellValue([cellValueWithoutMs]).success).toBe(true);
     expect(lookupField.validateCellValue(cellValue).success).toBe(false);
     expect(lookupField.validateCellValue([{ id: 'actxxx' }]).success).toBe(false);
 
     expect(lookupFieldOne.validateCellValue(cellValue).success).toBe(true);
+    expect(lookupFieldOne.validateCellValue(cellValueWithoutMs).success).toBe(true);
   });
 
   describe('validateOptions', () => {

packages/core/src/models/field/derivate/date.field.ts

@@ -14,7 +14,10 @@ extend(timezone);
 extend(customParseFormat);
 extend(utc);
 
-export const dataFieldCellValueSchema = z.string().datetime({ precision: 3, offset: true });
+// Stored date/time values can come from client-side `Date.toISOString()` (millisecond precision)
+// or from database JSON aggregation (which may omit fractional seconds when zero).
+// Accept both, while still requiring an explicit timezone offset (e.g. `Z`, `+00:00`).
+export const dataFieldCellValueSchema = z.string().datetime({ offset: true });
 
 export type IDateCellValue = z.infer<typeof dataFieldCellValueSchema>;