mirror of
https://github.com/supabase/supabase.git
synced 2026-09-06 09:59:03 +08:00
d153bab849
## What PR 6 of the SQL editor state re-layering stack. Moves ephemeral, never-persisted SQL editor state out of the snippet/folder "god store". **Session store** — `state/sql-editor/sql-editor-session-state.ts` holds per-snippet, read-by-many session state: - query `results` - `explainResults` - the row `limit` …with their mutators (`addResult`/`addResultError`/`resetResult`, `addExplainResult`/`addExplainResultError`/`resetExplainResult`, `resetResults`, `setLimit`). `removeSnippet` drops a snippet's session entries via `clearForSnippet(id)`. **Diff-request slice** — `state/sql-editor/sql-editor-diff-request.ts`. The Assistant's "Insert code" / "Replace code" diff is *not* per-snippet session state: it's a transient, fire-and-forget command produced outside the editor (e.g. query blocks / assistant) and consumed exactly once by whichever editor is active. It's modeled as a consume-once request (`requestDiff` / `consumeDiffRequest`) rather than durable state — the editor drains it on apply, so a stale diff can't leak into a later editor or session. (Previously this was `diffContent` in the god store: never cleared and triggered by object-reference identity.) Consumers read session state from `useSqlEditorSessionSnapshot` and the diff channel from `useSqlEditorDiffRequestSnapshot`, keeping `useSqlEditorV2StateSnapshot` only for snippets/folders. ### Why not the TanStack Query cache for results/explain? Editor execution is a **mutation**, not a keyed query — `mutation.data` is per-hook-instance and not keyed by snippet id, and there's no caching value to capture (re-running SQL must return *fresh* data, never a cached result). `EXPLAIN ANALYZE` actually executes the statement, so a declarative/auto-refetching `useQuery` is semantically wrong. Results/explain are imperative mutation outputs, scoped to the session, read by several decoupled consumers keyed by snippet id — exactly what a small in-memory keyed store models honestly. ## Consumers migrated - `SQLEditor.tsx` — results/explain/limit reads + `addResult`/`addResultError`/`addExplainResult`/`addExplainResultError`/`setLimit`; diff-apply effect now drains a consume-once request - `UtilityPanel.tsx`, `UtilityTabResults.tsx`, `UtilityTabExplain.tsx`, `UtilityActions.tsx` - `QueryBlock/EditQueryButton.tsx` — produces via `requestDiff` ## Notes - Result/explain types are kept verbatim from the god store (pre-existing `any` row/error types come along unchanged; tightening them is out of scope for this move). - `ref()` on result rows is preserved to avoid Valtio proxying large row sets. ## Tests - `sql-editor-session-state.test.ts` — result/explain mutators, `resetResults`, `clearForSnippet`, `limit` - `sql-editor-diff-request.test.ts` — `requestDiff`, `consumeDiffRequest` (drain + queue-of-one) Validation: - `pnpm --filter studio typecheck` ✅ - `pnpm exec vitest --run state/sql-editor/` ✅ (110 passed) - lint ✅ (no new errors) <!-- This is an auto-generated comment: release notes by coderabbit.ai --> ## Summary by CodeRabbit * **New Features** * SQL editor query results, EXPLAIN output, and the “Limit results to” setting now persist more reliably across a session. * AI-assisted SQL insert/replace actions now use a pending diff workflow to apply updates more consistently. * **Bug Fixes** * Results/EXPLAIN rendering and downloads stay in sync with the latest executed data. * Switching databases/snippets now clears the correct temporary results. * Diff application is more resilient when an editor is still loading, including empty-vs-non-empty editor cases. * **Tests** * Added coverage for the session and diff-request state logic. <!-- end of auto-generated comment: release notes by coderabbit.ai --> --------- Co-authored-by: Joshen Lim <joshenlimek@gmail.com>
33 lines
1.3 KiB
TypeScript
33 lines
1.3 KiB
TypeScript
import { proxy, useSnapshot } from 'valtio'
|
|
|
|
import { DiffType } from '@/components/interfaces/SQLEditor/SQLEditor.types'
|
|
|
|
/**
|
|
* A one-shot request to render a SQL diff in the active SQL editor.
|
|
*
|
|
* Unlike the session store (per-snippet results that many components read
|
|
* repeatedly), this is a transient command: it is produced outside the editor
|
|
* — e.g. the Assistant's "Insert code" / "Replace code" actions — and consumed
|
|
* exactly once by the editor. It targets whichever editor is active, not a
|
|
* particular snippet. It is drained on consumption rather than stored, so a
|
|
* stale request can never leak into a later editor or editing session.
|
|
*/
|
|
export const sqlEditorDiffRequestState = proxy({
|
|
pending: undefined as undefined | { sql: string; diffType: DiffType },
|
|
|
|
/** Queue a diff to be applied to the active editor. */
|
|
requestDiff: (sql: string, diffType: DiffType) => {
|
|
sqlEditorDiffRequestState.pending = { sql, diffType }
|
|
},
|
|
|
|
/** Read and clear the pending request, returning it (or undefined if none). */
|
|
consumeDiffRequest: () => {
|
|
const request = sqlEditorDiffRequestState.pending
|
|
sqlEditorDiffRequestState.pending = undefined
|
|
return request
|
|
},
|
|
})
|
|
|
|
export const useSqlEditorDiffRequestSnapshot = (options?: Parameters<typeof useSnapshot>[1]) =>
|
|
useSnapshot(sqlEditorDiffRequestState, options)
|