@stigmer/react 1.0.4 → 2.0.1

package/src/workflow/execution-history/__tests__/derive-failure-analysis.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect } from "vitest";
+import type { WorkflowExecution } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import {
+  ExecutionPhase,
+  WorkflowTaskStatus,
+} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
+import { deriveFailureAnalysis, type FailureGroup } from "../derive-failure-analysis";
+
+// ---------------------------------------------------------------------------
+// Fixture factory
+// ---------------------------------------------------------------------------
+
+function makeExecution(overrides: {
+  id?: string;
+  name?: string;
+  phase?: ExecutionPhase;
+  completedAt?: string;
+  error?: string;
+  tasks?: Array<{
+    taskName: string;
+    status: WorkflowTaskStatus;
+    error?: string;
+  }>;
+}): WorkflowExecution {
+  return {
+    metadata: {
+      id: overrides.id ?? "wfx_test",
+      name: overrides.name ?? "test-execution",
+      slug: overrides.name ?? "test-execution",
+    },
+    status: {
+      phase: overrides.phase ?? ExecutionPhase.EXECUTION_FAILED,
+      completedAt: overrides.completedAt ?? "2026-05-23T12:00:00Z",
+      error: overrides.error ?? "execution failed",
+      tasks: (overrides.tasks ?? []).map((t) => ({
+        taskName: t.taskName,
+        status: t.status,
+        error: t.error ?? "",
+      })),
+    },
+  } as unknown as WorkflowExecution;
+}
+
+// ---------------------------------------------------------------------------
+// deriveFailureAnalysis
+// ---------------------------------------------------------------------------
+
+describe("deriveFailureAnalysis", () => {
+  it("returns empty array when no executions are failed", () => {
+    const execs = [
+      makeExecution({ phase: ExecutionPhase.EXECUTION_COMPLETED }),
+      makeExecution({ phase: ExecutionPhase.EXECUTION_IN_PROGRESS }),
+    ];
+    expect(deriveFailureAnalysis(execs)).toEqual([]);
+  });
+
+  it("groups failures by task name", () => {
+    const execs = [
+      makeExecution({
+        id: "wfx_1",
+        tasks: [{ taskName: "validate", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED, error: "invalid input" }],
+      }),
+      makeExecution({
+        id: "wfx_2",
+        tasks: [{ taskName: "validate", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED, error: "bad format" }],
+      }),
+      makeExecution({
+        id: "wfx_3",
+        tasks: [{ taskName: "send_email", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED, error: "smtp error" }],
+      }),
+    ];
+
+    const groups = deriveFailureAnalysis(execs);
+    expect(groups).toHaveLength(2);
+    expect(groups[0].taskName).toBe("validate");
+    expect(groups[0].count).toBe(2);
+    expect(groups[1].taskName).toBe("send_email");
+    expect(groups[1].count).toBe(1);
+  });
+
+  it("sorts groups by count descending", () => {
+    const execs = [
+      makeExecution({ id: "1", tasks: [{ taskName: "a", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }] }),
+      makeExecution({ id: "2", tasks: [{ taskName: "b", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }] }),
+      makeExecution({ id: "3", tasks: [{ taskName: "b", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }] }),
+      makeExecution({ id: "4", tasks: [{ taskName: "b", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }] }),
+      makeExecution({ id: "5", tasks: [{ taskName: "a", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }] }),
+    ];
+
+    const groups = deriveFailureAnalysis(execs);
+    expect(groups[0].taskName).toBe("b");
+    expect(groups[0].count).toBe(3);
+    expect(groups[1].taskName).toBe("a");
+    expect(groups[1].count).toBe(2);
+  });
+
+  it("sorts instances within a group by time descending", () => {
+    const execs = [
+      makeExecution({
+        id: "wfx_old", completedAt: "2026-05-23T10:00:00Z",
+        tasks: [{ taskName: "step", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }],
+      }),
+      makeExecution({
+        id: "wfx_new", completedAt: "2026-05-23T14:00:00Z",
+        tasks: [{ taskName: "step", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED }],
+      }),
+    ];
+
+    const groups = deriveFailureAnalysis(execs);
+    expect(groups[0].instances[0].executionId).toBe("wfx_new");
+    expect(groups[0].instances[1].executionId).toBe("wfx_old");
+  });
+
+  it("uses the latest error as group latestError", () => {
+    const execs = [
+      makeExecution({
+        id: "wfx_1", completedAt: "2026-05-23T10:00:00Z",
+        tasks: [{ taskName: "step", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED, error: "old error" }],
+      }),
+      makeExecution({
+        id: "wfx_2", completedAt: "2026-05-23T14:00:00Z",
+        tasks: [{ taskName: "step", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED, error: "new error" }],
+      }),
+    ];
+
+    const groups = deriveFailureAnalysis(execs);
+    expect(groups[0].latestError).toBe("new error");
+  });
+
+  it('groups under "(unknown)" when no failed task is found', () => {
+    const execs = [
+      makeExecution({
+        id: "wfx_1", error: "workflow-level error",
+        tasks: [{ taskName: "step", status: WorkflowTaskStatus.WORKFLOW_TASK_COMPLETED }],
+      }),
+    ];
+
+    const groups = deriveFailureAnalysis(execs);
+    expect(groups).toHaveLength(1);
+    expect(groups[0].taskName).toBe("(unknown)");
+    expect(groups[0].latestError).toBe("workflow-level error");
+  });
+
+  it("returns empty array for empty input", () => {
+    expect(deriveFailureAnalysis([])).toEqual([]);
+  });
+
+  it("ignores non-failed executions mixed with failed ones", () => {
+    const execs = [
+      makeExecution({ id: "ok", phase: ExecutionPhase.EXECUTION_COMPLETED }),
+      makeExecution({
+        id: "fail", phase: ExecutionPhase.EXECUTION_FAILED,
+        tasks: [{ taskName: "step_x", status: WorkflowTaskStatus.WORKFLOW_TASK_FAILED, error: "boom" }],
+      }),
+      makeExecution({ id: "running", phase: ExecutionPhase.EXECUTION_IN_PROGRESS }),
+    ];
+
+    const groups = deriveFailureAnalysis(execs);
+    expect(groups).toHaveLength(1);
+    expect(groups[0].taskName).toBe("step_x");
+    expect(groups[0].count).toBe(1);
+  });
+});

package/src/workflow/execution-history/derive-execution-row.ts

@@ -0,0 +1,231 @@
+import type { WorkflowExecution } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import {
+  ExecutionPhase,
+  WorkflowTaskStatus,
+} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
+
+/**
+ * A flattened, UI-ready row derived from a {@link WorkflowExecution}.
+ *
+ * All computed fields (duration, failed task, retry count) are derived
+ * from the execution's status data — no additional API calls needed.
+ * This type is the contract between the derivation layer and the table
+ * component; it intentionally avoids protobuf types so the table can
+ * be tested and rendered without proto dependencies.
+ */
+export interface ExecutionRow {
+  readonly id: string;
+  readonly name: string;
+  readonly phase: ExecutionPhase;
+  readonly startedAt: Date | null;
+  readonly completedAt: Date | null;
+  /** Milliseconds between started_at and completed_at. `null` when not yet completed or timestamps missing. */
+  readonly durationMs: number | null;
+  readonly costMicros: bigint;
+  readonly inputTokens: bigint;
+  readonly outputTokens: bigint;
+  readonly totalTokens: bigint;
+  readonly taskCount: number;
+  readonly completedTaskCount: number;
+  /** Name of the first task in FAILED status, or `null` if none. */
+  readonly failedTaskName: string | null;
+  /** Name of the first task in IN_PROGRESS status, or `null` if none. */
+  readonly currentTaskName: string | null;
+  /** Number of retry attempts across all tasks (derived from task metadata). */
+  readonly retryCount: number;
+  /** `true` when any task is in WAITING_APPROVAL status. */
+  readonly hasHumanWait: boolean;
+  readonly error: string | null;
+  /** Reference to the original execution for downstream consumers that need the full object. */
+  readonly _source: WorkflowExecution;
+}
+
+const BIGINT_ZERO = BigInt(0);
+
+const TERMINAL_TASK_STATUSES = new Set([
+  WorkflowTaskStatus.WORKFLOW_TASK_COMPLETED,
+  WorkflowTaskStatus.WORKFLOW_TASK_FAILED,
+  WorkflowTaskStatus.WORKFLOW_TASK_SKIPPED,
+]);
+
+function parseIsoDate(iso: string | undefined): Date | null {
+  if (!iso) return null;
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+function extractRetryCount(metadata: { fields?: Record<string, unknown> } | undefined): number {
+  if (!metadata?.fields) return 0;
+  const retryField = metadata.fields["retry_count"] ?? metadata.fields["retryCount"];
+  if (retryField && typeof retryField === "object" && retryField !== null && "numberValue" in retryField) {
+    return Math.max(0, Math.floor((retryField as { numberValue: number }).numberValue ?? 0));
+  }
+  return 0;
+}
+
+/**
+ * Derives a UI-ready {@link ExecutionRow} from a raw {@link WorkflowExecution}.
+ *
+ * Pure function with zero side effects. Computes duration, identifies
+ * the failed/current task, counts retries, and normalizes bigint fields.
+ */
+export function deriveExecutionRow(exec: WorkflowExecution): ExecutionRow {
+  const meta = exec.metadata;
+  const status = exec.status;
+  const tasks = status?.tasks ?? [];
+
+  const startedAt = parseIsoDate(status?.startedAt);
+  const completedAt = parseIsoDate(status?.completedAt);
+
+  let durationMs: number | null = null;
+  if (startedAt && completedAt) {
+    durationMs = completedAt.getTime() - startedAt.getTime();
+  } else if (startedAt && status?.phase === ExecutionPhase.EXECUTION_IN_PROGRESS) {
+    durationMs = Date.now() - startedAt.getTime();
+  }
+
+  let failedTaskName: string | null = null;
+  let currentTaskName: string | null = null;
+  let completedTaskCount = 0;
+  let retryCount = 0;
+  let hasHumanWait = false;
+
+  for (const task of tasks) {
+    if (TERMINAL_TASK_STATUSES.has(task.status)) {
+      completedTaskCount++;
+    }
+    if (!failedTaskName && task.status === WorkflowTaskStatus.WORKFLOW_TASK_FAILED) {
+      failedTaskName = task.taskName || null;
+    }
+    if (!currentTaskName && task.status === WorkflowTaskStatus.WORKFLOW_TASK_IN_PROGRESS) {
+      currentTaskName = task.taskName || null;
+    }
+    if (task.status === WorkflowTaskStatus.WORKFLOW_TASK_WAITING_APPROVAL) {
+      hasHumanWait = true;
+      if (!currentTaskName) currentTaskName = task.taskName || null;
+    }
+    retryCount += extractRetryCount(task.metadata);
+  }
+
+  const costMicros = BigInt(status?.totalCostMicros ?? 0);
+  const inputTokens = BigInt(status?.totalInputTokens ?? 0);
+  const outputTokens = BigInt(status?.totalOutputTokens ?? 0);
+
+  return {
+    id: meta?.id ?? "",
+    name: meta?.name || meta?.slug || "",
+    phase: status?.phase ?? ExecutionPhase.EXECUTION_PHASE_UNSPECIFIED,
+    startedAt,
+    completedAt,
+    durationMs,
+    costMicros,
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    taskCount: tasks.length,
+    completedTaskCount,
+    failedTaskName,
+    currentTaskName,
+    retryCount,
+    hasHumanWait,
+    error: status?.error || null,
+    _source: exec,
+  };
+}
+
+/**
+ * Batch-derives execution rows from a list of raw executions.
+ * Preserves input order.
+ */
+export function deriveExecutionRows(executions: readonly WorkflowExecution[]): ExecutionRow[] {
+  return executions.map(deriveExecutionRow);
+}
+
+// ---------------------------------------------------------------------------
+// Client-side sorting
+// ---------------------------------------------------------------------------
+
+export type ExecutionSortField =
+  | "name"
+  | "phase"
+  | "startedAt"
+  | "duration"
+  | "cost"
+  | "tokens"
+  | "tasks";
+
+export type SortDirection = "asc" | "desc";
+
+type CompareFn = (a: ExecutionRow, b: ExecutionRow) => number;
+
+const SORT_COMPARATORS: Record<ExecutionSortField, CompareFn> = {
+  name: (a, b) => a.name.localeCompare(b.name),
+  phase: (a, b) => a.phase - b.phase,
+  startedAt: (a, b) => (a.startedAt?.getTime() ?? 0) - (b.startedAt?.getTime() ?? 0),
+  duration: (a, b) => (a.durationMs ?? -1) - (b.durationMs ?? -1),
+  cost: (a, b) => Number(a.costMicros - b.costMicros),
+  tokens: (a, b) => Number(a.totalTokens - b.totalTokens),
+  tasks: (a, b) => a.taskCount - b.taskCount,
+};
+
+/**
+ * Sorts execution rows by a given field and direction.
+ * Returns a new array (does not mutate the input).
+ */
+export function sortExecutionRows(
+  rows: readonly ExecutionRow[],
+  field: ExecutionSortField,
+  direction: SortDirection,
+): ExecutionRow[] {
+  const cmp = SORT_COMPARATORS[field];
+  const multiplier = direction === "desc" ? -1 : 1;
+  return [...rows].sort((a, b) => multiplier * cmp(a, b));
+}
+
+// ---------------------------------------------------------------------------
+// Client-side filtering
+// ---------------------------------------------------------------------------
+
+export interface ExecutionClientFilters {
+  readonly phases?: readonly ExecutionPhase[];
+  readonly minDurationMs?: number;
+  readonly maxDurationMs?: number;
+  readonly minCostMicros?: bigint;
+  readonly maxCostMicros?: bigint;
+  readonly failedTaskName?: string;
+  readonly hasRetries?: boolean;
+}
+
+/**
+ * Applies client-side filters to execution rows.
+ * Returns a new array containing only rows that match all criteria.
+ */
+export function filterExecutionRows(
+  rows: readonly ExecutionRow[],
+  filters: ExecutionClientFilters,
+): ExecutionRow[] {
+  return rows.filter((row) => {
+    if (filters.phases?.length && !filters.phases.includes(row.phase)) {
+      return false;
+    }
+    if (filters.minDurationMs != null && (row.durationMs ?? -1) < filters.minDurationMs) {
+      return false;
+    }
+    if (filters.maxDurationMs != null && (row.durationMs ?? Infinity) > filters.maxDurationMs) {
+      return false;
+    }
+    if (filters.minCostMicros != null && row.costMicros < filters.minCostMicros) {
+      return false;
+    }
+    if (filters.maxCostMicros != null && row.costMicros > filters.maxCostMicros) {
+      return false;
+    }
+    if (filters.failedTaskName && row.failedTaskName !== filters.failedTaskName) {
+      return false;
+    }
+    if (filters.hasRetries && row.retryCount === 0) {
+      return false;
+    }
+    return true;
+  });
+}

package/src/workflow/execution-history/derive-failure-analysis.ts

@@ -0,0 +1,111 @@
+import type { WorkflowExecution } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
+import {
+  ExecutionPhase,
+  WorkflowTaskStatus,
+} from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
+
+/**
+ * A single failed execution reference within a {@link FailureGroup}.
+ */
+export interface FailureInstance {
+  readonly executionId: string;
+  readonly executionName: string;
+  readonly error: string;
+  readonly failedAt: Date | null;
+}
+
+/**
+ * A group of failures sharing the same failing task name.
+ *
+ * Sorted by {@link count} descending so the most frequent failures
+ * appear first in the failure analysis panel.
+ */
+export interface FailureGroup {
+  /** The task name that failed across multiple executions. */
+  readonly taskName: string;
+  /** Number of executions where this task failed. */
+  readonly count: number;
+  /** Most recent error message from this task. */
+  readonly latestError: string;
+  /** Timestamp of the most recent failure. */
+  readonly latestFailedAt: Date | null;
+  /** Individual failed execution references (most recent first). */
+  readonly instances: readonly FailureInstance[];
+}
+
+function parseDate(iso: string | undefined): Date | null {
+  if (!iso) return null;
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+
+/**
+ * Groups failed executions by their failing task name.
+ *
+ * Pure function. Only considers executions in FAILED phase. Within each
+ * execution, finds the first FAILED task and groups by its name. Executions
+ * with no identifiable failed task are grouped under `"(unknown)"`.
+ *
+ * Returns groups sorted by failure count descending, with instances
+ * within each group sorted by failure time descending (most recent first).
+ */
+export function deriveFailureAnalysis(
+  executions: readonly WorkflowExecution[],
+): FailureGroup[] {
+  const groupMap = new Map<string, {
+    taskName: string;
+    instances: FailureInstance[];
+  }>();
+
+  for (const exec of executions) {
+    if (exec.status?.phase !== ExecutionPhase.EXECUTION_FAILED) continue;
+
+    const tasks = exec.status?.tasks ?? [];
+    let failedTaskName = "(unknown)";
+    let taskError = exec.status?.error || "";
+
+    for (const task of tasks) {
+      if (task.status === WorkflowTaskStatus.WORKFLOW_TASK_FAILED) {
+        failedTaskName = task.taskName || "(unknown)";
+        taskError = task.error || exec.status?.error || "";
+        break;
+      }
+    }
+
+    const instance: FailureInstance = {
+      executionId: exec.metadata?.id ?? "",
+      executionName: exec.metadata?.name || exec.metadata?.slug || "",
+      error: taskError,
+      failedAt: parseDate(exec.status?.completedAt),
+    };
+
+    let group = groupMap.get(failedTaskName);
+    if (!group) {
+      group = { taskName: failedTaskName, instances: [] };
+      groupMap.set(failedTaskName, group);
+    }
+    group.instances.push(instance);
+  }
+
+  const groups: FailureGroup[] = [];
+
+  for (const group of groupMap.values()) {
+    const sorted = [...group.instances].sort((a, b) => {
+      const ta = a.failedAt?.getTime() ?? 0;
+      const tb = b.failedAt?.getTime() ?? 0;
+      return tb - ta;
+    });
+
+    groups.push({
+      taskName: group.taskName,
+      count: sorted.length,
+      latestError: sorted[0]?.error ?? "",
+      latestFailedAt: sorted[0]?.failedAt ?? null,
+      instances: sorted,
+    });
+  }
+
+  groups.sort((a, b) => b.count - a.count);
+
+  return groups;
+}

package/src/workflow/execution-history/index.ts

@@ -0,0 +1,47 @@
+export {
+  deriveExecutionRow,
+  deriveExecutionRows,
+  sortExecutionRows,
+  filterExecutionRows,
+  type ExecutionRow,
+  type ExecutionSortField,
+  type SortDirection,
+  type ExecutionClientFilters,
+} from "./derive-execution-row";
+
+export {
+  deriveFailureAnalysis,
+  type FailureGroup,
+  type FailureInstance,
+} from "./derive-failure-analysis";
+
+export {
+  ExecutionHistoryTable,
+  type ExecutionHistoryTableProps,
+} from "./ExecutionHistoryTable";
+
+export {
+  useExecutionHistoryData,
+  type UseExecutionHistoryDataOptions,
+  type UseExecutionHistoryDataReturn,
+} from "./useExecutionHistoryData";
+
+export {
+  HealthMetricsStrip,
+  type HealthMetricsStripProps,
+} from "./HealthMetricsStrip";
+
+export {
+  FailureAnalysisPanel,
+  type FailureAnalysisPanelProps,
+} from "./FailureAnalysisPanel";
+
+export {
+  ExecutionFilterBar,
+  type ExecutionFilterBarProps,
+} from "./ExecutionFilterBar";
+
+export {
+  WorkflowExecutionHistory,
+  type WorkflowExecutionHistoryProps,
+} from "./WorkflowExecutionHistory";

package/src/workflow/execution-history/useExecutionHistoryData.ts

@@ -0,0 +1,103 @@
+"use client";
+
+import { useMemo } from "react";
+import { useWorkflowExecutionList } from "../useWorkflowExecutionList";
+import {
+  deriveExecutionRows,
+  filterExecutionRows,
+  type ExecutionRow,
+  type ExecutionClientFilters,
+} from "./derive-execution-row";
+
+/** Options for {@link useExecutionHistoryData}. */
+export interface UseExecutionHistoryDataOptions {
+  /**
+   * When set, scopes the list to executions of this workflow.
+   * When omitted, lists all executions across all workflows.
+   */
+  readonly workflowId?: string | null;
+  /** Maximum executions per page. @default 20 */
+  readonly pageSize?: number;
+  /** Opaque cursor for paginated fetching. */
+  readonly pageToken?: string;
+  /**
+   * Client-side filters applied post-fetch to the loaded page.
+   * These are a stopgap until server-side filters are wired (Phase 2).
+   */
+  readonly clientFilters?: ExecutionClientFilters;
+}
+
+/** Return value of {@link useExecutionHistoryData}. */
+export interface UseExecutionHistoryDataReturn {
+  /** Derived, optionally filtered execution rows for the current page. */
+  readonly rows: readonly ExecutionRow[];
+  /** Total pages from the server (does not account for client-side filtering). */
+  readonly totalPages: number;
+  /** `true` while the initial fetch is in flight. */
+  readonly isLoading: boolean;
+  /** `true` while a background refetch is in flight and stale data is shown. */
+  readonly isRefetching: boolean;
+  /** Error from the last failed request, or `null` when healthy. */
+  readonly error: Error | null;
+  /** Discard cached data and re-fetch from the server. */
+  readonly refetch: () => void;
+}
+
+/**
+ * Behavior hook that composes {@link useWorkflowExecutionList} with the
+ * {@link deriveExecutionRows} derivation pipeline and optional client-side
+ * filters.
+ *
+ * Returns pre-computed {@link ExecutionRow} objects ready for rendering
+ * by {@link ExecutionHistoryTable}.
+ *
+ * @example
+ * ```tsx
+ * const { rows, isLoading, error, refetch } = useExecutionHistoryData({
+ *   workflowId: "wf_onboarding",
+ *   pageSize: 20,
+ *   clientFilters: { phases: [ExecutionPhase.EXECUTION_FAILED] },
+ * });
+ * ```
+ */
+export function useExecutionHistoryData(
+  options?: UseExecutionHistoryDataOptions,
+): UseExecutionHistoryDataReturn {
+  const workflowId = options?.workflowId ?? null;
+  const pageSize = options?.pageSize ?? 20;
+  const pageToken = options?.pageToken;
+  const clientFilters = options?.clientFilters;
+
+  const {
+    executions,
+    totalPages,
+    isLoading,
+    isRefetching,
+    error,
+    refetch,
+  } = useWorkflowExecutionList({ workflowId, pageSize, pageToken });
+
+  const derivedRows = useMemo(
+    () => deriveExecutionRows(executions),
+    [executions],
+  );
+
+  const filteredRows = useMemo(() => {
+    if (!clientFilters || Object.keys(clientFilters).length === 0) {
+      return derivedRows;
+    }
+    return filterExecutionRows(derivedRows, clientFilters);
+  }, [derivedRows, clientFilters]);
+
+  return useMemo(
+    () => ({
+      rows: filteredRows,
+      totalPages,
+      isLoading,
+      isRefetching,
+      error,
+      refetch,
+    }),
+    [filteredRows, totalPages, isLoading, isRefetching, error, refetch],
+  );
+}