[sync] fix(app): preserve view defaults for personal selection requests (#1423) (#2749)

Synced from teableio/teable-ee@acd33a7

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

Author: tea-artist

apps/nextjs-app/src/features/app/blocks/view/grid/hooks/useSelectionOperation.ts

@@ -34,7 +34,7 @@ import { useConfirm } from '@teable/ui-lib/base';
 import { toast } from '@teable/ui-lib/shadcn/ui/sonner';
 import type { AxiosResponse } from 'axios';
 import { useTranslation } from 'next-i18next';
-import { useCallback } from 'react';
+import { useCallback, useMemo } from 'react';
 import { isHTTPS, isLocalhost } from '@/features/app/utils';
 import { serializerCellValueHtml, serializerHtml } from '@/features/app/utils/clipboard';
 import { tableConfig } from '@/features/i18n/table.config';
@@ -48,6 +48,7 @@ import {
   textPasteHandlerWithData,
 } from '../utils/copyAndPaste';
 import { getSyncCopyData } from '../utils/getSyncCopyData';
+import { buildSelectionViewQuery } from '../utils/selectionViewQuery';
 import { useSyncSelectionStore } from './useSelectionStore';
 
 const clearToastId = 'clearToastId';
@@ -79,13 +80,17 @@ export const useSelectionOperation = (props?: {
   const { t } = useTranslation(tableConfig.i18nNamespaces);
 
   const groupBy = view?.group;
+  const selectionViewQuery = useMemo(
+    () => buildSelectionViewQuery({ view, personalViewCommonQuery }),
+    [view, personalViewCommonQuery]
+  );
 
   const { mutateAsync: defaultCopyReq } = useMutation({
     mutationFn: async (copyRo: IRangesRo) => {
       const { collapsedGroupIds: _originalCollapsedGroupIds, ...rest } = copyRo;
       const params = {
         ...rest,
-        ...personalViewCommonQuery,
+        ...selectionViewQuery,
         viewId,
         groupBy,
         search,
@@ -105,7 +110,7 @@ export const useSelectionOperation = (props?: {
     mutationFn: (pasteRo: IPasteRo) =>
       paste(tableId!, {
         ...pasteRo,
-        ...personalViewCommonQuery,
+        ...selectionViewQuery,
         viewId,
         groupBy,
         collapsedGroupIds,
@@ -118,14 +123,14 @@ export const useSelectionOperation = (props?: {
 
   const { mutateAsync: temporaryPasteReq } = useMutation({
     mutationFn: (temporaryPasteRo: ITemporaryPasteRo) =>
-      temporaryPaste(tableId!, { ...temporaryPasteRo, ...personalViewCommonQuery, viewId }),
+      temporaryPaste(tableId!, { ...temporaryPasteRo, ...selectionViewQuery, viewId }),
   });
 
   const { mutateAsync: clearReq } = useMutation({
     mutationFn: (clearRo: IRangesRo) =>
       clear(tableId!, {
         ...clearRo,
-        ...personalViewCommonQuery,
+        ...selectionViewQuery,
         viewId,
         groupBy,
         collapsedGroupIds,
@@ -141,7 +146,7 @@ export const useSelectionOperation = (props?: {
       const { collapsedGroupIds: _originalCollapsedGroupIds, ...rest } = deleteRo;
       const params = {
         ...rest,
-        ...personalViewCommonQuery,
+        ...selectionViewQuery,
         viewId,
         groupBy,
         search,

apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.spec.ts

@@ -0,0 +1,82 @@
+import type { IGetRecordsRo } from '@teable/openapi';
+import { describe, expect, it } from 'vitest';
+import { buildSelectionViewQuery } from './selectionViewQuery';
+
+describe('buildSelectionViewQuery', () => {
+  it('returns undefined when there is no personal view query', () => {
+    expect(buildSelectionViewQuery({})).toBeUndefined();
+  });
+
+  it('drops ignoreViewQuery when personal query matches saved view query', () => {
+    const filter: NonNullable<IGetRecordsRo['filter']> = {
+      conjunction: 'and',
+      filterSet: [{ fieldId: 'fldValue', operator: 'is', value: 'Open' }],
+    };
+    const orderBy: NonNullable<IGetRecordsRo['orderBy']> = [{ fieldId: 'fldSort', order: 'desc' }];
+    const groupBy: NonNullable<IGetRecordsRo['groupBy']> = [{ fieldId: 'fldGroup', order: 'asc' }];
+
+    expect(
+      buildSelectionViewQuery({
+        view: {
+          filter,
+          sort: { sortObjs: orderBy },
+          group: groupBy,
+        },
+        personalViewCommonQuery: {
+          ignoreViewQuery: true,
+          filter,
+          orderBy,
+          groupBy,
+          projection: ['fldPrimary'],
+        },
+      })
+    ).toEqual({
+      projection: ['fldPrimary'],
+    });
+  });
+
+  it('keeps ignoreViewQuery when personal query intentionally clears a saved filter', () => {
+    const filter: NonNullable<IGetRecordsRo['filter']> = {
+      conjunction: 'and',
+      filterSet: [{ fieldId: 'fldValue', operator: 'is', value: 'Open' }],
+    };
+
+    expect(
+      buildSelectionViewQuery({
+        view: {
+          filter,
+        },
+        personalViewCommonQuery: {
+          ignoreViewQuery: true,
+          filter: null,
+          projection: ['fldPrimary'],
+        },
+      })
+    ).toEqual({
+      ignoreViewQuery: true,
+      filter: null,
+      projection: ['fldPrimary'],
+    });
+  });
+
+  it('keeps ignoreViewQuery when personal query changes sorting', () => {
+    const orderBy: NonNullable<IGetRecordsRo['orderBy']> = [{ fieldId: 'fldSort', order: 'asc' }];
+
+    expect(
+      buildSelectionViewQuery({
+        view: {
+          sort: { sortObjs: [{ fieldId: 'fldSort', order: 'desc' }] },
+        },
+        personalViewCommonQuery: {
+          ignoreViewQuery: true,
+          orderBy,
+          projection: ['fldPrimary'],
+        },
+      })
+    ).toEqual({
+      ignoreViewQuery: true,
+      orderBy,
+      projection: ['fldPrimary'],
+    });
+  });
+});

apps/nextjs-app/src/features/app/blocks/view/grid/utils/selectionViewQuery.ts

@@ -0,0 +1,45 @@
+import type { IGetRecordsRo } from '@teable/openapi';
+import { isEqual } from 'lodash';
+
+type IViewQueryLike = {
+  filter?: IGetRecordsRo['filter'];
+  sort?: { sortObjs?: IGetRecordsRo['orderBy'] } | null;
+  group?: IGetRecordsRo['groupBy'];
+};
+
+type ISelectionViewQuery = Pick<
+  IGetRecordsRo,
+  'ignoreViewQuery' | 'filter' | 'orderBy' | 'groupBy' | 'projection'
+>;
+
+/**
+ * Personal views always carry ignoreViewQuery=true, but selection APIs only need that
+ * flag when the personal view actually changes row-targeting query state.
+ */
+export const buildSelectionViewQuery = ({
+  view,
+  personalViewCommonQuery,
+}: {
+  view?: IViewQueryLike;
+  personalViewCommonQuery?: ISelectionViewQuery;
+}): ISelectionViewQuery | undefined => {
+  if (!personalViewCommonQuery) {
+    return;
+  }
+
+  const { ignoreViewQuery, filter, orderBy, groupBy, projection } = personalViewCommonQuery;
+  if (!ignoreViewQuery) {
+    return personalViewCommonQuery;
+  }
+
+  const hasQueryDifference =
+    !isEqual(filter ?? null, view?.filter ?? null) ||
+    !isEqual(orderBy, view?.sort?.sortObjs) ||
+    !isEqual(groupBy, view?.group);
+
+  if (hasQueryDifference) {
+    return personalViewCommonQuery;
+  }
+
+  return projection ? { projection } : undefined;
+};

packages/v2/e2e/src/paste.e2e.spec.ts

@@ -3657,6 +3657,32 @@ describe('v2 http paste (e2e)', () => {
       // B should be updated (last in DESC among filtered)
       expect(recordB?.fields[vsSortNameFieldId]).toBe('ViewSortFilterRow3');
     });
+
+    it('should paste to the correct row when client only sends projection', async () => {
+      // Simulate the personal-view request shape after frontend normalization:
+      // projection can differ, but row-targeting should still follow saved view defaults.
+      const result = await ctx.paste({
+        tableId: vsSortTableId,
+        viewId: vsSortViewId,
+        ranges: [
+          [0, 1],
+          [0, 1],
+        ],
+        content: [['ProjectionOnlyRow1']],
+        projection: [vsSortNameFieldId],
+      });
+
+      expect(result.updatedCount).toBe(1);
+
+      const records = await ctx.listRecords(vsSortTableId);
+      const recordD = records.find((r) => r.fields[vsSortValueFieldId] === 400);
+      const recordE = records.find((r) => r.fields[vsSortValueFieldId] === 500);
+
+      // Filtered DESC: E(500), D(400), C(300), B(200)
+      // Row 1 should update D, even when projection is present.
+      expect(recordD?.fields[vsSortNameFieldId]).toBe('ProjectionOnlyRow1');
+      expect(recordE?.fields[vsSortNameFieldId]).toBe('RecordE');
+    });
   });
 
   describe('paste with NULL values in sort field (v1 null ordering alignment)', () => {