Function useDeleteTableRowsAsync

apps/sim/hooks/queries/tables.ts:1109–1178

({ workspaceId, tableId }: RowMutationContext)

 * restores rows on failure/cancel).
 */
export function useDeleteTableRowsAsync({ workspaceId, tableId }: RowMutationContext) {
  const queryClient = useQueryClient()

  return useMutation({
    mutationFn: async ({
      filter,
      excludeRowIds,
      estimatedCount,
    }: DeleteTableRowsAsyncVariables) => {
      return requestJson(deleteTableRowsAsyncContract, {
        params: { tableId },
        body: { workspaceId, filter, excludeRowIds, estimatedCount },
      })
    },
    onMutate: async ({ filter, sort, excludeRowIds, estimatedCount }) => {
      // Target the exact infinite-rows query for the view the user is on — not every cached view.
      const activeKey = tableKeys.infiniteRows(
        tableId,
        tableRowsParamsKey({ pageSize: TABLE_LIMITS.MAX_QUERY_LIMIT, filter: filter ?? null, sort })
      )
      await queryClient.cancelQueries({ queryKey: activeKey })
      const previousRows =
        queryClient.getQueryData<InfiniteData<TableRowsResponse, TableRowsPageParam>>(activeKey)
      const previousDetail = queryClient.getQueryData<TableDefinition>(tableKeys.detail(tableId))
      const keep = new Set(excludeRowIds ?? [])
      // The active view's post-delete total is exactly the kept (deselected) rows — every other
      // matching row is doomed. Without this the footer / select-all label stays at the old total
      // until the job's terminal refetch.
      queryClient.setQueryData<InfiniteData<TableRowsResponse, TableRowsPageParam>>(
        activeKey,
        (old) =>
          old
            ? {
                ...old,
                pages: old.pages.map((page) => ({
                  ...page,
                  rows: page.rows.filter((r) => keep.has(r.id)),
                  ...(page.totalCount != null ? { totalCount: keep.size } : {}),
                })),
              }
            : old
      )
      if (estimatedCount != null) {
        queryClient.setQueryData<TableDefinition>(tableKeys.detail(tableId), (p) =>
          p ? { ...p, rowCount: Math.max(0, p.rowCount - estimatedCount) } : p
        )
      }
      return { activeKey, previousRows, previousDetail }
    },
    onSuccess: ({ data }) => {
      // Lock the SSE job consumer onto this run so its running/terminal events are accepted, and
      // flip the list-driven tray into "deleting" without waiting for a poll.
      queryClient.setQueryData<TableDefinition>(tableKeys.detail(tableId), (p) =>
        p ? { ...p, jobStatus: 'running', jobId: data.jobId, jobType: 'delete' } : p
      )
      queryClient.invalidateQueries({ queryKey: tableKeys.lists() })
    },
    onError: (error, _vars, context) => {