The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
/** Pure helpers of the database tools: clipboard formats, edits, labels. */
import type {
DbCellValue,
DbColor,
DbDriver,
DbProperty,
DbRowEdit,
DbSortKey,
DbSsh,
DbSslMode,
DataSource,
} from "@/platform/ipc";
import type { SshConfigValid } from "@/platform/remoteSettings";
import { vendorOf, vendorOfScheme } from "./vendors";
export type Cell = string | null;
/** Tab-separated values (Excel / IDEA "Copy"): NULL is empty, tabs / newlines become spaces. */
export function toTsv(header: readonly string[] | null, rows: ReadonlyArray<readonly Cell[]>): string {
const clean = (v: Cell) => (v ?? "").replace(/[\t\r\n]+/g, " ");
const lines = rows.map((r) => r.map(clean).join("\t"));
if (header) lines.unshift(header.map(clean).join("\t"));
return lines.join("\n");
}
/**
* Every value on a single `, `-separated line (IDEA's One-Row extractor, for
* `IN (…)` lists): NULL for nulls, numbers unquoted, everything else
* single-quoted with `'` doubled. `numeric(c)` decides quoting per column.
*/
export function toOneRow(rows: ReadonlyArray<readonly Cell[]>, numeric: (col: number) => boolean): string {
const literal = (v: Cell, c: number) =>
v === null ? "NULL" : numeric(c) && Number.isFinite(Number(v)) ? v : `'${v.replace(/'/g, "''")}'`;
return rows.flatMap((r) => r.map(literal)).join(", ");
}
/** RFC 4180 CSV; NULL is an empty field. */
export function toCsv(header: readonly string[] | null, rows: ReadonlyArray<readonly Cell[]>): string {
const field = (v: Cell) => {
const s = v ?? "";
return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
};
const lines = rows.map((r) => r.map(field).join(","));
if (header) lines.unshift(header.map(field).join(","));
return lines.join("\r\n");
}
/** Rows of RFC 4180 text with separator `sep` (quoted fields, `""`, CR LF); a trailing newline adds no row. */
export function parseDelimited(text: string, sep: string): string[][] {
const rows: string[][] = [];
let row: string[] = [];
let field = "";
let quoted = false;
let i = text.charCodeAt(0) === 0xfeff ? 1 : 0;
for (; i < text.length; i++) {
const ch = text[i]!;
if (quoted) {
if (ch !== '"') field += ch;
else if (text[i + 1] === '"') {
field += '"';
i++;
} else quoted = false;
} else if (ch === '"' && field === "") quoted = true;
else if (ch === sep) {
row.push(field);
field = "";
} else if (ch === "\n" || ch === "\r") {
if (ch === "\r" && text[i + 1] === "\n") i++;
row.push(field);
rows.push(row);
row = [];
field = "";
} else field += ch;
}
if (field !== "" || row.length) {
row.push(field);
rows.push(row);
}
return rows;
}
/** The separator of delimited text: tab when its first line has more tabs than commas or semicolons. */
export function guessSeparator(text: string): string {
const first = text.slice(0, text.search(/\r?\n|$/));
const count = (c: string) => first.split(c).length - 1;
return [",", "\t", ";"].reduce((best, c) => (count(c) > count(best) ? c : best), ",");
}
/**
* Insert edits importing `rows` into a table with `columns`: by header name
* (case-insensitive; unknown names skipped) or by position. `emptyAsNull`
* turns empty fields into NULL.
*/
export function importEdits(
rows: readonly string[][],
columns: readonly string[],
header: boolean,
emptyAsNull: boolean,
): { edits: DbRowEdit[]; mapped: string[] } {
const target = (h: string) => columns.find((c) => c.toLowerCase() === h.trim().toLowerCase()) ?? null;
const map: Array<string | null> = header
? (rows[0] ?? []).map(target)
: columns.slice(0, Math.max(0, ...rows.map((r) => r.length)));
const body = header ? rows.slice(1) : rows;
const edits: DbRowEdit[] = body
.filter((r) => r.some((v) => v !== ""))
.map((r) => ({
kind: "insert",
values: map.flatMap((column, i) =>
column === null ? [] : [{ column, value: emptyAsNull && (r[i] ?? "") === "" ? null : (r[i] ?? null) }],
),
}));
return { edits, mapped: map.filter((c): c is string => c !== null) };
}
/** Pending changes of the table editor. Row indices refer to the loaded page. */
export interface PendingEdits {
/** row → column → new value. */
updates: Map<number, Map<string, Cell>>;
deletes: Set<number>;
/** New rows: column → value (absent columns use their default). */
inserts: Array<Map<string, Cell>>;
}
export const emptyEdits = (): PendingEdits => ({ updates: new Map(), deletes: new Set(), inserts: [] });
export function hasEdits(e: PendingEdits): boolean {
return e.updates.size > 0 || e.deletes.size > 0 || e.inserts.length > 0;
}
/** The DML requests for `edits` of a page with `columns` / `rows`, keyed by `primaryKey`. */
export function buildRowEdits(
columns: readonly string[],
rows: ReadonlyArray<readonly Cell[]>,
primaryKey: readonly string[],
edits: PendingEdits,
): DbRowEdit[] {
const keyOf = (row: number): DbCellValue[] =>
primaryKey.map((c) => ({ column: c, value: rows[row]?.[columns.indexOf(c)] ?? null }));
const out: DbRowEdit[] = [];
for (const [row, changes] of edits.updates) {
if (edits.deletes.has(row) || !changes.size) continue;
out.push({ kind: "update", key: keyOf(row), values: [...changes].map(([column, value]) => ({ column, value })) });
}
for (const row of [...edits.deletes].sort((a, b) => a - b)) out.push({ kind: "delete", key: keyOf(row) });
for (const ins of edits.inserts)
out.push({ kind: "insert", values: [...ins].map(([column, value]) => ({ column, value })) });
return out;
}
/** IDEA's default name of a file data source: the file name without its extension (`shop.db` → `shop`). */
export function fileSourceName(file: string): string {
const base = file.split(/[\\/]/).pop() ?? file;
return base.replace(/\.[^.]+$/, "") || base;
}
/** The tree / menu icon of a data source (IDEA shows the vendor's mark). */
export function sourceIcon(s: Pick<DataSource, "vendor" | "driver">): string {
return vendorOf(s).icon;
}
export function sourceLabel(s: Pick<DataSource, "name" | "driver" | "vendor">): string {
return `${s.name} (${vendorOf(s).label})`;
}
/** The token of a data source colour (tree rows, console tab). */
export function colorVar(color: DbColor | null | undefined): string | undefined {
return color ? `var(--db-color-${color})` : undefined;
}
/** `*` / `?` wildcard match of the Schemas tab (case-sensitive, like the server's names). */
export function matchesPattern(name: string, pattern: string): boolean {
if (!/[*?]/.test(pattern)) return name === pattern;
const re = pattern
.replace(/[.+^${}()|[\]\\]/g, "\\$&")
.replace(/\*/g, ".*")
.replace(/\?/g, ".");
return new RegExp(`^${re}$`).test(name);
}
/** The table editor's ORDER BY field for a sort: `name DESC, id`. */
export function formatOrderBy(sort: readonly DbSortKey[]): string {
return sort.map((k) => (k.descending ? `${k.column} DESC` : k.column)).join(", ");
}
/** Parses the ORDER BY field (`col [ASC|DESC], …`, names matched case-insensitively); null when a part isn't a column. */
export function parseOrderBy(text: string, columns: readonly string[]): DbSortKey[] | null {
const out: DbSortKey[] = [];
for (const part of text
.split(",")
.map((p) => p.trim())
.filter(Boolean)) {
const m = /^("?)([^"]+?)\1(?:\s+(asc|desc))?$/i.exec(part);
const column = m && columns.find((c) => c.toLowerCase() === m[2]!.trim().toLowerCase());
if (!column) return null;
out.push({ column, descending: m[3]?.toLowerCase() === "desc" });
}
return out;
}
/** Schemas tab › Object filter: `name` matches one of its patterns (comma / space separated; empty: all). */
export function passesObjectFilter(name: string, filter: string | null | undefined): boolean {
const patterns = (filter ?? "").split(/[\s,]+/).filter(Boolean);
return !patterns.length || patterns.some((p) => matchesPattern(name.toLowerCase(), p.toLowerCase()));
}
/**
* The tree's quick filter (the toolbar's field): `name` contains it,
* case-insensitively (`*` / `?` still work through `matchesPattern` callers).
*/
export function passesTreeFilter(name: string, filter: string | null | undefined): boolean {
const q = (filter ?? "").trim().toLowerCase();
return !q || name.toLowerCase().includes(q);
}
/**
* Whether a console of `driver` gets the active-schema dropdown (a server with
* several schemas / databases to switch between; SQLite has one database only).
*/
export function schemaSwitchable(driver: DbDriver | null | undefined): boolean {
return driver === "postgres" || driver === "mysql" || driver === "sqlServer" || driver === "oracle";
}
/** The schema a console's statements run in: its pick, else the connection's default. */
export function activeSchema(picked: string | null | undefined, defaultSchema: string | null | undefined): string {
return picked || defaultSchema || "";
}
/**
* The databases / schemas the tree shows (Schemas tab): all of them, or the
* ones matching a chosen name or pattern; `keep` (the connected database) always stays.
*/
export function shownNames(
names: readonly string[],
all: boolean | undefined,
chosen: readonly string[] | undefined,
keep?: string | null,
): string[] {
if (all !== false) return [...names];
const picks = (chosen ?? []).map((p) => p.trim()).filter(Boolean);
return names.filter((n) => n === keep || picks.some((p) => matchesPattern(n, p)));
}
/**
* Connected targets idle for longer than their data source's Auto-disconnect
* (`lastUsed`: ms of the last statement / introspection; `busy`: running or holding a transaction).
*/
export function idleTargets(
connected: Iterable<string>,
sources: readonly DataSource[],
lastUsed: ReadonlyMap<string, number>,
busy: (target: string) => boolean,
now: number,
): string[] {
const out: string[] = [];
for (const t of connected) {
const secs = sources.find((s) => s.id === splitTarget(t).id)?.options?.autoDisconnectSecs;
if (!secs || busy(t)) continue;
if (now - (lastUsed.get(t) ?? now) >= secs * 1000) out.push(t);
}
return out;
}
export function newSourceId(): string {
const rnd =
typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random()}`;
return rnd.replace(/[^a-zA-Z0-9-]/g, "").slice(0, 36);
}
/** What a failed connection needs from the user before retrying. */
export type ConnectRemedy = "password" | "sshSecret" | "trustHostKey" | null;
/**
* Classifies a connection error: an unknown SSH host key to confirm, a missing
* or rejected SSH password / passphrase, or a database password. A changed host
* key is never offered for trust.
*/
export function connectRemedy(
kind: string | undefined,
message: string,
source?: Pick<DataSource, "ssh">,
): ConnectRemedy {
if (/^Unknown SSH host key/.test(message)) return "trustHostKey";
if (kind !== "permissionDenied") return null;
if (/^SSH host key .* has changed/.test(message)) return null;
if (/^SSH (password|key passphrase) required|^cannot decrypt SSH key/.test(message)) return "sshSecret";
if (/^SSH authentication failed/.test(message))
// With OpenSSH config + agent there is nothing to type unless a key is encrypted.
return source?.ssh?.auth === "openSsh" ? null : "sshSecret";
return "password";
}
/** The SSH user@host of a data source, for prompts. */
export function sshLabel(source: Pick<DataSource, "ssh">): string {
const ssh = source.ssh;
if (!ssh?.host) return "";
return `${ssh.user ? `${ssh.user}@` : ""}${ssh.host}${ssh.port ? `:${ssh.port}` : ""}`;
}
/** The SSH configuration a tunnel connects with; undefined for the inline fields or a missing one. */
export function sshConfigOf(
ssh: DbSsh | null | undefined,
configs: readonly SshConfigValid[],
): SshConfigValid | undefined {
const id = ssh?.config?.trim();
return id ? configs.find((c) => c.id === id) : undefined;
}
/** The SSH settings in effect: those of the chosen SSH configuration, else the inline fields. */
export function effectiveSsh(ssh: DbSsh | null | undefined, configs: readonly SshConfigValid[]): DbSsh | null {
if (!ssh) return null;
const c = sshConfigOf(ssh, configs);
return c
? { ...ssh, host: c.host, port: c.port, user: c.user, auth: c.auth, keyFile: c.keyFile, saveSecret: c.saveSecret }
: ssh;
}
/** Whether the SSH tab names a host to tunnel through (always, when the tunnel is off). */
export function sshTunnelReady(ssh: DbSsh | null | undefined, configs: readonly SshConfigValid[]): boolean {
if (!ssh?.enabled) return true;
if (ssh.config?.trim()) return !!sshConfigOf(ssh, configs)?.host.trim();
return !!ssh.host?.trim();
}
/**
* Connection target (backend `split_target`): a data source id for its configured
* database, or `<id>:<database>` for another database of the same server.
*/
export function splitTarget(target: string): { id: string; database: string | null } {
const i = target.indexOf(":");
return i < 0 ? { id: target, database: null } : { id: target.slice(0, i), database: target.slice(i + 1) || null };
}
/** The target of database `database` of data source `id`; the connected one is the data source itself. */
export function targetOf(id: string, database: string | null, current: string | null): string {
return !database || database === current ? id : `${id}:${database}`;
}
/** Key of the Database tree node of database `name` of data source `id`. */
export const databaseKey = (id: string, name: string) => `${id}/@${name}`;
const SSL_MODES: Record<string, DbSslMode> = {
disable: "disable",
disabled: "disable",
prefer: "prefer",
preferred: "prefer",
require: "require",
required: "require",
"verify-ca": "verifyCa",
verify_ca: "verifyCa",
"verify-full": "verifyFull",
verify_identity: "verifyFull",
"verify-identity": "verifyFull",
};
/**
* Data Source from URL (and the General tab's URL field): `postgres://user:pass@host:5432/db`,
* `mysql://…`, `mariadb://…`, wire-compatible products (`redshift://`, `tidb://`…), the
* `jdbc:` forms of those, `jdbc:sqlite:path` / `sqlite:path`. SSL parameters fill the
* SSL tab, other parameters become driver properties. Null when the URL names no supported driver.
*/
export function parseSourceUrl(raw: string): { source: Partial<DataSource>; password: string | null } | null {
const url = raw.trim().replace(/^jdbc:/i, "");
const sqlite = /^sqlite3?:(?:\/\/)?(.+)$/i.exec(url);
if (sqlite) {
const file = sqlite[1]!.replace(/^\/([A-Za-z]:)/, "$1");
return { source: { driver: "sqlite", file, name: fileSourceName(file) }, password: null };
}
// JDBC thin URLs: `jdbc:oracle:thin:@//host:port/service`.
const thin = /^(?:oracle|oracledb):thin:@(.+)$/i.exec(url);
const m =
/^([a-z][a-z0-9]*):\/\/(?:([^:@/]*)(?::([^@/]*))?@)?([^:/?,]+|\[[^\]]+\])(?::(\d+))?(?:,[^/?]*)?(?:\/([^?]*))?(?:\?(.*))?$/i.exec(
thin ? `oracle://${thin[1]!.replace(/^\/+/, "")}` : url,
);
const vendor = m ? vendorOfScheme(m[1]!) : undefined;
if (!m || !vendor || vendor.driver === "sqlite") return null;
const dec = (s: string | undefined) => {
try {
return s ? decodeURIComponent(s) : "";
} catch {
return s ?? "";
}
};
const port = m[5] ? parseInt(m[5], 10) : null;
if (port !== null && !(port > 0 && port < 65536)) return null;
let user = dec(m[2]);
let password = m[3] !== undefined ? dec(m[3]) : null;
const host = m[4]!.replace(/^\[(.*)\]$/, "$1");
const source: Partial<DataSource> = {
driver: vendor.driver,
host,
port,
user,
database: dec(m[6]).replace(/\/$/, ""),
};
if (vendor.id !== vendor.driver) source.vendor = vendor.id;
const properties: DbProperty[] = [];
for (const [k, v] of new URLSearchParams(m[7] ?? "")) {
switch (k.toLowerCase()) {
case "user":
user ||= v;
break;
case "password":
password ??= v;
break;
case "sslmode":
case "ssl-mode": {
const mode = SSL_MODES[v.toLowerCase()];
if (mode) source.ssl = mode;
break;
}
case "sslrootcert":
case "ssl-ca":
source.sslCaFile = v;
break;
case "sslcert":
case "ssl-cert":
source.sslCertFile = v;
break;
case "sslkey":
case "ssl-key":
source.sslKeyFile = v;
break;
default:
properties.push({ name: k, value: v });
}
}
source.user = user;
if (vendor.driver === "clickhouse") {
if (m[1]!.toLowerCase() === "https") source.ssl = "verifyFull";
else if (m[1]!.toLowerCase() === "http") source.ssl = "disable";
}
if (properties.length) source.properties = properties;
return { source, password };
}