@rebasepro/studio 0.21.2-canary.g1ea48be → 0.23.0

package/dist/{SQLEditor-sdtoZv5F.js → SQLEditor-TBw_K6CW.js}

@@ -1,11 +1,11 @@
-import { t as MonacoEditor } from "./MonacoEditor-D0_QljcX.js";
+import { t as MonacoEditor } from "./MonacoEditor-CUxy5_k5.js";
 import { ConfirmationDialog, ErrorView, IconForView, useRebaseContext, useSnackbarController, useStudioCollectionRegistry, useStudioSidePanelController, useTranslation } from "@rebasepro/app";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Button, Checkbox, CircularProgress, Collapse, CopyIcon, DatabaseIcon, Dialog, DialogActions, DialogContent, DialogTitle, IconButton, Menu, MenuIcon, MenuItem, MoreVerticalIcon, PencilIcon, PlayIcon, PlusIcon, RefreshCwIcon, ResizablePanels, Tab, Tabs, TerminalIcon, TextField, TextareaAutosize, Tooltip, Trash2Icon, Typography, VirtualTable, XIcon, cls, defaultBorderMixin, iconSize } from "@rebasepro/ui";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { isArrayValue, isRecordValue, readStoredJson, readStoredString, toSnakeCase, writeStoredJson, writeStoredString } from "@rebasepro/utils";
 import { createPortal } from "react-dom";
-import { parseFirst } from "pgsql-ast-parser";
+import { parse, parseFirst } from "pgsql-ast-parser";
 //#region src/components/SQLEditor/SchemaBrowser.tsx
 var SchemaBrowser = ({ onTableClick, schemas, isSchemaLoading, schemaError, onRetrySchema }) => {
 	const [expandedSchemas, setExpandedSchemas] = useState({ public: true });
@@ -393,6 +393,181 @@ var SQLEditorSidebar = ({ onSelectSnippet, onTableClick, snippets, history, onDe
 };
 //#endregion
 //#region src/utils/sql_utils.ts
+/** The statements in `sqlText`, or `null` when the parser cannot read it. */
+function parseStatements(sqlText) {
+	try {
+		return parse(sqlText);
+	} catch {
+		return null;
+	}
+}
+/**
+* The `EXPLAIN` for one statement, or `null` when `sqlText` is not exactly one.
+*
+* Never `ANALYZE`: that executes the statement to time it, so explaining a
+* `DELETE` deleted the rows — without the confirmation "Run" asks for.
+*
+* And never more than one statement. Sent as one simple query, `EXPLAIN (…)
+* SELECT 1; DELETE …` explains the SELECT and *runs* the DELETE. Text the
+* parser cannot read is still explained, as long as no `;` could be hiding a
+* second statement in it.
+*/
+function buildExplainSql(sqlText) {
+	const statement = sqlText.trim().replace(/;+$/, "").trim();
+	if (!statement) return null;
+	const statements = parseStatements(statement);
+	return (statements ? statements.length === 1 : !statement.includes(";")) ? `EXPLAIN (FORMAT JSON) ${statement}` : null;
+}
+/**
+* Whether the console's automatic `LIMIT` may be appended to `sqlText`: one
+* top-level SELECT that has no limit of its own.
+*
+* Decided on the parsed statement, not the text. A search for the word SELECT
+* also found it inside `INSERT INTO … SELECT` and `CREATE TABLE … AS SELECT`,
+* which then copied a thousand rows and reported success, and at the start of
+* a script whose last statement the appended `LIMIT` turned into a syntax
+* error. Text the parser cannot read is left as written.
+*/
+function acceptsAutoLimit(sqlText) {
+	const statements = parseStatements(sqlText);
+	if (!statements || statements.length !== 1) return false;
+	const [statement] = statements;
+	return statement.type === "select" && !statement.limit;
+}
+/** A destructive command named anywhere in a text, comments included. */
+var DESTRUCTIVE_COMMAND = /\b(DELETE|UPDATE|DROP|TRUNCATE)\b/i;
+function isDestructiveStatement(statement) {
+	switch (statement.type) {
+		case "delete":
+		case "update": return !statement.where;
+		case "truncate table":
+		case "drop table":
+		case "drop sequence":
+		case "drop index":
+		case "drop type":
+		case "drop trigger":
+		case "drop function": return true;
+		case "alter table": return statement.changes.some((change) => change.type === "drop column" || change.type === "drop constraint");
+		case "with": return statement.bind.some((binding) => isDestructiveStatement(binding.statement)) || isDestructiveStatement(statement.in);
+		case "with recursive": return isDestructiveStatement(statement.in);
+		case "do": return DESTRUCTIVE_COMMAND.test(statement.code);
+		default: return false;
+	}
+}
+/**
+* Whether "Run" asks before running `sqlText`: a statement in it deletes or
+* updates without a WHERE of its own, drops or truncates.
+*
+* Decided per parsed statement, not on the text. A search of the text for the
+* word WHERE found it in another statement or in a comment, so `DELETE FROM
+* posts; SELECT * FROM posts WHERE id = 1` deleted every post without asking.
+* Text the parser cannot read is confirmed whenever it names a destructive
+* command.
+*/
+function needsDestructiveConfirmation(sqlText) {
+	const statements = parseStatements(sqlText);
+	if (!statements) return DESTRUCTIVE_COMMAND.test(sqlText);
+	return statements.some(isDestructiveStatement);
+}
+/**
+* A table as SQL: `"schema"."table"` when the query named its schema, and a
+* bare `"table"` when it left it to the search path — which then resolves it
+* the same way it resolved the query.
+*/
+function quoteTableName(tableName, schemaName) {
+	const quote = (identifier) => `"${identifier.replace(/"/g, "\"\"")}"`;
+	return schemaName ? `${quote(schemaName)}.${quote(tableName)}` : quote(tableName);
+}
+/**
+* The introspected columns of a table the query named — in the schema it
+* named, when it named one. Unqualified, the first schema that has a table of
+* that name answers.
+*/
+function findTableInfo(schemas, table) {
+	if (table.schema) return schemas[table.schema]?.find((t) => t.tableName === table.name);
+	for (const schema of Object.values(schemas)) {
+		const tableInfo = schema.find((t) => t.tableName === table.name);
+		if (tableInfo) return tableInfo;
+	}
+}
+/**
+* The name Postgres gives the result column of an unaliased select item, as
+* far as it can be told from the expression: a column keeps its name, a cast
+* the name of what it casts, a function call the function's, and anything
+* else a name no table column has.
+*/
+function expressionColumnName(expr) {
+	switch (expr.type) {
+		case "ref": return expr.name;
+		case "cast": {
+			const operandName = expressionColumnName(expr.operand);
+			if (operandName !== "?column?") return operandName;
+			return expr.to.kind === "array" ? operandName : expr.to.name;
+		}
+		case "call": return expr.function.name;
+		case "keyword": return expr.keyword;
+		case "case": return "case";
+		case "array select": return "array";
+		case "select": {
+			const [first] = expr.columns ?? [];
+			return first ? selectedColumnName(first) : "?column?";
+		}
+		default: return "?column?";
+	}
+}
+function selectedColumnName(column) {
+	return column.alias?.name ?? expressionColumnName(column.expr);
+}
+/**
+* How many columns of the query's result may carry `name` — an upper bound:
+* a `*` over a source whose columns are not known counts once for every name.
+*
+* A result row is an object keyed by column name, so where two columns share
+* a name the row holds only the last of them. A key or a value read from such
+* a row cannot be told apart from its namesake: for `SELECT * FROM posts p
+* JOIN authors a …` the row's `id` is the author's.
+*/
+function resultColumnCounter(ast, schemas) {
+	const sources = (ast.from ?? []).map((item) => {
+		if (item.type === "table") {
+			const renamed = item.name.columnNames ?? [];
+			const columns = findTableInfo(schemas, {
+				name: item.name.name,
+				schema: item.name.schema
+			})?.columns.map((c, i) => renamed[i]?.name ?? c.name);
+			return {
+				refName: item.name.alias ?? item.name.name,
+				columns
+			};
+		}
+		if (item.type === "statement") {
+			const { statement } = item;
+			const named = statement.type === "select" && (statement.columns ?? []).every((c) => !(c.expr.type === "ref" && c.expr.name === "*"));
+			const renamed = item.columnNames ?? [];
+			const columns = named && statement.type === "select" ? (statement.columns ?? []).map((c, i) => renamed[i]?.name ?? selectedColumnName(c)) : void 0;
+			return {
+				refName: item.alias,
+				columns
+			};
+		}
+		return {
+			refName: item.alias?.name,
+			columns: void 0
+		};
+	});
+	return (name) => {
+		let count = 0;
+		for (const column of ast.columns ?? []) {
+			const expr = column.expr;
+			if (expr.type === "ref" && expr.name === "*") {
+				const covered = expr.table ? sources.filter((source) => source.refName === expr.table?.name) : sources;
+				if (covered.length === 0) count += 1;
+				for (const source of covered) count += source.columns ? source.columns.filter((c) => c === name).length : 1;
+			} else if (selectedColumnName(column) === name) count += 1;
+		}
+		return count;
+	};
+}
 /**
 * Extract all tables referenced in a SQL query's FROM and JOIN clauses.
 * Returns an empty array for non-SELECT queries or parse failures.
@@ -406,6 +581,7 @@ function extractTablesFromQuery(sqlString) {
 			for (const item of fromItems) {
 				if (item.type === "table" && item.name) tables.push({
 					name: item.name.name,
+					schema: item.name.schema,
 					alias: item.name.alias
 				});
 				if (item.type === "join") {
@@ -434,10 +610,12 @@ function resolveQueryCollections(sqlString, schemas, collections, resultColumns)
 	const tables = extractTablesFromQuery(sqlString);
 	if (tables.length === 0) return [];
 	const selectColumns = [];
+	let countResultColumns;
 	try {
 		const ast = parseFirst(sqlString);
-		if (ast.type === "select" && ast.columns) {
-			for (const col of ast.columns) if (col.expr?.type === "ref") selectColumns.push({
+		if (ast.type === "select") {
+			countResultColumns = resultColumnCounter(ast, schemas);
+			for (const col of ast.columns ?? []) if (col.expr?.type === "ref") selectColumns.push({
 				table: col.expr.table?.name,
 				column: col.expr.name,
 				alias: col.alias?.name
@@ -447,17 +625,12 @@ function resolveQueryCollections(sqlString, schemas, collections, resultColumns)
 	const results = [];
 	for (const table of tables) {
 		const matched = collections.find((c) => {
-			return (("table" in c ? c.table : void 0) || toSnakeCase(c.slug)) === table.name;
+			const tableName = ("table" in c ? c.table : void 0) || toSnakeCase(c.slug);
+			const schemaName = ("schema" in c ? c.schema : void 0) || "public";
+			return tableName === table.name && (!table.schema || table.schema === schemaName);
 		});
 		if (!matched) continue;
-		const tableColumns = [];
-		for (const schemaEntries of Object.values(schemas)) {
-			const tableInfo = schemaEntries.find((t) => t.tableName === table.name);
-			if (tableInfo) {
-				tableColumns.push(...tableInfo.columns.map((c) => c.name));
-				break;
-			}
-		}
+		const tableColumns = findTableInfo(schemas, table)?.columns.map((c) => c.name) ?? [];
 		let pkColumn;
 		const tableRef = table.alias || table.name;
 		const idSelectCol = selectColumns.find((sc) => sc.column === "id" && (!sc.table || sc.table === tableRef || sc.table === table.name));
@@ -466,6 +639,7 @@ function resolveQueryCollections(sqlString, schemas, collections, resultColumns)
 			if (resultColumns.includes("id")) pkColumn = "id";
 		}
 		if (!pkColumn && tableColumns.includes("id")) pkColumn = "id";
+		if (pkColumn && (!countResultColumns || countResultColumns(pkColumn) > 1)) pkColumn = void 0;
 		results.push({
 			tableName: table.name,
 			tableAlias: table.alias,
@@ -493,37 +667,25 @@ function determineTableAndPK(sqlString, columnKey, schemas) {
 		const resolvedColumn = selectColumns.find((sc) => sc.alias === columnKey || !sc.alias && sc.column === columnKey);
 		const actualDbColumnName = resolvedColumn?.column ?? columnKey;
 		const columnTableRef = resolvedColumn?.table;
-		let resolvedTableName = null;
-		if (tables.length === 1) resolvedTableName = tables[0].name;
+		let resolvedTable = null;
+		if (tables.length === 1) resolvedTable = tables[0];
 		else {
 			if (columnTableRef) {
 				const matchedTable = tables.find((t) => t.alias === columnTableRef || t.name === columnTableRef);
-				if (matchedTable) resolvedTableName = matchedTable.name;
+				if (matchedTable) resolvedTable = matchedTable;
 			}
-			if (!resolvedTableName) {
-				const matchedTables = tables.filter((t) => {
-					for (const schema of Object.values(schemas)) {
-						const tableInfo = schema.find((ti) => ti.tableName === t.name);
-						if (tableInfo && tableInfo.columns.some((c) => c.name === actualDbColumnName)) return true;
-					}
-					return false;
-				});
-				if (matchedTables.length === 1) resolvedTableName = matchedTables[0].name;
+			if (!resolvedTable) {
+				const matchedTables = tables.filter((t) => findTableInfo(schemas, t)?.columns.some((c) => c.name === actualDbColumnName) ?? false);
+				if (matchedTables.length === 1) resolvedTable = matchedTables[0];
 				else if (matchedTables.length > 1) return { error: `Ambiguous column "${columnKey}": Found in multiple queried tables.` };
 				else return { error: `Could not find column "${columnKey}" in the queried tables.` };
 			}
 		}
-		if (!resolvedTableName) return { error: "Could not resolve the target table." };
-		let pkDbColumns = [];
-		for (const schema of Object.values(schemas)) {
-			const tableInfo = schema.find((t) => t.tableName === resolvedTableName);
-			if (tableInfo) {
-				pkDbColumns = tableInfo.columns.filter((c) => c.isPrimaryKey).map((c) => c.name);
-				break;
-			}
-		}
+		if (!resolvedTable) return { error: "Could not resolve the target table." };
+		const resolvedTableName = resolvedTable.name;
+		const pkDbColumns = (findTableInfo(schemas, resolvedTable)?.columns ?? []).filter((c) => c.isPrimaryKey).map((c) => c.name);
 		if (pkDbColumns.length === 0) return { error: `Table "${resolvedTableName}" has no primary key defined.` };
-		const tableAlias = tables.find((t) => t.name === resolvedTableName)?.alias;
+		const tableAlias = resolvedTable.alias;
 		const primaryKeys = pkDbColumns.map((dbCol) => {
 			const selectCol = selectColumns.find((sc) => sc.column === dbCol && (!sc.table || sc.table === (tableAlias || resolvedTableName)));
 			return {
@@ -531,8 +693,13 @@ function determineTableAndPK(sqlString, columnKey, schemas) {
 				resultColumn: selectCol?.alias || selectCol?.column || dbCol
 			};
 		});
+		const countResultColumns = resultColumnCounter(ast, schemas);
+		if (countResultColumns(columnKey) > 1) return { error: `Ambiguous column "${columnKey}": the result has more than one column of that name. Give each one its own alias to edit it.` };
+		const sharedKey = primaryKeys.find((pk) => countResultColumns(pk.resultColumn) > 1);
+		if (sharedKey) return { error: `Cannot tell which "${sharedKey.resultColumn}" column is the key of "${resolvedTableName}": the result has more than one column of that name. Give it its own alias (${tableAlias || resolvedTableName}.${sharedKey.dbColumn} AS ${resolvedTableName}_${sharedKey.dbColumn}) to edit this table.` };
 		return {
 			tableName: resolvedTableName,
+			schemaName: resolvedTable.schema,
 			primaryKeys
 		};
 	} catch (e) {
@@ -805,7 +972,8 @@ var SQLEditor = () => {
 			loading: false,
 			error: null,
 			execTime: null,
-			lastExecutedSql: null
+			lastExecutedSql: null,
+			lastExecutedConnection: null
 		}));
 		if (restored.length > 0) return restored;
 		return [{
@@ -818,7 +986,8 @@ var SQLEditor = () => {
 			loading: false,
 			error: null,
 			execTime: null,
-			lastExecutedSql: null
+			lastExecutedSql: null,
+			lastExecutedConnection: null
 		}];
 	});
 	const [activeTabId, setActiveTabId] = useState(() => {
@@ -1032,6 +1201,7 @@ var SQLEditor = () => {
 	const [isConfirmDialogOpen, setIsConfirmDialogOpen] = useState(false);
 	const [pendingAction, setPendingAction] = useState(null);
 	const [editingCell, setEditingCell] = useState(null);
+	const isCurrentConnection = useCallback((connection) => connection !== null && connection.database === selectedDatabase && connection.role === selectedRole, [selectedDatabase, selectedRole]);
 	const handleDoubleClick = useCallback((rowIndex, columnKey, initialValue, rowData) => {
 		if (!activeTab.lastExecutedSql) {
 			snackbarController.open({
@@ -1040,6 +1210,13 @@ var SQLEditor = () => {
 			});
 			return;
 		}
+		if (!isCurrentConnection(activeTab.lastExecutedConnection)) {
+			snackbarController.open({
+				type: "error",
+				message: t("studio_sql_cannot_edit_other_connection")
+			});
+			return;
+		}
 		const resolution = determineTableAndPK(activeTab.lastExecutedSql, columnKey, schemas);
 		if (resolution.error || !resolution.primaryKeys || resolution.primaryKeys.length === 0) {
 			snackbarController.open({
@@ -1063,13 +1240,24 @@ var SQLEditor = () => {
 		});
 	}, [
 		activeTab.lastExecutedSql,
+		activeTab.lastExecutedConnection,
+		isCurrentConnection,
 		schemas,
-		snackbarController
+		snackbarController,
+		t
 	]);
 	const handleCellSave = useCallback(async (newValue, rowData, columnKey, rowIndex) => {
 		if (!editingCell || !activeTab.lastExecutedSql) return;
 		setEditingCell(null);
 		if (newValue === editingCell.initialValue) return;
+		const connection = activeTab.lastExecutedConnection;
+		if (!isCurrentConnection(connection)) {
+			snackbarController.open({
+				type: "error",
+				message: t("studio_sql_cannot_edit_other_connection")
+			});
+			return;
+		}
 		const resolution = determineTableAndPK(activeTab.lastExecutedSql, columnKey, schemas);
 		if (resolution.error || !resolution.tableName || !resolution.primaryKeys || resolution.primaryKeys.length === 0) {
 			snackbarController.open({
@@ -1078,7 +1266,7 @@ var SQLEditor = () => {
 			});
 			return;
 		}
-		const tableName = resolution.tableName;
+		const tableName = quoteTableName(resolution.tableName, resolution.schemaName);
 		const formatValue = (val) => {
 			if (val === null || val === void 0) return "NULL";
 			if (typeof val === "number") return val;
@@ -1100,12 +1288,12 @@ var SQLEditor = () => {
 		};
 		const dbColumnName = resolveDbColumnName(columnKey);
 		const whereConditions = resolution.primaryKeys.map((pk) => `"${pk.dbColumn}" = ${formatValue(rowData[pk.resultColumn])}`).join(" AND ");
-		const updateSql = `UPDATE "${tableName}" SET "${dbColumnName}" = ${formatValue(newValue)} WHERE ${whereConditions};`;
+		const updateSql = `UPDATE ${tableName} SET "${dbColumnName}" = ${formatValue(newValue)} WHERE ${whereConditions};`;
 		try {
 			if (databaseAdmin?.executeSql) {
 				await databaseAdmin.executeSql(updateSql, {
-					database: selectedDatabase,
-					role: selectedRole
+					database: connection.database,
+					role: connection.role
 				});
 				const newResults = [...activeTab.results || []];
 				if (newResults[rowIndex]) newResults[rowIndex] = {
@@ -1128,12 +1316,13 @@ var SQLEditor = () => {
 		editingCell,
 		schemas,
 		activeTab.lastExecutedSql,
+		activeTab.lastExecutedConnection,
 		activeTab.results,
+		isCurrentConnection,
 		databaseAdmin,
 		updateActiveTab,
 		snackbarController,
-		selectedDatabase,
-		selectedRole
+		t
 	]);
 	const [columnWidths, setColumnWidths] = useState(() => {
 		return readStoredJson(`rebase_sql_column_widths_${client?.baseUrl ? client.baseUrl.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9]/g, "_") : "default"}`, {
@@ -1200,7 +1389,8 @@ var SQLEditor = () => {
 			loading: false,
 			error: null,
 			execTime: null,
-			lastExecutedSql: null
+			lastExecutedSql: null,
+			lastExecutedConnection: null
 		}]);
 		setActiveTabId(newId);
 	};
@@ -1232,12 +1422,23 @@ var SQLEditor = () => {
 		const formatted = activeTab.sql.replace(/\s+/g, " ").replace(/\s?,\s?/g, ", ").replace(/\s?=\s?/g, " = ").trim();
 		setSql(formatted);
 	};
+	/** The editor, for the selection the toolbar's buttons act on. */
+	const editorHandle = useRef(null);
 	const handleExplain = async () => {
-		const explainSql = `EXPLAIN (FORMAT JSON, ANALYZE) ${activeTab.sql}`;
+		const explainSql = buildExplainSql(editorHandle.current?.getSelectedText() ?? activeTab.sql);
+		if (!explainSql) {
+			updateActiveTab({
+				results: null,
+				error: t("studio_sql_explain_single_statement")
+			});
+			return;
+		}
 		updateActiveTab({
 			loading: true,
 			error: null,
-			results: null
+			results: null,
+			lastExecutedSql: null,
+			lastExecutedConnection: null
 		});
 		const start = performance.now();
 		try {
@@ -1260,10 +1461,8 @@ var SQLEditor = () => {
 	};
 	const executeRun = useCallback(async (sqlOverride) => {
 		let sqlToRun = sqlOverride || activeTab.sql;
-		const upperSql = sqlToRun.toUpperCase();
 		const isAggregate = /\b(COUNT|SUM|AVG|MIN|MAX)\s*\(/i.test(sqlToRun);
-		const isExplain = /\bEXPLAIN\b/i.test(sqlToRun);
-		if (autoLimit && upperSql.includes("SELECT") && !upperSql.includes("LIMIT") && !isAggregate && !isExplain) {
+		if (autoLimit && acceptsAutoLimit(sqlToRun) && !isAggregate) {
 			sqlToRun = sqlToRun.trim().replace(/;$/, "");
 			sqlToRun = `${sqlToRun} LIMIT 1000;`;
 		}
@@ -1282,7 +1481,11 @@ var SQLEditor = () => {
 				updateActiveTab({
 					results: result,
 					execTime: Math.round(performance.now() - start),
-					lastExecutedSql: sqlToRun
+					lastExecutedSql: sqlToRun,
+					lastExecutedConnection: {
+						database: selectedDatabase,
+						role: selectedRole
+					}
 				});
 				if (history[history.length - 1] !== activeTab.sql) saveHistory([...history, activeTab.sql]);
 			} else updateActiveTab({ error: t("studio_sql_execution_not_supported") });
@@ -1304,14 +1507,7 @@ var SQLEditor = () => {
 	const handleRun = useCallback(async (selectedText) => {
 		const sqlTarget = selectedText || activeTab.sql;
 		if (!sqlTarget.trim()) return;
-		const hasDestructive = [
-			"DELETE",
-			"DROP",
-			"TRUNCATE",
-			"UPDATE"
-		].some((kw) => sqlTarget.toUpperCase().includes(kw));
-		const hasWhere = sqlTarget.toUpperCase().includes("WHERE");
-		if (hasDestructive && (!hasWhere || sqlTarget.toUpperCase().includes("DROP") || sqlTarget.toUpperCase().includes("TRUNCATE"))) {
+		if (needsDestructiveConfirmation(sqlTarget)) {
 			setPendingAction(() => () => executeRun(selectedText));
 			setIsConfirmDialogOpen(true);
 			return;
@@ -1325,7 +1521,7 @@ var SQLEditor = () => {
 				const isInput = activeElement?.tagName === "INPUT" || activeElement?.tagName === "TEXTAREA";
 				if (!activeElement?.className?.includes("monaco-mouse-cursor-text") && !isInput) {
 					e.preventDefault();
-					handleRun();
+					handleRun(editorHandle.current?.getSelectedText());
 				}
 			}
 		};
@@ -1876,7 +2072,7 @@ var SQLEditor = () => {
 									})
 								}),
 								/* @__PURE__ */ jsxs(Button, {
-									onClick: () => handleRun(),
+									onClick: () => handleRun(editorHandle.current?.getSelectedText()),
 									disabled: loading,
 									size: "small",
 									color: "primary",
@@ -1898,6 +2094,7 @@ var SQLEditor = () => {
 						firstPanel: /* @__PURE__ */ jsx("div", {
 							className: "h-full w-full relative flex flex-col min-h-0",
 							children: /* @__PURE__ */ jsx(MonacoEditor, {
+								ref: editorHandle,
 								value: sql,
 								onChange: (v) => setSql(v || ""),
 								onRun: handleRun,
@@ -1974,4 +2171,4 @@ var SQLEditor = () => {
 //#endregion
 export { SQLEditor };
 
-//# sourceMappingURL=SQLEditor-sdtoZv5F.js.map
+//# sourceMappingURL=SQLEditor-TBw_K6CW.js.map