@hienlh/ppm 0.9.65 → 0.9.67

package/src/server/routes/database.ts

@@ -1,13 +1,13 @@
 import { Hono } from "hono";
 import {
   getConnections, getConnectionById, insertConnection, updateConnection, deleteConnection,
+  decryptConfig, getConnectionConfig,
   type ConnectionConfig, type ConnectionRow,
 } from "../../services/db.service.ts";
 import { getAdapter } from "../../services/database/adapter-registry.ts";
 import { syncTables, searchTables, getTablesFromCache } from "../../services/table-cache.service.ts";
 import { isReadOnlyQuery } from "../../services/database/readonly-check.ts";
 import { ok, err } from "../../types/api.ts";
-import type { DbConnectionConfig } from "../../types/database.ts";
 
 export const databaseRoutes = new Hono();
 
@@ -43,11 +43,14 @@ databaseRoutes.get("/connections", (c) => {
   }
 });
 
-/** GET /api/db/connections/export — full connection data including credentials */
+/** GET /api/db/connections/export — full connection data including credentials (decrypted) */
 databaseRoutes.get("/connections/export", (c) => {
   try {
     const conns = getConnections();
-    const exported = conns.map(({ id, sort_order, created_at, updated_at, ...rest }) => rest);
+    const exported = conns.map(({ id, sort_order, created_at, updated_at, connection_config, ...rest }) => ({
+      ...rest,
+      connection_config: JSON.stringify(decryptConfig(connection_config)),
+    }));
     return c.json(ok({ version: 1, exported_at: new Date().toISOString(), connections: exported }));
   } catch (e) {
     return c.json(err((e as Error).message), 500);
@@ -181,12 +184,25 @@ databaseRoutes.delete("/connections/:id", (c) => {
 // Connection operations
 // ---------------------------------------------------------------------------
 
+/** POST /api/db/test — test a raw (unsaved) connection config */
+databaseRoutes.post("/test", async (c) => {
+  try {
+    const body = await c.req.json<{ type: "sqlite" | "postgres"; connectionConfig: { type: string; path?: string; connectionString?: string } }>();
+    if (!body.type || !body.connectionConfig) return c.json(err("type and connectionConfig required"), 400);
+    const adapter = getAdapter(body.type);
+    const result = await adapter.testConnection(body.connectionConfig as import("../../types/database.ts").DbConnectionConfig);
+    return c.json(ok(result));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
 /** POST /api/db/connections/:id/test */
 databaseRoutes.post("/connections/:id/test", async (c) => {
   try {
     const conn = resolveConn(c.req.param("id"));
     if (!conn) return c.json(err("Connection not found"), 404);
-    const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+    const config = decryptConfig(conn.connection_config);
     const adapter = getAdapter(conn.type);
     const result = await adapter.testConnection(config);
     return c.json(ok(result));
@@ -217,7 +233,7 @@ databaseRoutes.get("/connections/:id/schema", async (c) => {
     const table = c.req.query("table");
     const schema = c.req.query("schema");
     if (!table) return c.json(err("table query param required"), 400);
-    const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+    const config = decryptConfig(conn.connection_config);
     const adapter = getAdapter(conn.type);
     const cols = await adapter.getTableSchema(config, table, schema);
     return c.json(ok(cols));
@@ -233,7 +249,7 @@ databaseRoutes.get("/connections/:id/data", async (c) => {
     if (!conn) return c.json(err("Connection not found"), 404);
     const table = c.req.query("table");
     if (!table) return c.json(err("table query param required"), 400);
-    const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+    const config = decryptConfig(conn.connection_config);
     const adapter = getAdapter(conn.type);
     const data = await adapter.getTableData(config, table, {
       schema: c.req.query("schema"),
@@ -260,7 +276,7 @@ databaseRoutes.post("/connections/:id/query", async (c) => {
       return c.json(err("Connection is readonly — only SELECT queries allowed. Change this in PPM web UI."), 403);
     }
 
-    const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+    const config = decryptConfig(conn.connection_config);
     const adapter = getAdapter(conn.type);
     const result = await adapter.executeQuery(config, body.sql);
     return c.json(ok(result));
@@ -287,7 +303,7 @@ databaseRoutes.put("/connections/:id/cell", async (c) => {
       return c.json(err("table, pkColumn, and column are required"), 400);
     }
 
-    const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+    const config = decryptConfig(conn.connection_config);
     const adapter = getAdapter(conn.type);
     await adapter.updateCell(config, body.table, {
       schema: body.schema,
@@ -320,7 +336,7 @@ databaseRoutes.delete("/connections/:id/row", async (c) => {
       return c.json(err("table, pkColumn, and pkValue are required"), 400);
     }
 
-    const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+    const config = decryptConfig(conn.connection_config);
     const adapter = getAdapter(conn.type);
     await adapter.deleteRow(config, body.table, {
       schema: body.schema,
@@ -333,6 +349,107 @@ databaseRoutes.delete("/connections/:id/row", async (c) => {
   }
 });
 
+// ---------------------------------------------------------------------------
+// Bulk operations
+// ---------------------------------------------------------------------------
+
+/** POST /api/db/connections/:id/rows/delete — bulk delete by PK values */
+databaseRoutes.post("/connections/:id/rows/delete", async (c) => {
+  try {
+    const conn = resolveConn(c.req.param("id"));
+    if (!conn) return c.json(err("Connection not found"), 404);
+    if (conn.readonly) return c.json(err("Connection is readonly — bulk delete is disabled."), 403);
+
+    const body = await c.req.json<{ table: string; schema?: string; pkColumn: string; pkValues: unknown[] }>();
+    if (!body.table || !body.pkColumn || !Array.isArray(body.pkValues) || body.pkValues.length === 0) {
+      return c.json(err("table, pkColumn, and pkValues[] are required"), 400);
+    }
+
+    const config = decryptConfig(conn.connection_config);
+    const adapter = getAdapter(conn.type);
+    for (const pkValue of body.pkValues) {
+      await adapter.deleteRow(config, body.table, { schema: body.schema, pkColumn: body.pkColumn, pkValue });
+    }
+    return c.json(ok({ deleted: body.pkValues.length }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** POST /api/db/connections/:id/row — insert a new row */
+databaseRoutes.post("/connections/:id/row", async (c) => {
+  try {
+    const conn = resolveConn(c.req.param("id"));
+    if (!conn) return c.json(err("Connection not found"), 404);
+    if (conn.readonly) return c.json(err("Connection is readonly — insert is disabled."), 403);
+
+    const body = await c.req.json<{ table: string; schema?: string; values: Record<string, unknown> }>();
+    if (!body.table || !body.values || Object.keys(body.values).length === 0) {
+      return c.json(err("table and values are required"), 400);
+    }
+
+    const config = decryptConfig(conn.connection_config);
+    const adapter = getAdapter(conn.type);
+    // Build and execute INSERT query
+    const cols = Object.keys(body.values);
+    const vals = Object.values(body.values);
+    const placeholders = cols.map((_, i) => `$${i + 1}`).join(", ");
+    const schema = body.schema && conn.type === "postgres" ? `"${body.schema}".` : "";
+    const sql = `INSERT INTO ${schema}"${body.table}" (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})`;
+    await adapter.executeQuery(config, sql.replace(/\$(\d+)/g, (_, n) => {
+      const v = vals[Number(n) - 1];
+      if (v === null || v === undefined) return "NULL";
+      if (typeof v === "number") return String(v);
+      return `'${String(v).replace(/'/g, "''")}'`;
+    }));
+    return c.json(ok({ inserted: true }), 201);
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Export
+// ---------------------------------------------------------------------------
+
+/** GET /api/db/connections/:id/export?table=X&schema=Y&format=csv|json&limit=10000 */
+databaseRoutes.get("/connections/:id/export", async (c) => {
+  try {
+    const conn = resolveConn(c.req.param("id"));
+    if (!conn) return c.json(err("Connection not found"), 404);
+    const table = c.req.query("table");
+    if (!table) return c.json(err("table query param required"), 400);
+    const schema = c.req.query("schema");
+    const format = c.req.query("format") === "json" ? "json" : "csv";
+    const limit = Math.min(parseInt(c.req.query("limit") ?? "10000", 10), 10000);
+
+    const config = decryptConfig(conn.connection_config);
+    const adapter = getAdapter(conn.type);
+    const data = await adapter.getTableData(config, table, { schema, page: 1, limit });
+
+    if (format === "json") {
+      return new Response(JSON.stringify(data.rows, null, 2), {
+        headers: { "Content-Type": "application/json", "Content-Disposition": `attachment; filename="${table}.json"` },
+      });
+    }
+
+    // CSV
+    const escape = (val: string): string => {
+      if (val.includes(",") || val.includes('"') || val.includes("\n")) return `"${val.replace(/"/g, '""')}"`;
+      return val;
+    };
+    const lines = [data.columns.map(escape).join(",")];
+    for (const row of data.rows) {
+      lines.push(data.columns.map((col) => escape(String(row[col] ?? ""))).join(","));
+    }
+    return new Response(lines.join("\n"), {
+      headers: { "Content-Type": "text/csv", "Content-Disposition": `attachment; filename="${table}.csv"` },
+    });
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
 // ---------------------------------------------------------------------------
 // Search
 // ---------------------------------------------------------------------------

package/src/services/cloud.service.ts

@@ -3,6 +3,7 @@ import { homedir, hostname } from "node:os";
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { VERSION } from "../version.ts";
+import { configService } from "./config.service.ts";
 
 const PPM_DIR = resolve(homedir(), ".ppm");
 const AUTH_FILE = resolve(PPM_DIR, "cloud-auth.json");
@@ -284,7 +285,7 @@ export async function linkDevice(name?: string): Promise<CloudDevice> {
   if (!auth) throw new Error("Not logged in. Run 'ppm cloud login' first.");
 
   const machineId = getMachineId();
-  const deviceName = name || hostname() || "Unknown Machine";
+  const deviceName = name || (configService.get("device_name") as string) || hostname() || "Unknown Machine";
 
   const res = await cloudFetch("/api/devices", {
     method: "POST",

package/src/services/database/sqlite-adapter.ts

@@ -31,6 +31,7 @@ export const sqliteAdapter: DatabaseAdapter = {
       nullable: !c.notnull,
       pk: !!c.pk,
       defaultValue: c.dflt_value,
+      fk: c.fk,
     }));
   },
 

package/src/services/db.service.ts

@@ -2,9 +2,10 @@ import { Database, type SQLQueryBindings } from "bun:sqlite";
 import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
+import { encrypt, decrypt } from "../lib/account-crypto.ts";
 
 const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 14;
+const CURRENT_SCHEMA_VERSION = 15;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -414,6 +415,22 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 14;
     `);
   }
+
+  if (current < 15) {
+    // Encrypt all existing plaintext connection_config values
+    const rows = database.query("SELECT id, connection_config FROM connections").all() as { id: number; connection_config: string }[];
+    for (const row of rows) {
+      try {
+        // Try decrypting — if it works, already encrypted
+        decrypt(row.connection_config);
+      } catch {
+        // Plaintext — encrypt it
+        const encrypted = encrypt(row.connection_config);
+        database.query("UPDATE connections SET connection_config = ? WHERE id = ?").run(encrypted, row.id);
+      }
+    }
+    database.exec("PRAGMA user_version = 15");
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -796,6 +813,28 @@ export type ConnectionConfig =
   | { type: "sqlite"; path: string }
   | { type: "postgres"; connectionString: string };
 
+/** Encrypt a connection config object for storage */
+function encryptConfig(config: ConnectionConfig): string {
+  return encrypt(JSON.stringify(config));
+}
+
+/** Decrypt a stored connection_config string, with fallback for pre-migration plaintext */
+export function decryptConfig(encrypted: string): ConnectionConfig {
+  try {
+    return JSON.parse(decrypt(encrypted));
+  } catch {
+    // Fallback: might be plaintext (pre-migration or test DB)
+    return JSON.parse(encrypted);
+  }
+}
+
+/** Get decrypted connection config by connection ID */
+export function getConnectionConfig(id: number): ConnectionConfig | null {
+  const conn = getConnectionById(id);
+  if (!conn) return null;
+  return decryptConfig(conn.connection_config);
+}
+
 export function getConnections(): ConnectionRow[] {
   return getDb().query(
     "SELECT * FROM connections ORDER BY sort_order, id",
@@ -826,7 +865,7 @@ export function insertConnection(
   const maxOrder = (getDb().query("SELECT COALESCE(MAX(sort_order), -1) as m FROM connections").get() as { m: number }).m;
   getDb().query(
     "INSERT INTO connections (type, name, connection_config, group_name, color, sort_order) VALUES (?, ?, ?, ?, ?, ?)",
-  ).run(type, name, JSON.stringify(config), groupName ?? null, color ?? null, maxOrder + 1);
+  ).run(type, name, encryptConfig(config), groupName ?? null, color ?? null, maxOrder + 1);
   return getConnectionByName(name)!;
 }
 
@@ -843,7 +882,7 @@ export function updateConnection(
   const sets: string[] = [];
   const vals: unknown[] = [];
   if (updates.name !== undefined) { sets.push("name = ?"); vals.push(updates.name); }
-  if (updates.config !== undefined) { sets.push("connection_config = ?"); vals.push(JSON.stringify(updates.config)); }
+  if (updates.config !== undefined) { sets.push("connection_config = ?"); vals.push(encryptConfig(updates.config)); }
   if (updates.groupName !== undefined) { sets.push("group_name = ?"); vals.push(updates.groupName); }
   if (updates.color !== undefined) { sets.push("color = ?"); vals.push(updates.color); }
   if (updates.readonly !== undefined) { sets.push("readonly = ?"); vals.push(updates.readonly); }

package/src/services/postgres.service.ts

@@ -12,6 +12,7 @@ export interface PgColumnInfo {
   nullable: boolean;
   pk: boolean;
   defaultValue: string | null;
+  fk: { table: string; column: string } | null;
 }
 
 export interface PgQueryResult {
@@ -19,6 +20,7 @@ export interface PgQueryResult {
   rows: Record<string, unknown>[];
   rowsAffected: number;
   changeType: "select" | "modify";
+  executionTimeMs: number;
 }
 
 /** Auto-close idle connections after 5 minutes */
@@ -40,7 +42,13 @@ class PostgresService {
       cached.timer = setTimeout(() => this.disconnect(connectionString), IDLE_TIMEOUT_MS);
       return cached.sql;
     }
-    const sql = postgres(connectionString, { max: 3, idle_timeout: 60 });
+    // Parse sslmode from connection string to configure SSL properly
+    const url = new URL(connectionString);
+    const sslmode = url.searchParams.get("sslmode");
+    const sslOpts = sslmode === "no-verify" || sslmode === "require"
+      ? { rejectUnauthorized: false }
+      : sslmode === "disable" ? false : undefined;
+    const sql = postgres(connectionString, { max: 3, idle_timeout: 60, ssl: sslOpts as any });
     const timer = setTimeout(() => this.disconnect(connectionString), IDLE_TIMEOUT_MS);
     this.cache.set(connectionString, { sql, timer });
     return sql;
@@ -82,7 +90,7 @@ class PostgresService {
     }));
   }
 
-  /** Get column schema for a table */
+  /** Get column schema for a table (with FK metadata) */
   async getTableSchema(connectionString: string, table: string, schema = "public"): Promise<PgColumnInfo[]> {
     const sql = this.connect(connectionString);
     const cols = await sql`
@@ -97,12 +105,32 @@ class PostgresService {
       WHERE c.table_schema = ${schema} AND c.table_name = ${table}
       ORDER BY c.ordinal_position
     `;
+
+    // Query FK references
+    const fkRows = await sql`
+      SELECT kcu.column_name as from_col,
+             ccu.table_name as ref_table,
+             ccu.column_name as ref_col
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu
+        ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage ccu
+        ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
+      WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema = ${schema} AND tc.table_name = ${table}
+    `;
+    const fkMap = new Map<string, { table: string; column: string }>();
+    for (const fk of fkRows) {
+      fkMap.set(fk.from_col as string, { table: fk.ref_table as string, column: fk.ref_col as string });
+    }
+
     return cols.map((c) => ({
       name: c.name as string,
       type: c.type as string,
-      nullable: c.nullable as boolean,
-      pk: c.pk as boolean,
+      nullable: c.nullable === true || c.nullable === "true" || c.nullable === "t",
+      pk: c.pk === true || c.pk === "true" || c.pk === "t",
       defaultValue: c.default_value as string | null,
+      fk: fkMap.get(c.name as string) ?? null,
     }));
   }
 
@@ -139,14 +167,17 @@ class PostgresService {
     const isSelect = trimmed.startsWith("SELECT") || trimmed.startsWith("EXPLAIN") ||
       trimmed.startsWith("SHOW") || trimmed.startsWith("\\D");
 
+    const start = performance.now();
     if (isSelect) {
       const rows = await sql.unsafe(sqlText);
+      const executionTimeMs = Math.round(performance.now() - start);
       const columns = rows.length > 0 ? Object.keys(rows[0]!) : [];
-      return { columns, rows: rows as unknown as Record<string, unknown>[], rowsAffected: 0, changeType: "select" };
+      return { columns, rows: rows as unknown as Record<string, unknown>[], rowsAffected: 0, changeType: "select", executionTimeMs };
     }
 
     const result = await sql.unsafe(sqlText);
-    return { columns: [], rows: [], rowsAffected: result.count ?? 0, changeType: "modify" };
+    const executionTimeMs = Math.round(performance.now() - start);
+    return { columns: [], rows: [], rowsAffected: result.count ?? 0, changeType: "modify", executionTimeMs };
   }
 
   /** Update a single cell value */

package/src/services/sqlite.service.ts

@@ -14,6 +14,7 @@ export interface ColumnInfo {
   notnull: boolean;
   pk: boolean;
   dflt_value: string | null;
+  fk: { table: string; column: string } | null;
 }
 
 export interface QueryResult {
@@ -21,6 +22,7 @@ export interface QueryResult {
   rows: Record<string, unknown>[];
   rowsAffected: number;
   changeType: "select" | "modify";
+  executionTimeMs: number;
 }
 
 /** Auto-close idle databases after 5 minutes */
@@ -81,11 +83,20 @@ class SqliteService {
     });
   }
 
-  /** Get column schema for a table */
+  /** Get column schema for a table (with FK metadata) */
   getTableSchema(projectPath: string, dbPath: string, table: string): ColumnInfo[] {
     const abs = this.resolvePath(projectPath, dbPath);
     const db = this.open(abs);
-    return db.query(`PRAGMA table_info("${table}")`).all() as ColumnInfo[];
+    const cols = db.query(`PRAGMA table_info("${table}")`).all() as Omit<ColumnInfo, "fk">[];
+
+    // Build FK map from PRAGMA foreign_key_list
+    const fkRows = db.query(`PRAGMA foreign_key_list("${table}")`).all() as { from: string; table: string; to: string }[];
+    const fkMap = new Map<string, { table: string; column: string }>();
+    for (const fk of fkRows) {
+      fkMap.set(fk.from, { table: fk.table, column: fk.to });
+    }
+
+    return cols.map((c) => ({ ...c, fk: fkMap.get(c.name) ?? null }));
   }
 
   /** Get paginated rows from a table */
@@ -115,15 +126,18 @@ class SqliteService {
     const trimmed = sql.trim().toUpperCase();
     const isSelect = trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("EXPLAIN");
 
+    const start = performance.now();
     if (isSelect) {
       const stmt = db.query(sql);
       const rows = stmt.all() as Record<string, unknown>[];
+      const executionTimeMs = Math.round(performance.now() - start);
       const columns = rows.length > 0 ? Object.keys(rows[0]!) : [];
-      return { columns, rows, rowsAffected: 0, changeType: "select" };
+      return { columns, rows, rowsAffected: 0, changeType: "select", executionTimeMs };
     }
 
     const result = db.run(sql);
-    return { columns: [], rows: [], rowsAffected: result.changes, changeType: "modify" };
+    const executionTimeMs = Math.round(performance.now() - start);
+    return { columns: [], rows: [], rowsAffected: result.changes, changeType: "modify", executionTimeMs };
   }
 
   /** Update a single cell value */

package/src/services/table-cache.service.ts

@@ -1,9 +1,8 @@
 import {
   getCachedTables, upsertTableCache, deleteTableCache, searchTableCache,
-  getConnectionById, type TableCacheRow,
+  getConnectionById, decryptConfig, type TableCacheRow,
 } from "./db.service.ts";
 import { getAdapter } from "./database/adapter-registry.ts";
-import type { DbConnectionConfig } from "../types/database.ts";
 
 export interface CachedTable {
   connectionId: number;
@@ -42,7 +41,7 @@ export async function syncTables(connectionId: number): Promise<CachedTable[]> {
   const conn = getConnectionById(connectionId);
   if (!conn) throw new Error(`Connection not found: ${connectionId}`);
 
-  const config = JSON.parse(conn.connection_config) as DbConnectionConfig;
+  const config = decryptConfig(conn.connection_config);
   const adapter = getAdapter(conn.type);
   const tables = await adapter.getTables(config);
 

package/src/types/database.ts

@@ -19,6 +19,7 @@ export interface DbColumnInfo {
   nullable: boolean;
   pk: boolean;
   defaultValue: string | null;
+  fk: { table: string; column: string } | null;
 }
 
 export interface DbQueryResult {
@@ -26,6 +27,7 @@ export interface DbQueryResult {
   rows: Record<string, unknown>[];
   rowsAffected: number;
   changeType: "select" | "modify";
+  executionTimeMs: number;
 }
 
 export interface DbPagedData {

package/src/web/components/database/connection-form-dialog.tsx

@@ -15,6 +15,8 @@ interface ConnectionFormDialogProps {
   onSave?: (data: CreateConnectionData) => Promise<void>;
   onUpdate?: (id: number, data: UpdateConnectionData) => Promise<void>;
   onTest: (id: number) => Promise<{ ok: boolean; error?: string }>;
+  /** Test raw (unsaved) connection config — enables Test button in create mode */
+  onTestRaw?: (type: "sqlite" | "postgres", config: { type: string; path?: string; connectionString?: string }) => Promise<{ ok: boolean; error?: string }>;
 }
 
 interface FormState {
@@ -28,7 +30,7 @@ interface FormState {
 }
 
 export function ConnectionFormDialog({
-  open, onClose, connection, onSave, onUpdate, onTest,
+  open, onClose, connection, onSave, onUpdate, onTest, onTestRaw,
 }: ConnectionFormDialogProps) {
   const isEdit = !!connection;
   const [form, setForm] = useState<FormState>({
@@ -63,11 +65,20 @@ export function ConnectionFormDialog({
   };
 
   const handleTest = async () => {
-    if (!isEdit) return;
     setTesting(true);
     setTestResult(null);
     try {
-      const result = await onTest(connection!.id);
+      let result: { ok: boolean; error?: string };
+      if (isEdit) {
+        result = await onTest(connection!.id);
+      } else if (onTestRaw) {
+        const config = form.type === "postgres"
+          ? { type: "postgres" as const, connectionString: form.connectionString }
+          : { type: "sqlite" as const, path: form.path };
+        result = await onTestRaw(form.type, config);
+      } else {
+        result = { ok: false, error: "Save connection first" };
+      }
       setTestResult(result);
     } finally {
       setTesting(false);
@@ -227,11 +238,9 @@ export function ConnectionFormDialog({
         </div>
 
         <DialogFooter>
-          {isEdit && (
-            <Button variant="outline" size="sm" onClick={handleTest} disabled={testing} className="mr-auto">
-              {testing ? "Testing…" : "Test Connection"}
-            </Button>
-          )}
+          <Button variant="outline" size="sm" onClick={handleTest} disabled={testing} className="mr-auto">
+            {testing ? "Testing…" : "Test Connection"}
+          </Button>
           <Button variant="outline" size="sm" onClick={onClose}>Cancel</Button>
           <Button size="sm" onClick={handleSave} disabled={saving}>
             {saving ? "Saving…" : isEdit ? "Save" : "Add"}