[sync] fix(sdk): normalize v2 rollup field docs (#1403) (#2737)

Synced from teableio/teable-ee@67908ee

Co-authored-by: nichenqin <nichenqin@hotmail.com>

Author: tea-artist

packages/sdk/src/model/field/factory.spec.ts

@@ -14,14 +14,19 @@ const createBaseField = (): IFieldVo => ({
   dbFieldType: DbFieldType.Text,
 });
 
+const foreignTableId = 'tblForeign00000001';
+const lookupFieldId = 'fldLookup000000001';
+const linkFieldId = 'fldLink000000000001';
+const sumExpression = 'sum({values})';
+
 describe('createFieldInstance lookup normalization', () => {
   it('normalizes v2 conditionalLookup payload shape', () => {
     const field = {
       ...createBaseField(),
       type: 'conditionalLookup',
       options: {
-        foreignTableId: 'tblForeign00000001',
-        lookupFieldId: 'fldLookup000000001',
+        foreignTableId,
+        lookupFieldId,
         condition: {
           filter: {
             conjunction: 'and',
@@ -43,8 +48,8 @@ describe('createFieldInstance lookup normalization', () => {
     expect(instance.isLookup).toBe(true);
     expect(instance.isConditionalLookup).toBe(true);
     expect(instance.lookupOptions).toMatchObject({
-      foreignTableId: 'tblForeign00000001',
-      lookupFieldId: 'fldLookup000000001',
+      foreignTableId,
+      lookupFieldId,
       sort: { fieldId: 'fldScore0000000001', order: 'asc' },
       limit: 5,
     });
@@ -58,9 +63,9 @@ describe('createFieldInstance lookup normalization', () => {
       cellValueType: CellValueType.Number,
       dbFieldType: DbFieldType.Real,
       options: {
-        linkFieldId: 'fldLink000000000001',
-        lookupFieldId: 'fldLookup000000001',
-        foreignTableId: 'tblForeign00000001',
+        linkFieldId,
+        lookupFieldId,
+        foreignTableId,
       },
     } as unknown as IFieldVo;
 
@@ -70,9 +75,82 @@ describe('createFieldInstance lookup normalization', () => {
     expect(instance.isLookup).toBe(true);
     expect(instance.isConditionalLookup).toBeUndefined();
     expect(instance.lookupOptions).toMatchObject({
-      linkFieldId: 'fldLink000000000001',
-      lookupFieldId: 'fldLookup000000001',
-      foreignTableId: 'tblForeign00000001',
+      linkFieldId,
+      lookupFieldId,
+      foreignTableId,
+    });
+  });
+
+  it('normalizes v2 rollup payload shape', () => {
+    const field = {
+      ...createBaseField(),
+      type: FieldType.Rollup,
+      options: {
+        expression: sumExpression,
+        formatting: {
+          type: 'decimal',
+          precision: 2,
+        },
+      },
+      config: {
+        linkFieldId,
+        foreignTableId,
+        lookupFieldId,
+      },
+      cellValueType: CellValueType.Number,
+      dbFieldType: DbFieldType.Real,
+    } as unknown as IFieldVo;
+
+    const instance = createFieldInstance(field);
+
+    expect(instance.type).toBe(FieldType.Rollup);
+    expect((instance.options as { expression?: string }).expression).toBe(sumExpression);
+    expect(instance.lookupOptions).toMatchObject({
+      linkFieldId,
+      foreignTableId,
+      lookupFieldId,
+    });
+  });
+
+  it('normalizes v2 conditionalRollup payload shape', () => {
+    const field = {
+      ...createBaseField(),
+      type: FieldType.ConditionalRollup,
+      options: {
+        expression: sumExpression,
+        formatting: {
+          type: 'decimal',
+          precision: 2,
+        },
+      },
+      config: {
+        foreignTableId,
+        lookupFieldId,
+        condition: {
+          filter: {
+            conjunction: 'and',
+            filterSet: [{ fieldId: 'fldStatus000000001', operator: 'is', value: 'Active' }],
+          },
+          sort: { fieldId: 'fldScore0000000001', order: 'desc' },
+          limit: 10,
+        },
+      },
+      cellValueType: CellValueType.Number,
+      dbFieldType: DbFieldType.Real,
+    } as unknown as IFieldVo;
+
+    const instance = createFieldInstance(field);
+
+    expect(instance.type).toBe(FieldType.ConditionalRollup);
+    expect(instance.options).toMatchObject({
+      expression: sumExpression,
+      foreignTableId,
+      lookupFieldId,
+      sort: { fieldId: 'fldScore0000000001', order: 'desc' },
+      limit: 10,
     });
+    expect(
+      (instance.options as { filter?: { filterSet?: unknown[] } }).filter?.filterSet
+    ).toHaveLength(1);
   });
 });

packages/sdk/src/model/field/factory.ts

@@ -23,7 +23,7 @@ import { SingleLineTextField } from './single-line-text.field';
 import { SingleSelectField } from './single-select.field';
 import { UserField } from './user.field';
 
-const FIELD_TYPES = new Set<string>(Object.values(FieldType));
+const fieldTypes = new Set<string>(Object.values(FieldType));
 
 const isRecordObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -32,7 +32,7 @@ const asRecordObject = (value: unknown): Record<string, unknown> | undefined =>
   isRecordObject(value) ? value : undefined;
 
 const isKnownFieldType = (value: unknown): value is FieldType =>
-  typeof value === 'string' && FIELD_TYPES.has(value);
+  typeof value === 'string' && fieldTypes.has(value);
 
 const inferLookupInnerType = (field: IFieldVo): FieldType => {
   switch (field.cellValueType) {
@@ -47,63 +47,148 @@ const inferLookupInnerType = (field: IFieldVo): FieldType => {
   }
 };
 
-/**
- * Translate v2 lookup DTO shape (type: lookup/conditionalLookup) to the v1-compatible shape
- * consumed by the existing SDK field model.
- */
-const normalizeV2LookupField = (field: IFieldVo): IFieldVo => {
-  const rawType = (field as { type: string }).type;
-  if (rawType !== 'lookup' && rawType !== 'conditionalLookup') {
+const normalizeV2RollupField = (field: IFieldVo): IFieldVo => {
+  if (field.type !== FieldType.Rollup) {
     return field;
   }
 
   const raw = field as IFieldVo & {
-    type: string;
-    innerType?: unknown;
-    innerOptions?: unknown;
+    config?: unknown;
+    lookupOptions?: unknown;
+  };
+  const config = asRecordObject(raw.config);
+  if (!config) {
+    return field;
+  }
+
+  const lookupOptions = {
+    ...(asRecordObject(raw.lookupOptions) ?? {}),
+  } as Record<string, unknown>;
+
+  if (config.linkFieldId != null) lookupOptions.linkFieldId = config.linkFieldId;
+  if (config.foreignTableId != null) lookupOptions.foreignTableId = config.foreignTableId;
+  if (config.lookupFieldId != null) lookupOptions.lookupFieldId = config.lookupFieldId;
+
+  return {
+    ...field,
+    lookupOptions: lookupOptions as IFieldVo['lookupOptions'],
+  };
+};
+
+const normalizeV2ConditionalRollupField = (field: IFieldVo): IFieldVo => {
+  if (field.type !== FieldType.ConditionalRollup) {
+    return field;
+  }
+
+  const raw = field as IFieldVo & {
+    config?: unknown;
     options?: unknown;
   };
+  const config = asRecordObject(raw.config);
+  if (!config) {
+    return field;
+  }
 
-  const rawOptions = asRecordObject(raw.options as unknown);
+  const condition = asRecordObject(config.condition);
+  const options = {
+    ...(asRecordObject(raw.options) ?? {}),
+  } as Record<string, unknown>;
+
+  if (config.foreignTableId != null) options.foreignTableId = config.foreignTableId;
+  if (config.lookupFieldId != null) options.lookupFieldId = config.lookupFieldId;
+  if (condition?.filter != null) options.filter = condition.filter;
+  if (condition?.sort != null) options.sort = condition.sort;
+  if (condition?.limit != null) options.limit = condition.limit;
+
+  return {
+    ...field,
+    options: options as IFieldVo['options'],
+  };
+};
+
+const resolveLookupInnerType = (
+  field: IFieldVo,
+  raw: IFieldVo & {
+    innerType?: unknown;
+    options?: unknown;
+  },
+  rawOptions: Record<string, unknown> | undefined
+): FieldType => {
   const innerTypeCandidate =
     (typeof raw.innerType === 'string' ? raw.innerType : undefined) ||
     (typeof rawOptions?.innerType === 'string' ? rawOptions.innerType : undefined);
-  const innerType = isKnownFieldType(innerTypeCandidate)
-    ? innerTypeCandidate
-    : inferLookupInnerType(field);
+  return isKnownFieldType(innerTypeCandidate) ? innerTypeCandidate : inferLookupInnerType(field);
+};
 
-  const innerOptions = (raw.innerOptions ?? rawOptions?.innerOptions) as IFieldVo['options'];
-  const condition = asRecordObject(rawOptions?.condition);
+const mergeLookupCondition = (
+  lookupOptions: Record<string, unknown>,
+  condition: Record<string, unknown> | undefined
+) => {
+  if (!condition) {
+    return;
+  }
+
+  if (condition.filter !== undefined) lookupOptions.filter = condition.filter;
+  if (condition.sort !== undefined) lookupOptions.sort = condition.sort;
+  if (condition.limit !== undefined) lookupOptions.limit = condition.limit;
+};
 
+const buildLookupOptions = (
+  field: IFieldVo,
+  rawOptions: Record<string, unknown> | undefined
+): IFieldVo['lookupOptions'] => {
   const lookupOptions: Record<string, unknown> = {};
+
   if (rawOptions?.foreignTableId != null) lookupOptions.foreignTableId = rawOptions.foreignTableId;
   if (rawOptions?.lookupFieldId != null) lookupOptions.lookupFieldId = rawOptions.lookupFieldId;
   if (rawOptions?.linkFieldId != null) lookupOptions.linkFieldId = rawOptions.linkFieldId;
   if (rawOptions?.filter != null) lookupOptions.filter = rawOptions.filter;
   if (rawOptions?.sort != null) lookupOptions.sort = rawOptions.sort;
   if (rawOptions?.limit != null) lookupOptions.limit = rawOptions.limit;
-  if (condition) {
-    if (condition.filter !== undefined) lookupOptions.filter = condition.filter;
-    if (condition.sort !== undefined) lookupOptions.sort = condition.sort;
-    if (condition.limit !== undefined) lookupOptions.limit = condition.limit;
+
+  mergeLookupCondition(lookupOptions, asRecordObject(rawOptions?.condition));
+
+  return Object.keys(lookupOptions).length > 0
+    ? (lookupOptions as IFieldVo['lookupOptions'])
+    : field.lookupOptions;
+};
+
+/**
+ * Translate v2 lookup DTO shape (type: lookup/conditionalLookup) to the v1-compatible shape
+ * consumed by the existing SDK field model.
+ */
+const normalizeV2LookupField = (field: IFieldVo): IFieldVo => {
+  const rawType = (field as { type: string }).type;
+  if (rawType !== 'lookup' && rawType !== 'conditionalLookup') {
+    return field;
   }
 
+  const raw = field as IFieldVo & {
+    type: string;
+    innerType?: unknown;
+    innerOptions?: unknown;
+    options?: unknown;
+  };
+
+  const rawOptions = asRecordObject(raw.options as unknown);
+  const innerType = resolveLookupInnerType(field, raw, rawOptions);
+  const innerOptions = (raw.innerOptions ?? rawOptions?.innerOptions) as IFieldVo['options'];
+
   return {
     ...field,
     type: innerType,
     isLookup: true,
     isConditionalLookup:
       rawType === 'conditionalLookup' || field.isConditionalLookup ? true : undefined,
     options: innerOptions ?? {},
-    lookupOptions:
-      Object.keys(lookupOptions).length > 0
-        ? (lookupOptions as IFieldVo['lookupOptions'])
-        : field.lookupOptions,
+    lookupOptions: buildLookupOptions(field, rawOptions),
   };
 };
 
 export function createFieldInstance(field: IFieldVo, doc?: Doc<IFieldVo>) {
-  const normalizedField = normalizeV2LookupField(field);
+  const normalizedField = normalizeV2ConditionalRollupField(
+    normalizeV2RollupField(normalizeV2LookupField(field))
+  );
   const instance = (() => {
     switch (normalizedField.type) {
       case FieldType.SingleLineText: