fabro/apps/fabro-web/app/hooks/use-insights-query-runner.ts
fabro-sh-0530[bot] b196a97ac4
Introduce approved effect hooks and migrate direct useEffect calls (#425)
## Summary

Implements the React Effects Policy by creating the approved hook
surface in `hooks/effects.ts` and migrating a broad set of direct
`useEffect` calls across the codebase to either purpose-named hooks or
non-effect patterns.

### Plan Summary

- Add `hooks/effects.ts` exporting `useMountEffect`, `useInterval`,
`useTimeout`, `useDebouncedValue`, `useWindowEvent`, `useDocumentEvent`,
`useDocumentTitle`, `useMediaQuery`, `useLocationHash`, and
`useResizeObserver`
- Extract large imperative effects into purpose-named hooks:
`useTerminalSession`, `useFloatingTooltipMeasurements`,
`useAnnotatedRunGraphSvg`, `useInstallEffects`, and others
- Move install session fetch from a component effect into a SWR query
(`install-query.ts`)
- Replace `useEffect` + `useState` state-derivation patterns with
render-time computation or ref callbacks
- Replace `AskFabroLayoutProvider`/`useAskFabroLayout` context with a
prop callback

## What changed and why

**`hooks/effects.ts`** — the new approved primitive surface. All
internal `useEffect` calls here are intentional; the hooks expose the
*external system* they manage rather than leaking `useEffect` to
component code. `useMediaQuery` and `useLocationHash` use
`useSyncExternalStore` instead of effect + state.

**`useTerminalSession`** — the largest extraction. The 130-line
xterm/WebSocket/ResizeObserver setup block moves from
`terminal-view.tsx` into its own hook, which now owns the `terminalRef`,
`fitRef`, and `socketRef` that previously cluttered the component.
`TerminalConnectionError` and `ConnectionStatus` types are exported from
the hook.

**`useFloatingTooltipMeasurements`** — extracts the `useLayoutEffect` +
ResizeObserver + window resize listener out of `FloatingTooltip`. The
`FloatingTooltipSize` type moves with it so consumers don't need to
import from the component.

**`useInstallSessionQuery` + `useInstallEffects`** — the install session
fetch moves from a component effect to SWR (`install-query.ts`). The
three remaining install effects (token URL scrubbing, GitHub error URL
scrubbing, health-poll restart) move into
`hooks/use-install-effects.ts`. The root-redirect effect is replaced
with a render-time `<Navigate>` gate. The `SessionState` discriminant
now carries `token` so stale query results can be discarded without an
effect chain.

**`SelectionCheckbox`** — `useEffect` setting `input.indeterminate` is
replaced with a ref callback, which runs synchronously after the node is
attached and avoids a stale-frame flash.

**`event-debug.tsx`** — the manual `window.addEventListener("keydown",
...)` pattern is replaced with `useWindowEvent`, removing the
`react-doctor-disable` suppression comments.

**`run-waterfall.tsx`** — the local `useTickingNow` is deleted;
`RunWaterfall` now calls the shared `useTickingNow` from `lib/time` with
the new `active` parameter signature.

**`toast.test.tsx`** — `useEffect(() => onReady?.(api), ...)` in the
test helper is replaced with a direct call during render, which is valid
because `onReady` has no side effects that React cares about.

**`AskFabroSidebar`** — `setIsResizing` from the layout context is
replaced with an `onResizeActiveChange` prop, removing the
`useAskFabroLayout` call and the hidden context coupling from the
sidebar.


### Fabro Details

<details>
<summary>Ran 3 stages in 114m 5s for $95.71</summary>

| Stage | Duration | Cost | Retries |
|---|---|---|---|
| start | 0s | – | 0 |
| work | 103m 3s | $80.42 | 0 |
| audit | 10m 19s | $15.29 | 0 |
| **Total** | **114m 5s** | **$95.71** | **0** |

</details>

<details>
<summary>Ran <code>Goal.fabro</code> (4 nodes and 5 edges)</summary>

```dot
digraph Goal {
    graph [
        goal="Complete the user-provided goal",
        rankdir=LR,
        max_node_visits=30
    ]

    start [shape=Mdiamond, label="Start"]
    exit  [shape=Msquare, label="Exit"]

    work [
        label="Work",
        thread_id="goal",
        fidelity="full",
        max_visits=12,
        model="gpt-55",
        reasoning_effort="xhigh",
        prompt="@prompts/continue.md"
    ]

    audit [
        label="Completion Audit",
        thread_id="goal",
        fidelity="full",
        goal_gate=true,
        retry_target="work",
        output_schema="routing",
        output_retries=2,
        max_visits=12,
        model="gpt-55",
        reasoning_effort="xhigh",
        prompt="@prompts/audit.md"
    ]

    start -> work -> audit

    audit -> exit [label="Done", condition="outcome=succeeded"]
    audit -> work [label="Continue", condition="outcome=failed || preferred_label=Continue"]
    audit -> work [label="No clear verdict"]
}

```

</details>

⚒️ Generated with [Fabro](https://fabro.sh)

---------

Co-authored-by: Fabro <noreply@fabro.sh>
Co-authored-by: Bryan Helmkamp <bryan@brynary.com>
2026-05-27 10:37:29 -04:00

116 lines
4 KiB
TypeScript

import { useCallback, useEffect, useRef, useState } from "react";
export interface QueryResult {
columns: string[];
rows: Array<Record<string, string | number>>;
elapsed: number;
rowsRead: number;
bytesRead: number;
rowsReturned: number;
}
function generateMockResult(sql: string): QueryResult {
const lowerSql = sql.toLowerCase();
if (lowerSql.includes("workflow_name") && lowerSql.includes("avg")) {
return {
columns: ["workflow_name", "avg_duration", "run_count"],
rows: [
{ workflow_name: "Expand Product", avg_duration: 342.5, run_count: 48 },
{ workflow_name: "Implement Feature", avg_duration: 287.3, run_count: 156 },
{ workflow_name: "Security Scan", avg_duration: 198.1, run_count: 312 },
{ workflow_name: "Fix Build", avg_duration: 145.7, run_count: 482 },
{ workflow_name: "Sync Drift", avg_duration: 89.2, run_count: 94 },
{ workflow_name: "Dependency Audit", avg_duration: 67.4, run_count: 201 },
],
elapsed: 0.531,
rowsRead: 5182366,
bytesRead: 357780000,
rowsReturned: 6,
};
}
if (lowerSql.includes("failure_rate") || lowerSql.includes("failed")) {
return {
columns: ["day", "failures", "total", "failure_rate"],
rows: Array.from({ length: 14 }, (_, i) => {
const d = new Date();
d.setDate(d.getDate() - i);
const total = 80 + Math.floor(Math.random() * 60);
const failures = Math.floor(Math.random() * 15);
return {
day: d.toISOString().slice(0, 10),
failures,
total,
failure_rate: Math.round((1000 * failures) / total) / 10,
};
}),
elapsed: 0.287,
rowsRead: 2841092,
bytesRead: 198400000,
rowsReturned: 14,
};
}
return {
columns: ["repo", "runs", "total_additions", "total_deletions"],
rows: [
{ repo: "fabro-engine", runs: 482, total_additions: 28450, total_deletions: 12300 },
{ repo: "fabro-web", runs: 356, total_additions: 19200, total_deletions: 8900 },
{ repo: "fabro-cli", runs: 198, total_additions: 8700, total_deletions: 4200 },
{ repo: "fabro-docs", runs: 145, total_additions: 12100, total_deletions: 3400 },
{ repo: "fabro-sdk", runs: 89, total_additions: 5600, total_deletions: 2100 },
{ repo: "fabro-infra", runs: 67, total_additions: 3200, total_deletions: 1800 },
{ repo: "fabro-actions", runs: 42, total_additions: 2100, total_deletions: 980 },
{ repo: "fabro-proto", runs: 28, total_additions: 1400, total_deletions: 650 },
],
elapsed: 0.148,
rowsRead: 1204588,
bytesRead: 89200000,
rowsReturned: 8,
};
}
/**
* Synchronizes the mock Insights query runner with the browser timer queue.
* Starting a new run clears any pending timer, and the active timer is cleared
* on unmount so stale completions cannot update React state.
*/
export function useInsightsQueryRunner(initialSql: string) {
const [result, setResult] = useState<QueryResult | null>(() =>
generateMockResult(initialSql),
);
const [isRunning, setIsRunning] = useState(false);
const runRequestIdRef = useRef(0);
const runTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
const clearPendingRun = useCallback(() => {
if (runTimeoutRef.current !== null) {
clearTimeout(runTimeoutRef.current);
runTimeoutRef.current = null;
}
}, []);
const runQuery = useCallback((sql: string) => {
const requestId = runRequestIdRef.current + 1;
runRequestIdRef.current = requestId;
clearPendingRun();
setIsRunning(true);
const delay = 200 + Math.random() * 400;
runTimeoutRef.current = setTimeout(() => {
if (runRequestIdRef.current !== requestId) return;
runTimeoutRef.current = null;
setResult(generateMockResult(sql));
setIsRunning(false);
}, delay);
}, [clearPendingRun]);
useEffect(() => {
return () => {
runRequestIdRef.current += 1;
clearPendingRun();
};
}, [clearPendingRun]);
return { result, isRunning, runQuery };
}