mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-21 16:03:46 +00:00
Snowflake is a built-in data source kind: connection dialog, key-pair, browser single sign-on, password or token sign-in, the database tree, SQL consoles, and Snowflake-aware SQL assistance and syntax colours. The driver speaks Snowflake's session protocol over the existing reqwest + rustls stack, with no JDBC/ODBC or native library and no new package. Metadata is read with SHOW / DESCRIBE, which need no running warehouse; introspected names are kept on disk for completion. Co-authored-by: vvnadolskyy <12991410+vvnadolskyy@users.noreply.github.com>
492 lines
16 KiB
TypeScript
492 lines
16 KiB
TypeScript
/**
|
||
* Actions of the Database tool window (IDEA's Database view actions): they
|
||
* act on the node passed as the argument (context menus) or on the tree's
|
||
* lead node (toolbar, shortcuts while the tree has focus).
|
||
*/
|
||
import { introspectSource } from "./introspection";
|
||
import { writeClipboardText } from "@/platform/clipboard";
|
||
import { call, commands, type DataSource, type DbDriver, type DbTableInfo } from "@/platform/ipc";
|
||
import { registerActions, type Action } from "@/platform/actions";
|
||
import { editorService, notifications, showServiceView, toolWindowService } from "@/workbench/contributions";
|
||
import { splitTarget } from "./model";
|
||
import { nodeTarget, objectOf, schemaObjectOf, tableFolder, tableOf, type DbNode } from "./nodes";
|
||
import { canDrop, canModifyTable, canRename, reference, scriptSql, type ScriptKind } from "./objects";
|
||
import {
|
||
DB_TOOL_WINDOW,
|
||
OUTPUT_TAB,
|
||
RESULTS_VIEW,
|
||
detailsKey,
|
||
disconnect,
|
||
duplicateSource,
|
||
loadDetails,
|
||
loadSchemas,
|
||
loadSources,
|
||
loadTables,
|
||
openConsole,
|
||
openConsoleWith,
|
||
openDdl,
|
||
openObjectDdl,
|
||
openDialog,
|
||
openSourceDialog,
|
||
readableDdl,
|
||
refresh,
|
||
revealInTree,
|
||
runSql,
|
||
sourceById,
|
||
tablesKey,
|
||
toggleSeparateProceduresAndFunctions,
|
||
useDatabase,
|
||
withConnection,
|
||
removeSource,
|
||
} from "./store";
|
||
import { tableInput } from "./tableInput";
|
||
import { tx } from "@/platform/i18n";
|
||
|
||
/** Context key: the Database tree has focus. */
|
||
export const DB_VIEW_FOCUS = "databaseViewFocus";
|
||
const OPEN = "projectOpen";
|
||
|
||
const isNode = (v: unknown): v is DbNode => !!v && typeof v === "object" && "kind" in v && "key" in v;
|
||
|
||
/** The node an action runs on: its argument, else the tree's lead node. */
|
||
function nodeFrom(arg: unknown): DbNode | null {
|
||
return isNode(arg) ? arg : useDatabase.getState().selectedNode;
|
||
}
|
||
|
||
function driverOf(id: string): DbDriver {
|
||
return sourceById(id)?.driver ?? "sqlite";
|
||
}
|
||
|
||
function sourceOf(n: DbNode | null): DataSource | undefined {
|
||
return n ? sourceById(nodeTarget(n)) : undefined;
|
||
}
|
||
|
||
/** Copies `text`; `failure` is the notification title when the clipboard refuses it. */
|
||
async function copy(text: string, failure: string) {
|
||
try {
|
||
await writeClipboardText(text);
|
||
} catch {
|
||
notifications().notify({ level: "error", title: failure });
|
||
}
|
||
}
|
||
|
||
/** Where Quick Documentation opens: below the tree's selected row. */
|
||
function rowAnchor(): { x: number; y: number } {
|
||
const row = document.querySelector(
|
||
'[role="tree"][aria-label="Data sources"] [role="treeitem"][aria-selected="true"]',
|
||
);
|
||
const r = row?.getBoundingClientRect();
|
||
return r ? { x: r.left + 24, y: r.bottom + 2 } : { x: window.innerWidth / 2, y: window.innerHeight / 3 };
|
||
}
|
||
|
||
export function openTableData(id: string, schema: string, table: string) {
|
||
void editorService().openInput(tableInput(id, schema, table), { focus: true });
|
||
}
|
||
|
||
/** Tables of a schema, loading them if needed. */
|
||
async function tablesIn(id: string, schema: string): Promise<DbTableInfo[]> {
|
||
if (useDatabase.getState().tables[tablesKey(id, schema)]?.status !== "ok") await loadTables(id, schema);
|
||
const l = useDatabase.getState().tables[tablesKey(id, schema)];
|
||
return l?.status === "ok" ? l.value : [];
|
||
}
|
||
|
||
/** DDL of a table / view, or of every table and view of a schema or data source. */
|
||
async function ddlOf(n: DbNode): Promise<{ id: string; text: string } | null> {
|
||
const id = nodeTarget(n);
|
||
if (!id) return null;
|
||
const one = async (schema: string, table: string) =>
|
||
readableDdl(await withConnection(id, () => call(commands.dbDdl(id, schema, table))), driverOf(id));
|
||
try {
|
||
const o = schemaObjectOf(n);
|
||
if (o)
|
||
return { id, text: await withConnection(id, () => call(commands.dbObjectDdl(id, o.schema, o.kind, o.name))) };
|
||
const t = tableOf(n);
|
||
if (t) return { id, text: await one(t.schema, t.table) };
|
||
let schemas: string[] = [];
|
||
if (n.kind === "schema" || n.kind === "folder") schemas = [n.schema];
|
||
else if (n.kind === "source" || n.kind === "database") {
|
||
if (useDatabase.getState().schemas[id]?.status !== "ok") await loadSchemas(id);
|
||
const l = useDatabase.getState().schemas[id];
|
||
schemas = l?.status === "ok" ? l.value : [];
|
||
}
|
||
const parts: string[] = [];
|
||
for (const schema of schemas) {
|
||
const tables = (await tablesIn(id, schema)).filter(
|
||
(t) => n.kind !== "folder" || tableFolder(t.kind) === n.folder,
|
||
);
|
||
// Tables before views: views select from them.
|
||
tables.sort((a, b) => Number(a.kind !== "table") - Number(b.kind !== "table"));
|
||
for (const t of tables) parts.push(await one(schema, t.name));
|
||
}
|
||
return { id, text: parts.join("\n") };
|
||
} catch (e) {
|
||
notifications().notify({
|
||
level: "error",
|
||
title: "Cannot generate the DDL",
|
||
body: e instanceof Error ? e.message : String(e),
|
||
});
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/** SQL Scripts › Select / Insert / Update / Delete templates into the console. */
|
||
export async function insertScript(n: DbNode, kind: ScriptKind) {
|
||
const t = tableOf(n);
|
||
if (!t) return;
|
||
const key = detailsKey(t.id, t.schema, t.table);
|
||
if (useDatabase.getState().details[key]?.status !== "ok") await loadDetails(t.id, t.schema, t.table);
|
||
const d = useDatabase.getState().details[key];
|
||
const columns = d?.status === "ok" ? d.value.columns : [];
|
||
try {
|
||
await openConsoleWith(t.id, scriptSql(driverOf(t.id), kind, t.schema, t.table, columns));
|
||
} catch (e) {
|
||
notifications().notify({
|
||
level: "error",
|
||
title: "Cannot generate the SQL script",
|
||
body: e instanceof Error ? e.message : String(e),
|
||
});
|
||
}
|
||
}
|
||
|
||
/** SQL Scripts › Run SQL Script…: picks a `.sql` file and runs all its statements. */
|
||
async function runScriptFile(id: string) {
|
||
const { open } = await import("@/platform/dialog");
|
||
const file = await open({
|
||
multiple: false,
|
||
directory: false,
|
||
title: "Run SQL Script",
|
||
filters: [{ name: "SQL", extensions: ["sql", "ddl"] }],
|
||
});
|
||
if (typeof file !== "string") return;
|
||
try {
|
||
const text = await call(commands.fsReadText(file));
|
||
const statements = await call(commands.dbStatements(id, text, 0, text.length));
|
||
useDatabase.setState({ activeResult: OUTPUT_TAB });
|
||
showServiceView(RESULTS_VIEW, false);
|
||
if (
|
||
await runSql(
|
||
id,
|
||
statements.map((s) => s.text),
|
||
)
|
||
)
|
||
notifications().notify({
|
||
level: "info",
|
||
title: `Script finished: ${statements.length} statement${statements.length === 1 ? "" : "s"}`,
|
||
});
|
||
} catch (e) {
|
||
notifications().notify({
|
||
level: "error",
|
||
title: "Cannot run the script",
|
||
body: e instanceof Error ? e.message : String(e),
|
||
});
|
||
}
|
||
}
|
||
|
||
function refreshNode(n: DbNode | null) {
|
||
if (!n) {
|
||
void loadSources();
|
||
for (const c of useDatabase.getState().connected) void refresh(c);
|
||
return;
|
||
}
|
||
const id = nodeTarget(n);
|
||
if (!id) return;
|
||
if (n.kind === "schema" || n.kind === "folder") void loadTables(id, n.schema);
|
||
else if (tableOf(n)) {
|
||
const t = tableOf(n)!;
|
||
void loadDetails(t.id, t.schema, t.table);
|
||
} else void refresh(id);
|
||
}
|
||
|
||
export function registerDatabaseTreeActions(): () => void {
|
||
const tree = (a: Omit<Action, "category">): Action => ({
|
||
category: "Database",
|
||
when: OPEN,
|
||
keyWhen: DB_VIEW_FOCUS,
|
||
...a,
|
||
});
|
||
return registerActions([
|
||
tree({
|
||
id: "db.properties",
|
||
title: "Data Source Properties…",
|
||
icon: "db-properties",
|
||
keywords: ["data sources", "connection settings"],
|
||
run: ({ arg }) => {
|
||
const src = sourceOf(nodeFrom(arg));
|
||
const { sources } = useDatabase.getState();
|
||
openSourceDialog(src ?? (sources.length === 1 ? sources[0]! : null));
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.refresh",
|
||
title: "Refresh",
|
||
icon: "refresh",
|
||
keywords: ["synchronize", "introspect"],
|
||
run: ({ arg }) => refreshNode(nodeFrom(arg)),
|
||
}),
|
||
tree({
|
||
id: "db.introspect",
|
||
title: "Introspect All Databases",
|
||
icon: "refresh",
|
||
keywords: ["snowflake", "completion", "catalog", "schemas"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const id = n ? nodeTarget(n) : null;
|
||
if (id) void introspectSource(id);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.disconnect",
|
||
title: "Deactivate",
|
||
icon: "db-disconnect",
|
||
keywords: ["disconnect", "close connection"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const id = n ? nodeTarget(n) : null;
|
||
if (!id) {
|
||
for (const c of useDatabase.getState().connected) void disconnect(c);
|
||
return;
|
||
}
|
||
// A database node closes its own connection; anything else the data source's.
|
||
void disconnect(n?.kind === "database" ? id : splitTarget(id).id);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.jumpToConsole",
|
||
title: "Jump to Query Console…",
|
||
icon: "db-console",
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const id = n ? nodeTarget(n) : null;
|
||
const { sources } = useDatabase.getState();
|
||
const target = id ?? (sources.length === 1 ? (sources[0]!.id ?? null) : null);
|
||
if (target) void openConsole(target);
|
||
else toolWindowService().show(DB_TOOL_WINDOW, true);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.editData",
|
||
title: "Edit Data",
|
||
icon: "db-table",
|
||
keywords: ["open table", "table editor"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const t = n && tableOf(n);
|
||
if (t) openTableData(t.id, t.schema, t.table);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.goToDdl",
|
||
title: "Go to DDL",
|
||
icon: "file-sql",
|
||
keywords: ["edit source", "definition", "create table"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const o = n && schemaObjectOf(n);
|
||
if (o) return void openObjectDdl(o.id, o.schema, o.kind, o.name);
|
||
const t = n && tableOf(n);
|
||
if (t) void openDdl(t.id, t.schema, t.table);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.quickDoc",
|
||
title: "Quick Documentation",
|
||
icon: "info",
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (n && n.kind !== "message") openDialog({ kind: "quickDoc", node: n, anchor: rowAnchor() });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.rename",
|
||
title: "Rename…",
|
||
icon: "edit",
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (!n) return;
|
||
const id = nodeTarget(n);
|
||
if (n.kind === "source" && id) return openDialog({ kind: "rename", id, object: null });
|
||
const o = objectOf(n);
|
||
if (id && o && canRename(driverOf(id), o)) openDialog({ kind: "rename", id, object: o });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.drop",
|
||
title: "Drop…",
|
||
icon: "trash",
|
||
keywords: ["delete", "remove data source"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (!n) return;
|
||
const id = nodeTarget(n);
|
||
if (n.kind === "source") return void removeSource(n.source);
|
||
const o = objectOf(n);
|
||
if (id && o && canDrop(driverOf(id), o)) openDialog({ kind: "drop", id, object: o });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.truncate",
|
||
title: "Truncate…",
|
||
keywords: ["delete all rows", "empty table"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (n?.kind === "table" && n.table.kind === "table")
|
||
openDialog({ kind: "truncate", id: n.id, schema: n.schema, table: n.table.name });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.modifyTable",
|
||
title: "Modify Table…",
|
||
icon: "edit",
|
||
keywords: ["alter table", "add column", "modify column"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const t = n && tableOf(n);
|
||
if (!t || t.view || !canModifyTable(driverOf(t.id))) return;
|
||
openDialog({
|
||
kind: "modifyTable",
|
||
id: t.id,
|
||
schema: t.schema,
|
||
table: t.table,
|
||
focusColumn: n.kind === "column" ? n.column.name : undefined,
|
||
});
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.newTable",
|
||
title: "Table",
|
||
icon: "db-table",
|
||
keywords: ["create table", "new table"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const id = n && nodeTarget(n);
|
||
if (!n || !id) return;
|
||
const schema =
|
||
"schema" in n && typeof n.schema === "string" ? n.schema : driverOf(id) === "sqlite" ? "main" : null;
|
||
if (schema !== null) openDialog({ kind: "modifyTable", id, schema, table: null });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.newColumn",
|
||
title: "Column",
|
||
icon: "db-column",
|
||
keywords: ["add column"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const t = n && tableOf(n);
|
||
if (t && !t.view && canModifyTable(driverOf(t.id)))
|
||
openDialog({ kind: "modifyTable", id: t.id, schema: t.schema, table: t.table, addColumn: true });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.importData",
|
||
title: "Import Data from File…",
|
||
icon: "import",
|
||
keywords: ["csv", "tsv", "load data"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (n?.kind === "table" && n.table.kind === "table" && driverOf(n.id) !== "clickhouse")
|
||
openDialog({ kind: "import", id: n.id, schema: n.schema, table: n.table.name });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.copyReference",
|
||
title: "Copy Reference",
|
||
icon: "copy",
|
||
keywords: ["qualified name"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (!n) return;
|
||
const id = nodeTarget(n);
|
||
if (n.kind === "source") return void copy(n.source.name ?? "", tx("Cannot copy the name"));
|
||
if (n.kind === "database") return void copy(n.name, tx("Cannot copy the name"));
|
||
const o = objectOf(n);
|
||
if (id && o) void copy(reference(driverOf(id), o), tx("Cannot copy the reference"));
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.duplicateSource",
|
||
title: "Duplicate",
|
||
icon: "copy",
|
||
keywords: ["copy data source"],
|
||
run: ({ arg }) => {
|
||
const src = sourceOf(nodeFrom(arg));
|
||
if (src?.id) void duplicateSource(src.id);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.ddlToClipboard",
|
||
title: "Generate DDL to Clipboard",
|
||
icon: "copy",
|
||
keywords: ["create table", "sql script"],
|
||
run: async ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const ddl = n && (await ddlOf(n));
|
||
if (ddl) await copy(ddl.text, tx("Cannot copy the DDL"));
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.ddlToConsole",
|
||
title: "Generate DDL to Query Console",
|
||
icon: "db-console",
|
||
keywords: ["create table", "sql script"],
|
||
run: async ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const ddl = n && (await ddlOf(n));
|
||
if (ddl) await openConsoleWith(ddl.id, ddl.text);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.runSqlScript",
|
||
title: "Run SQL Script…",
|
||
icon: "run",
|
||
keywords: ["execute file", "import sql"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
const { sources } = useDatabase.getState();
|
||
const id = (n && nodeTarget(n)) ?? (sources.length === 1 ? sources[0]!.id : null);
|
||
if (id) void runScriptFile(id);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.sqlScript",
|
||
title: "SQL Script Template",
|
||
hidden: true,
|
||
run: ({ arg }) => {
|
||
const a = (arg ?? {}) as { node?: DbNode; kind?: ScriptKind };
|
||
const n = a.node ?? useDatabase.getState().selectedNode;
|
||
if (n && a.kind) void insertScript(n, a.kind);
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.goToReferencedTable",
|
||
title: "Go to Referenced Table",
|
||
keywords: ["foreign key"],
|
||
run: ({ arg }) => {
|
||
const n = nodeFrom(arg);
|
||
if (n?.kind === "foreignKey") void revealInTree(n.id, n.fk.refSchema, n.fk.refTable, "table");
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.new",
|
||
title: "New…",
|
||
icon: "plus",
|
||
keywords: ["query console", "data source"],
|
||
run: () => {
|
||
toolWindowService().show(DB_TOOL_WINDOW, false);
|
||
useDatabase.setState({ newMenuOpen: true });
|
||
},
|
||
}),
|
||
tree({
|
||
id: "db.separateProceduresAndFunctions",
|
||
title: "Separate Procedures and Functions",
|
||
run: toggleSeparateProceduresAndFunctions,
|
||
}),
|
||
tree({
|
||
id: "db.collapseAll",
|
||
title: "Collapse All",
|
||
icon: "collapse-all",
|
||
run: () => useDatabase.setState({ treeExpanded: new Set() }),
|
||
}),
|
||
]);
|
||
}
|