drixio 1.1.6 → 1.1.8

package/dist/cli.js

@@ -47,7 +47,7 @@ function printCustomDashboard(title, rows) {
   );
 }
 function printDashboard(dbConfig) {
-  const headerTitle = ` Lightweight Interactive TUI Database Client  \u2022  v${"1.1.6"} `;
+  const headerTitle = ` Lightweight Interactive TUI Database Client  \u2022  v${process.env.npm_package_version} `;
   let dbTypeVal = "None";
   let targetVal = "-";
   let sourceVal = "None";
@@ -156,14 +156,49 @@ var init_sqlite = __esm({
         const info = pragmaQuery.all();
         const fkQuery = db.prepare(`PRAGMA foreign_key_list(${quoted})`);
         const fks = fkQuery.all();
+        const indexListQuery = db.prepare(`PRAGMA index_list(${quoted})`);
+        const indexList = indexListQuery.all();
+        const uniqueCols = /* @__PURE__ */ new Set();
+        for (const idx of indexList) {
+          if (idx.unique === 1) {
+            const infoQuery = db.prepare(
+              `PRAGMA index_info(${this.quoteIdentifier(idx.name)})`
+            );
+            const cols = infoQuery.all();
+            if (cols.length === 1 && cols[0].name) {
+              uniqueCols.add(cols[0].name);
+            }
+          }
+        }
+        const enumMap = /* @__PURE__ */ new Map();
+        try {
+          const createSql = db.prepare(
+            `SELECT sql FROM sqlite_master WHERE type='table' AND name=${quoted}`
+          ).get();
+          if (createSql?.sql) {
+            const checkRegex = /CHECK\s*\(\s*["']?(\w+)["']?\s+IN\s*\(([^)]+)\)\s*\)/gi;
+            let match;
+            while ((match = checkRegex.exec(createSql.sql)) !== null) {
+              const colName = match[1];
+              const valuesStr = match[2];
+              const values = valuesStr.split(",").map((s) => s.trim().replace(/^'|'$/g, "")).filter((s) => s.length > 0);
+              if (values.length > 0) {
+                enumMap.set(colName, values);
+              }
+            }
+          }
+        } catch {
+        }
         return info.map((col) => {
           const fk = fks.find((f) => f.from === col.name);
           return {
             name: col.name,
             type: col.type,
             isPk: col.pk > 0,
-            nullable: col.notnull === 0,
+            nullable: col.pk > 0 ? false : col.notnull === 0,
+            isUnique: col.pk > 0 || uniqueCols.has(col.name),
             defaultValue: col.dflt_value != null ? String(col.dflt_value) : void 0,
+            enumValues: enumMap.get(col.name),
             fkTarget: fk ? { table: fk.table, column: fk.to } : void 0
           };
         });
@@ -176,7 +211,9 @@ var init_sqlite = __esm({
         const indexes = [];
         for (const idx of indexList) {
           if (idx.origin === "pk") continue;
-          const indexInfoQuery = db.prepare(`PRAGMA index_info(${this.quoteIdentifier(idx.name)})`);
+          const indexInfoQuery = db.prepare(
+            `PRAGMA index_info(${this.quoteIdentifier(idx.name)})`
+          );
           const columns = indexInfoQuery.all();
           indexes.push({
             name: idx.name,
@@ -204,20 +241,38 @@ var init_sqlite = __esm({
       }
       async query(sql) {
         const db = await this.getDb();
-        const trimmed = sql.trim().toUpperCase();
-        const isRead = trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("EXPLAIN") || trimmed.startsWith("WITH");
-        if (isRead) {
-          const query = db.prepare(sql);
-          const rows = query.all();
+        const stripped = sql.replace(
+          /^(\s*--[^\n]*\n|\s*\/\*[\s\S]*?\*\/\s*|\s+)*/g,
+          ""
+        );
+        const upper = stripped.toUpperCase();
+        const isRead = upper.startsWith("SELECT") || upper.startsWith("PRAGMA") || upper.startsWith("EXPLAIN") || upper.startsWith("WITH") || upper.startsWith("(");
+        const hasReturning = /\bRETURNING\b/i.test(sql);
+        if (isRead || hasReturning) {
+          const stmt = db.prepare(sql);
+          const rows = stmt.all();
           let columns = [];
           if (rows.length > 0) {
             columns = Object.keys(rows[0]);
+          } else {
+            try {
+              const colMeta = stmt.columns();
+              if (Array.isArray(colMeta)) {
+                columns = colMeta.map((c) => c.name || c.column);
+              }
+            } catch {
+            }
           }
           return { columns, rows };
         } else {
-          const query = db.prepare(sql);
-          query.run();
-          return { columns: ["Result"], rows: [{ Result: "Success" }] };
+          const stmt = db.prepare(sql);
+          const result = stmt.run();
+          const changes = result.changes ?? 0;
+          return {
+            columns: ["Result", "AffectedRows"],
+            rows: [{ Result: "Success", AffectedRows: changes }],
+            affectedRows: changes
+          };
         }
       }
       async executeSql(sql) {
@@ -238,9 +293,108 @@ var init_sqlite = __esm({
         const placeholders = cols.map(() => "?").join(", ");
         const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
         const stmt = db.prepare(sql);
-        for (const row of rows) {
-          const values = cols.map((c) => row[c]);
-          stmt.run(...values);
+        db.exec("BEGIN");
+        try {
+          for (const row of rows) {
+            const values = cols.map((c) => row[c]);
+            stmt.run(...values);
+          }
+          db.exec("COMMIT");
+        } catch (e) {
+          db.exec("ROLLBACK");
+          throw e;
+        }
+      }
+      async recreateTable(tableName, newColumns, renames = {}) {
+        const db = await this.getDb();
+        const quotedOldTable = this.quoteIdentifier(tableName);
+        const tableCheck = db.prepare(
+          `SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`
+        ).get(tableName);
+        if (!tableCheck) {
+          throw new Error(`Table "${tableName}" does not exist.`);
+        }
+        const indexRows = db.prepare(
+          `SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ? AND sql IS NOT NULL`
+        ).all(tableName);
+        const tempTableName = `_drixio_recreate_${Date.now()}`;
+        const quotedTempTable = this.quoteIdentifier(tempTableName);
+        const pkColumns = newColumns.filter((c) => c.isPk);
+        const isCompositePk = pkColumns.length > 1;
+        const colDefs = [];
+        for (const col of newColumns) {
+          let def = `${this.quoteIdentifier(col.name)} ${col.type || "TEXT"}`;
+          if (col.isPk && !isCompositePk) {
+            def += " PRIMARY KEY";
+          }
+          if (!col.nullable && (!col.isPk || isCompositePk)) {
+            def += " NOT NULL";
+          }
+          if (col.defaultValue !== void 0 && col.defaultValue !== null && col.defaultValue !== "") {
+            def += ` DEFAULT '${String(col.defaultValue).replace(/'/g, "''")}'`;
+          }
+          if (col.fkTarget && col.fkTarget.table && col.fkTarget.column) {
+            def += ` REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          }
+          if (col.isUnique && (!col.isPk || isCompositePk)) {
+            def += " UNIQUE";
+          }
+          colDefs.push(def);
+        }
+        if (isCompositePk) {
+          const pkColsQuoted = pkColumns.map((c) => this.quoteIdentifier(c.name)).join(", ");
+          colDefs.push(`PRIMARY KEY (${pkColsQuoted})`);
+        }
+        const createSql = `CREATE TABLE ${quotedTempTable} (
+  ${colDefs.join(",\n  ")}
+);`;
+        const newToOldMap = {};
+        for (const [oldName, newName] of Object.entries(renames)) {
+          newToOldMap[newName] = oldName;
+        }
+        const oldTableCols = db.prepare(`PRAGMA table_info(${quotedOldTable})`).all().map((r) => r.name);
+        const copyNewCols = [];
+        const copyOldCols = [];
+        for (const col of newColumns) {
+          const sourceOldName = newToOldMap[col.name] || col.name;
+          if (oldTableCols.includes(sourceOldName)) {
+            copyNewCols.push(this.quoteIdentifier(col.name));
+            copyOldCols.push(this.quoteIdentifier(sourceOldName));
+          }
+        }
+        let copySql = "";
+        if (copyNewCols.length > 0) {
+          copySql = `INSERT INTO ${quotedTempTable} (${copyNewCols.join(", ")}) SELECT ${copyOldCols.join(", ")} FROM ${quotedOldTable};`;
+        }
+        db.exec("PRAGMA foreign_keys = OFF;");
+        db.exec("BEGIN TRANSACTION;");
+        try {
+          db.exec(createSql);
+          if (copySql) {
+            db.exec(copySql);
+          }
+          db.exec(`DROP TABLE ${quotedOldTable};`);
+          db.exec(`ALTER TABLE ${quotedTempTable} RENAME TO ${quotedOldTable};`);
+          for (const idx of indexRows) {
+            if (!idx.sql) continue;
+            let idxSql = idx.sql;
+            for (const [oldName, newName] of Object.entries(renames)) {
+              idxSql = idxSql.replace(
+                new RegExp(`\\b${oldName}\\b`, "g"),
+                newName
+              );
+            }
+            try {
+              db.exec(idxSql);
+            } catch {
+            }
+          }
+          db.exec("COMMIT;");
+        } catch (err) {
+          db.exec("ROLLBACK;");
+          throw err;
+        } finally {
+          db.exec("PRAGMA foreign_keys = ON;");
         }
       }
     };
@@ -254,45 +408,54 @@ var init_postgres = __esm({
   "src/adapters/postgres.ts"() {
     "use strict";
     PostgresAdapter = class {
-      client;
-      connected = false;
+      connectionString;
+      pool = null;
       constructor(connection) {
-        this.client = new pg.Client({
-          connectionString: connection
-        });
+        this.connectionString = connection;
       }
-      async connectIfNecessary() {
-        if (!this.connected) {
-          await this.client.connect();
-          this.connected = true;
+      getPool() {
+        if (!this.pool) {
+          this.pool = new pg.Pool({
+            connectionString: this.connectionString
+          });
+          this.pool.on("error", () => {
+          });
         }
+        return this.pool;
       }
       quoteIdentifier(name) {
         return `"${name.replace(/"/g, '""')}"`;
       }
       async getStatus() {
         try {
-          await this.connectIfNecessary();
-          const dbRes = await this.client.query("SELECT current_database() as db, version() as version");
+          const dbRes = await this.getPool().query(
+            "SELECT current_database() as db, version() as version"
+          );
           const dbName = dbRes.rows[0]?.db;
           const version = dbRes.rows[0]?.version?.split(" ")[1] || dbRes.rows[0]?.version;
           let activeConnections = 0;
           let transactions = 0;
           let uptime = 0;
           try {
-            const uptimeRes = await this.client.query("SELECT EXTRACT(EPOCH FROM (now() - pg_postmaster_start_time())) as uptime");
+            const uptimeRes = await this.getPool().query(
+              "SELECT EXTRACT(EPOCH FROM (now() - pg_postmaster_start_time())) as uptime"
+            );
             uptime = parseInt(uptimeRes.rows[0]?.uptime || "0", 10);
           } catch (e) {
           }
           try {
-            const statRes = await this.client.query("SELECT sum(numbackends) as conns, sum(xact_commit + xact_rollback) as txs FROM pg_stat_database");
+            const statRes = await this.getPool().query(
+              "SELECT sum(numbackends) as conns, sum(xact_commit + xact_rollback) as txs FROM pg_stat_database"
+            );
             activeConnections = parseInt(statRes.rows[0]?.conns || "0", 10);
             transactions = parseInt(statRes.rows[0]?.txs || "0", 10);
           } catch (e) {
           }
           let sizeBytes = 0;
           try {
-            const sizeRes = await this.client.query("SELECT pg_database_size(current_database()) as size");
+            const sizeRes = await this.getPool().query(
+              "SELECT pg_database_size(current_database()) as size"
+            );
             sizeBytes = parseInt(sizeRes.rows[0]?.size || "0", 10);
           } catch (e) {
           }
@@ -314,18 +477,16 @@ var init_postgres = __esm({
         }
       }
       async getTables() {
-        await this.connectIfNecessary();
         const query = `
       SELECT tablename 
       FROM pg_catalog.pg_tables 
-      WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema'
+      WHERE schemaname = 'public'
       ORDER BY tablename;
     `;
-        const res = await this.client.query(query);
+        const res = await this.getPool().query(query);
         return res.rows.map((row) => row.tablename);
       }
       async getSchema(tableName) {
-        await this.connectIfNecessary();
         const query = `
       SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
              (SELECT count(*) 
@@ -336,6 +497,15 @@ var init_postgres = __esm({
                 AND kcu.table_name = c.table_name 
                 AND kcu.column_name = c.column_name
                 AND kcu.table_schema = c.table_schema) as is_pk,
+             (SELECT count(*)
+              FROM information_schema.table_constraints tc2
+              JOIN information_schema.constraint_column_usage ccu2
+                ON tc2.constraint_name = ccu2.constraint_name
+                AND tc2.table_schema = ccu2.table_schema
+              WHERE tc2.constraint_type = 'UNIQUE'
+                AND tc2.table_name = c.table_name
+                AND tc2.table_schema = c.table_schema
+                AND ccu2.column_name = c.column_name) as is_unique,
              (SELECT ccu.table_name || '.' || ccu.column_name
               FROM information_schema.table_constraints tc 
               JOIN information_schema.key_column_usage kcu
@@ -351,7 +521,7 @@ var init_postgres = __esm({
       WHERE c.table_name = $1 AND c.table_schema = 'public'
       ORDER BY c.ordinal_position;
     `;
-        const res = await this.client.query(query, [tableName]);
+        const res = await this.getPool().query(query, [tableName]);
         return res.rows.map((col) => {
           let fkTarget;
           if (col.fk_target) {
@@ -362,14 +532,14 @@ var init_postgres = __esm({
             name: col.column_name,
             type: col.data_type,
             isPk: parseInt(col.is_pk) > 0,
-            nullable: col.is_nullable === "YES",
+            nullable: parseInt(col.is_pk) > 0 ? false : col.is_nullable === "YES",
+            isUnique: parseInt(col.is_pk) > 0 || parseInt(col.is_unique) > 0,
             defaultValue: col.column_default != null ? String(col.column_default) : void 0,
             fkTarget
           };
         });
       }
       async getIndexes(tableName) {
-        await this.connectIfNecessary();
         const query = `
       SELECT
           i.relname as index_name,
@@ -388,10 +558,11 @@ var init_postgres = __esm({
           AND a.attnum = ANY(ix.indkey)
           AND t.relkind = 'r'
           AND t.relname = $1
+          AND t.relnamespace = 'public'::regnamespace
       ORDER BY
-          i.relname, a.attnum;
+          i.relname, array_position(ix.indkey, a.attnum);
     `;
-        const res = await this.client.query(query, [tableName]);
+        const res = await this.getPool().query(query, [tableName]);
         const rows = res.rows;
         const indexMap = /* @__PURE__ */ new Map();
         for (const row of rows) {
@@ -409,7 +580,6 @@ var init_postgres = __esm({
         return Array.from(indexMap.values());
       }
       async getData(tableName, limit = 50, offset = 0, whereClause, orderBy) {
-        await this.connectIfNecessary();
         const schema = await this.getSchema(tableName);
         const columns = schema.map((col) => col.name);
         let sql = `SELECT * FROM ${this.quoteIdentifier(tableName)}`;
@@ -420,38 +590,50 @@ var init_postgres = __esm({
           sql += ` ORDER BY ${this.quoteIdentifier(orderBy.col)} ${orderBy.asc ? "ASC" : "DESC"}`;
         }
         sql += ` LIMIT $1 OFFSET $2`;
-        const res = await this.client.query(sql, [limit, offset]);
+        const res = await this.getPool().query(sql, [limit, offset]);
         return { columns, rows: res.rows };
       }
       async query(sql) {
-        await this.connectIfNecessary();
-        const res = await this.client.query(sql);
+        const res = await this.getPool().query(sql);
         let columns = [];
         if (res.fields) {
           columns = res.fields.map((f) => f.name);
         }
-        return { columns, rows: res.rows || [] };
+        return {
+          columns,
+          rows: res.rows || [],
+          affectedRows: typeof res.rowCount === "number" ? res.rowCount : void 0
+        };
       }
       async executeSql(sql) {
-        await this.connectIfNecessary();
-        await this.client.query(sql);
+        await this.getPool().query(sql);
       }
       async close() {
-        if (this.connected) {
-          await this.client.end();
-          this.connected = false;
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
         }
       }
       async insert(tableName, rows) {
         if (rows.length === 0) return;
-        await this.connectIfNecessary();
-        const cols = Object.keys(rows[0]);
-        const colsQuoted = cols.map((c) => this.quoteIdentifier(c)).join(", ");
-        for (const row of rows) {
-          const placeholders = cols.map((_, i) => `$${i + 1}`).join(", ");
-          const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
-          const values = cols.map((c) => row[c]);
-          await this.client.query(sql, values);
+        const pool = this.getPool();
+        const client = await pool.connect();
+        try {
+          const cols = Object.keys(rows[0]);
+          const colsQuoted = cols.map((c) => this.quoteIdentifier(c)).join(", ");
+          await client.query("BEGIN");
+          for (const row of rows) {
+            const placeholders = cols.map((_, i) => `$${i + 1}`).join(", ");
+            const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
+            const values = cols.map((c) => row[c]);
+            await client.query(sql, values);
+          }
+          await client.query("COMMIT");
+        } catch (e) {
+          await client.query("ROLLBACK");
+          throw e;
+        } finally {
+          client.release();
         }
       }
     };
@@ -472,9 +654,13 @@ var init_mysql = __esm({
       }
       async getPool() {
         if (!this.pool) {
-          this.pool = mysql.createPool(this.connection);
+          this.pool = mysql.createPool({
+            uri: this.connection,
+            multipleStatements: true
+          });
           this.pool.on("connection", (connection) => {
-            connection.query("SET SESSION sql_mode = 'ANSI_QUOTES'");
+            connection.query("SET SESSION sql_mode = 'ANSI_QUOTES'").catch(() => {
+            });
           });
         }
         return this.pool;
@@ -485,21 +671,31 @@ var init_mysql = __esm({
       async getStatus() {
         try {
           const pool = await this.getPool();
-          const [dbRow] = await pool.query("SELECT DATABASE() as db, VERSION() as version");
+          const [dbRow] = await pool.query(
+            "SELECT DATABASE() as db, VERSION() as version"
+          );
           const dbName = dbRow[0]?.db;
           const version = dbRow[0]?.version;
-          const [statusRows] = await pool.query("SHOW GLOBAL STATUS WHERE Variable_name IN ('Threads_connected', 'Queries', 'Uptime')");
+          const [statusRows] = await pool.query(
+            "SHOW GLOBAL STATUS WHERE Variable_name IN ('Threads_connected', 'Queries', 'Uptime')"
+          );
           let activeConnections = 0;
           let queries = 0;
           let uptime = 0;
           for (const row of statusRows) {
-            if (row.Variable_name === "Threads_connected") activeConnections = parseInt(row.Value, 10);
-            if (row.Variable_name === "Queries") queries = parseInt(row.Value, 10);
-            if (row.Variable_name === "Uptime") uptime = parseInt(row.Value, 10);
+            if (row.Variable_name === "Threads_connected")
+              activeConnections = parseInt(row.Value, 10);
+            if (row.Variable_name === "Queries")
+              queries = parseInt(row.Value, 10);
+            if (row.Variable_name === "Uptime")
+              uptime = parseInt(row.Value, 10);
           }
           let sizeBytes = 0;
           if (dbName) {
-            const [sizeRow] = await pool.query("SELECT SUM(data_length + index_length) as size FROM information_schema.TABLES WHERE table_schema = ?", [dbName]);
+            const [sizeRow] = await pool.query(
+              "SELECT SUM(data_length + index_length) as size FROM information_schema.TABLES WHERE table_schema = ?",
+              [dbName]
+            );
             sizeBytes = parseInt(sizeRow[0]?.size || "0", 10);
           }
           return {
@@ -521,7 +717,9 @@ var init_mysql = __esm({
       }
       async getTables() {
         const pool = await this.getPool();
-        const [rows] = await pool.query("SHOW TABLES;");
+        const [rows] = await pool.query(
+          "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
+        );
         return rows.map((row) => Object.values(row)[0]);
       }
       async getSchema(tableName) {
@@ -555,7 +753,8 @@ var init_mysql = __esm({
             name: col.Field,
             type: col.Type,
             isPk: col.Key === "PRI",
-            nullable: col.Null === "YES",
+            nullable: col.Key === "PRI" ? false : col.Null === "YES",
+            isUnique: col.Key === "PRI" || col.Key === "UNI",
             defaultValue: col.Default != null ? String(col.Default) : void 0,
             enumValues,
             fkTarget: fk ? {
@@ -567,7 +766,9 @@ var init_mysql = __esm({
       }
       async getIndexes(tableName) {
         const pool = await this.getPool();
-        const [rows] = await pool.query(`SHOW INDEX FROM ${this.quoteIdentifier(tableName)}`);
+        const [rows] = await pool.query(
+          `SHOW INDEX FROM ${this.quoteIdentifier(tableName)}`
+        );
         const indexMap = /* @__PURE__ */ new Map();
         for (const row of rows) {
           if (row.Key_name === "PRIMARY") continue;
@@ -594,7 +795,10 @@ var init_mysql = __esm({
         if (orderBy) {
           sql += ` ORDER BY ${this.quoteIdentifier(orderBy.col)} ${orderBy.asc ? "ASC" : "DESC"}`;
         }
-        const [rows] = await pool.query(sql + " LIMIT ? OFFSET ?", [limit, offset]);
+        const [rows] = await pool.query(sql + " LIMIT ? OFFSET ?", [
+          limit,
+          offset
+        ]);
         return { columns, rows };
       }
       async query(sql) {
@@ -602,16 +806,17 @@ var init_mysql = __esm({
         const [rows, fields] = await pool.query(sql);
         let columns = [];
         let data = [];
+        let affectedRows = void 0;
         if (fields && Array.isArray(fields)) {
           columns = fields.map((f) => f.name);
           data = rows;
         } else {
           columns = ["Result"];
-          data = [
-            { Result: "Success", AffectedRows: rows.affectedRows }
-          ];
+          const count = rows.affectedRows ?? 0;
+          affectedRows = count;
+          data = [{ Result: "Success", AffectedRows: count }];
         }
-        return { columns, rows: data };
+        return { columns, rows: data, affectedRows };
       }
       async executeSql(sql) {
         const pool = await this.getPool();
@@ -626,13 +831,23 @@ var init_mysql = __esm({
       async insert(tableName, rows) {
         if (rows.length === 0) return;
         const pool = await this.getPool();
-        const cols = Object.keys(rows[0]);
-        const colsQuoted = cols.map((c) => this.quoteIdentifier(c)).join(", ");
-        const placeholders = cols.map(() => "?").join(", ");
-        const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
-        for (const row of rows) {
-          const values = cols.map((c) => row[c]);
-          await pool.query(sql, values);
+        const connection = await pool.getConnection();
+        try {
+          const cols = Object.keys(rows[0]);
+          const colsQuoted = cols.map((c) => this.quoteIdentifier(c)).join(", ");
+          const placeholders = cols.map(() => "?").join(", ");
+          const sql = `INSERT INTO ${this.quoteIdentifier(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
+          await connection.beginTransaction();
+          for (const row of rows) {
+            const values = cols.map((c) => row[c]);
+            await connection.query(sql, values);
+          }
+          await connection.commit();
+        } catch (e) {
+          await connection.rollback();
+          throw e;
+        } finally {
+          connection.release();
         }
       }
     };
@@ -1034,6 +1249,335 @@ var init_export = __esm({
   }
 });
 
+// src/core/seeder.ts
+function getRandomItem(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function getRandomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function getRandomFloat(min, max, decimals = 2) {
+  const str = (Math.random() * (max - min) + min).toFixed(decimals);
+  return parseFloat(str);
+}
+function getRandomDate(pastDays = 30) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - getRandomInt(0, pastDays));
+  d.setHours(getRandomInt(0, 23), getRandomInt(0, 59), getRandomInt(0, 59));
+  return d.toISOString().replace("T", " ").substring(0, 19);
+}
+function inferColumnStrategy(col) {
+  const name = col.name.toLowerCase();
+  const type = (col.type || "").toUpperCase();
+  if (col.fkTarget) {
+    return {
+      type: "fk",
+      label: `FK \u2192 ${col.fkTarget.table}.${col.fkTarget.column}`,
+      target: col.fkTarget
+    };
+  }
+  if (col.isPk && (type.includes("INT") || type === "SERIAL")) {
+    return {
+      type: "pk_auto",
+      label: "Auto-increment (Skip / Handled by DB)"
+    };
+  }
+  if (col.enumValues && col.enumValues.length > 0) {
+    return {
+      type: "enum",
+      label: `Enum (${col.enumValues.slice(0, 3).join(", ")})`,
+      values: col.enumValues
+    };
+  }
+  if (type.includes("BOOL") || type === "TINYINT(1)" || name.startsWith("is_") || name.startsWith("has_")) {
+    return { type: "boolean", label: "Boolean (true / false)" };
+  }
+  if (name.includes("email")) {
+    return { type: "email", label: "Email Address" };
+  }
+  if (name.includes("phone") || name.includes("tel") || name.includes("mobile")) {
+    return { type: "phone", label: "Phone Number" };
+  }
+  if (name.includes("first_name")) {
+    return { type: "first_name", label: "First Name" };
+  }
+  if (name.includes("last_name")) {
+    return { type: "last_name", label: "Last Name" };
+  }
+  if (name.includes("name") || name.includes("author") || name.includes("user")) {
+    return { type: "full_name", label: "Full Name" };
+  }
+  if (name.includes("avatar") || name.includes("image") || name.includes("photo") || name.includes("thumbnail")) {
+    return { type: "avatar", label: "Avatar / Image URL" };
+  }
+  if (name.includes("city")) {
+    return { type: "city", label: "City Name" };
+  }
+  if (name.includes("country")) {
+    return { type: "country", label: "Country Name" };
+  }
+  if (name.includes("address")) {
+    return { type: "address", label: "Street Address" };
+  }
+  if (name.includes("title") || name.includes("subject") || name.includes("headline")) {
+    return { type: "title", label: "Title / Headline" };
+  }
+  if (name.includes("desc") || name.includes("content") || name.includes("body") || name.includes("bio") || name.includes("comment") || type.includes("TEXT")) {
+    return { type: "paragraph", label: "Text / Paragraph" };
+  }
+  if (name.includes("status")) {
+    return { type: "status", label: "Status (active/pending...)" };
+  }
+  if (name.includes("role")) {
+    return { type: "role", label: "Role (admin/member...)" };
+  }
+  if (name.includes("price") || name.includes("amount") || name.includes("cost") || name.includes("salary") || type.includes("DECIMAL") || type.includes("FLOAT") || type.includes("REAL") || type.includes("NUMERIC")) {
+    return { type: "price", label: "Price / Currency" };
+  }
+  if (type.includes("DATE") || type.includes("TIME")) {
+    return { type: "date", label: "Date / Timestamp" };
+  }
+  if (type.includes("INT") || name.includes("age") || name.includes("count") || name.includes("qty") || name.includes("quantity")) {
+    return { type: "integer", label: "Integer (1 - 500)" };
+  }
+  if (type.includes("UUID")) {
+    return { type: "uuid", label: "UUID v4" };
+  }
+  return { type: "string", label: "Random Word / Code" };
+}
+function generateFieldValue(strategy, fkCache = {}) {
+  switch (strategy.type) {
+    case "pk_auto":
+      return void 0;
+    // Don't include in insert
+    case "fk": {
+      if (!strategy.target) return 1;
+      const { table, column } = strategy.target;
+      const ids = fkCache[`${table}.${column}`] || [];
+      if (ids.length > 0) {
+        return getRandomItem(ids);
+      }
+      return 1;
+    }
+    case "enum":
+      return strategy.values && strategy.values.length > 0 ? getRandomItem(strategy.values) : "Default";
+    case "boolean":
+      return Math.random() > 0.5 ? 1 : 0;
+    case "email": {
+      const f = getRandomItem(FIRST_NAMES).toLowerCase();
+      const l = getRandomItem(LAST_NAMES).toLowerCase();
+      return `${f}.${l}${getRandomInt(1, 99)}@${getRandomItem(DOMAINS)}`;
+    }
+    case "phone":
+      return `+1 (${getRandomInt(200, 999)}) ${getRandomInt(200, 999)}-${getRandomInt(1e3, 9999)}`;
+    case "first_name":
+      return getRandomItem(FIRST_NAMES);
+    case "last_name":
+      return getRandomItem(LAST_NAMES);
+    case "full_name":
+      return `${getRandomItem(FIRST_NAMES)} ${getRandomItem(LAST_NAMES)}`;
+    case "avatar":
+      return `https://picsum.photos/seed/${getRandomInt(100, 9999)}/200`;
+    case "city":
+      return getRandomItem(CITIES);
+    case "country":
+      return getRandomItem([
+        "United States",
+        "United Kingdom",
+        "Germany",
+        "Japan",
+        "Canada",
+        "Singapore"
+      ]);
+    case "address":
+      return `${getRandomInt(10, 999)} ${getRandomItem(["Market St", "Broadway", "Highland Ave", "Pine Rd", "Maple St"])}`;
+    case "title":
+      return getRandomItem(TITLES);
+    case "paragraph":
+      return getRandomItem(PARAGRAPHS);
+    case "status":
+      return getRandomItem(STATUSES);
+    case "role":
+      return getRandomItem(ROLES);
+    case "price":
+      return getRandomFloat(9.99, 499.99);
+    case "date":
+      return getRandomDate(30);
+    case "integer":
+      return getRandomInt(1, 500);
+    case "uuid":
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    default:
+      return `Item_${getRandomInt(100, 9999)}`;
+  }
+}
+async function getFkCandidates(adapter, schema) {
+  const fkCache = {};
+  for (const col of schema) {
+    if (col.fkTarget) {
+      const key = `${col.fkTarget.table}.${col.fkTarget.column}`;
+      if (!fkCache[key]) {
+        try {
+          const data = await adapter.getData(col.fkTarget.table, 50);
+          if (data && data.rows && data.rows.length > 0) {
+            fkCache[key] = data.rows.map((r) => r[col.fkTarget.column]).filter((v) => v !== null && v !== void 0);
+          }
+        } catch {
+          fkCache[key] = [];
+        }
+      }
+    }
+  }
+  return fkCache;
+}
+async function previewMockData(adapter, tableName, previewCount = 3) {
+  const schema = await adapter.getSchema(tableName);
+  const fkCache = await getFkCandidates(adapter, schema);
+  const rules = schema.map((col) => ({
+    column: col,
+    strategy: inferColumnStrategy(col)
+  }));
+  const previewRows = [];
+  for (let i = 0; i < previewCount; i++) {
+    const row = {};
+    for (const { column, strategy } of rules) {
+      const val = generateFieldValue(strategy, fkCache);
+      row[column.name] = val !== void 0 ? val : "(auto)";
+    }
+    previewRows.push(row);
+  }
+  return {
+    tableName,
+    rules,
+    previewRows
+  };
+}
+async function generateAndInsertMockData(adapter, tableName, count, onProgress) {
+  const schema = await adapter.getSchema(tableName);
+  const fkCache = await getFkCandidates(adapter, schema);
+  const rules = schema.map((col) => ({
+    column: col,
+    strategy: inferColumnStrategy(col)
+  }));
+  const activeRules = rules.filter((r) => r.strategy.type !== "pk_auto");
+  if (activeRules.length === 0) {
+    return 0;
+  }
+  const rowsToInsert = [];
+  for (let i = 0; i < count; i++) {
+    const row = {};
+    for (const { column, strategy } of activeRules) {
+      const val = generateFieldValue(strategy, fkCache);
+      if (val !== void 0) {
+        row[column.name] = val;
+      }
+    }
+    rowsToInsert.push(row);
+  }
+  const CHUNK_SIZE = 250;
+  let inserted = 0;
+  for (let i = 0; i < rowsToInsert.length; i += CHUNK_SIZE) {
+    const chunk = rowsToInsert.slice(i, i + CHUNK_SIZE);
+    await adapter.insert(tableName, chunk);
+    inserted += chunk.length;
+    if (onProgress) {
+      onProgress(inserted, count);
+    }
+  }
+  return inserted;
+}
+var FIRST_NAMES, LAST_NAMES, DOMAINS, CITIES, TITLES, PARAGRAPHS, STATUSES, ROLES;
+var init_seeder = __esm({
+  "src/core/seeder.ts"() {
+    "use strict";
+    FIRST_NAMES = [
+      "James",
+      "Mary",
+      "John",
+      "Patricia",
+      "Robert",
+      "Jennifer",
+      "Michael",
+      "Linda",
+      "William",
+      "Elizabeth",
+      "David",
+      "Barbara",
+      "Richard",
+      "Susan",
+      "Joseph",
+      "Jessica",
+      "Thomas",
+      "Sarah",
+      "Charles",
+      "Karen",
+      "Lucas",
+      "Emma",
+      "Alex",
+      "Olivia"
+    ];
+    LAST_NAMES = [
+      "Smith",
+      "Johnson",
+      "Williams",
+      "Brown",
+      "Jones",
+      "Garcia",
+      "Miller",
+      "Davis",
+      "Rodriguez",
+      "Martinez",
+      "Hernandez",
+      "Lopez",
+      "Gonzalez",
+      "Wilson",
+      "Anderson",
+      "Taylor"
+    ];
+    DOMAINS = [
+      "gmail.com",
+      "outlook.com",
+      "yahoo.com",
+      "example.com",
+      "company.io"
+    ];
+    CITIES = [
+      "New York",
+      "San Francisco",
+      "London",
+      "Tokyo",
+      "Berlin",
+      "Paris",
+      "Sydney",
+      "Toronto",
+      "Singapore",
+      "Amsterdam"
+    ];
+    TITLES = [
+      "Getting started with database design",
+      "10 tips for clean and maintainable code",
+      "Understanding indexing and performance",
+      "How to optimize complex SQL queries",
+      "Modern web application architecture",
+      "Best practices for database migrations",
+      "A deep dive into relational models",
+      "Improving frontend latency and responsiveness"
+    ];
+    PARAGRAPHS = [
+      "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+      "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.",
+      "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.",
+      "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    ];
+    STATUSES = ["active", "pending", "completed", "inactive", "archived"];
+    ROLES = ["admin", "editor", "member", "viewer", "moderator"];
+  }
+});
+
 // src/server/api.ts
 import { Hono } from "hono";
 import { spawn } from "child_process";
@@ -1111,7 +1655,9 @@ function registerApiRoutes(app, dbConfig) {
       const stats = {};
       for (const t of tables) {
         try {
-          const res = await adapter.query(`SELECT COUNT(*) as c FROM ${adapter.quoteIdentifier(t)}`);
+          const res = await adapter.query(
+            `SELECT COUNT(*) as c FROM ${adapter.quoteIdentifier(t)}`
+          );
           if (res && res.rows && res.rows.length > 0) {
             const row = res.rows[0];
             const countVal = Object.values(row)[0];
@@ -1137,6 +1683,33 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
+  api.post("/tables/:name/schema", async (c) => {
+    const tableName = c.req.param("name");
+    try {
+      const body = await c.req.json().catch(() => ({}));
+      const { columns, renames } = body;
+      if (!columns || !Array.isArray(columns)) {
+        return c.json(
+          { success: false, error: "Invalid columns parameter" },
+          400
+        );
+      }
+      if (adapter.recreateTable) {
+        await adapter.recreateTable(tableName, columns, renames || {});
+        return c.json({ success: true });
+      } else {
+        return c.json(
+          {
+            success: false,
+            error: "Table recreation is currently supported for SQLite"
+          },
+          400
+        );
+      }
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
   api.get("/tables/:name/indexes", async (c) => {
     const tableName = c.req.param("name");
     try {
@@ -1158,12 +1731,42 @@ function registerApiRoutes(app, dbConfig) {
       orderBy = { col: orderCol, asc: orderAscStr !== "false" };
     }
     try {
-      const data = await adapter.getData(tableName, limit, offset, whereClause, orderBy);
+      const data = await adapter.getData(
+        tableName,
+        limit,
+        offset,
+        whereClause,
+        orderBy
+      );
       return c.json({ success: true, data });
     } catch (e) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
+  api.get("/tables/:name/mock/preview", async (c) => {
+    try {
+      const tableName = c.req.param("name");
+      const data = await previewMockData(adapter, tableName, 3);
+      return c.json({ success: true, data });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
+  api.post("/tables/:name/mock", async (c) => {
+    try {
+      const tableName = c.req.param("name");
+      const body = await c.req.json().catch(() => ({}));
+      const count = Math.min(Math.max(Number(body.count) || 10, 1), 1e3);
+      const inserted = await generateAndInsertMockData(
+        adapter,
+        tableName,
+        count
+      );
+      return c.json({ success: true, count: inserted });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
   api.post("/query", async (c) => {
     try {
       const { sql } = await c.req.json();
@@ -1173,34 +1776,26 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
-  api.get("/tables/:name/export", async (c) => {
-    const tableName = c.req.param("name");
-    const format = c.req.query("format") || "csv";
-    const whereClause = c.req.query("where") || "";
-    const orderCol = c.req.query("orderCol");
-    const orderAscStr = c.req.query("orderAsc");
-    let orderBy = void 0;
-    if (orderCol) {
-      orderBy = { col: orderCol, asc: orderAscStr !== "false" };
-    }
+  api.post("/query/export", async (c) => {
     try {
-      const batchSize = 1e3;
-      let batchOffset = 0;
-      const allRows = [];
-      let exportColumns = [];
-      let lastBatch;
-      do {
-        lastBatch = await adapter.getData(tableName, batchSize, batchOffset, whereClause, orderBy);
-        if (exportColumns.length === 0) exportColumns = lastBatch.columns;
-        allRows.push(...lastBatch.rows);
-        batchOffset += batchSize;
-      } while (lastBatch.rows.length === batchSize);
-      const rows = allRows;
+      const { sql } = await c.req.json();
+      if (!sql) {
+        return c.json(
+          { success: false, error: "No SQL query provided" },
+          400
+        );
+      }
+      const result = await adapter.query(sql);
+      const rows = result.rows;
       const timestamp = getDatetimeStr();
-      const exportFilename = `${tableName}_export_${timestamp}`;
+      const format = c.req.query("format") || "csv";
+      const exportFilename = `query_result_${timestamp}`;
       if (format === "json") {
         const jsonStr = JSON.stringify(rows, null, 2);
-        c.header("Content-Disposition", `attachment; filename="${exportFilename}.json"`);
+        c.header(
+          "Content-Disposition",
+          `attachment; filename="${exportFilename}.json"`
+        );
         c.header("Content-Type", "application/json");
         return c.body(jsonStr);
       } else {
@@ -1221,10 +1816,106 @@ function registerApiRoutes(app, dbConfig) {
           });
           csvStr = [headerStr, ...rowStrs].join("\n");
         }
-        c.header("Content-Disposition", `attachment; filename="${exportFilename}.csv"`);
+        c.header(
+          "Content-Disposition",
+          `attachment; filename="${exportFilename}.csv"`
+        );
         c.header("Content-Type", "text/csv");
         return c.body(csvStr);
       }
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
+  api.get("/tables/:name/export", async (c) => {
+    const tableName = c.req.param("name");
+    const format = c.req.query("format") || "csv";
+    const whereClause = c.req.query("where") || "";
+    const orderCol = c.req.query("orderCol");
+    const orderAscStr = c.req.query("orderAsc");
+    let orderBy = void 0;
+    if (orderCol) {
+      orderBy = { col: orderCol, asc: orderAscStr !== "false" };
+    }
+    try {
+      const timestamp = getDatetimeStr();
+      const exportFilename = `${tableName}_export_${timestamp}`;
+      const stream = new ReadableStream({
+        async start(controller) {
+          const encoder = new TextEncoder();
+          try {
+            const batchSize = 1e3;
+            let batchOffset = 0;
+            let hasMore = true;
+            let isFirstChunk = true;
+            if (format === "json") {
+              controller.enqueue(encoder.encode("[\n"));
+            }
+            while (hasMore) {
+              const batch = await adapter.getData(
+                tableName,
+                batchSize,
+                batchOffset,
+                whereClause,
+                orderBy
+              );
+              if (batch.rows.length === 0) {
+                break;
+              }
+              if (format === "json") {
+                let jsonStr = "";
+                for (let i = 0; i < batch.rows.length; i++) {
+                  if (!isFirstChunk || i > 0) {
+                    jsonStr += ",\n";
+                  }
+                  jsonStr += JSON.stringify(batch.rows[i], null, 2);
+                }
+                controller.enqueue(encoder.encode(jsonStr));
+              } else {
+                let csvStr = "";
+                const headers = batch.columns || Object.keys(batch.rows[0] || {});
+                if (isFirstChunk && headers.length > 0) {
+                  csvStr += headers.join(",") + "\n";
+                }
+                for (const r of batch.rows) {
+                  const rowStr = headers.map((h) => {
+                    let val = r[h];
+                    if (val === null || val === void 0)
+                      val = "";
+                    val = String(val);
+                    if (val.includes(",") || val.includes('"') || val.includes("\n")) {
+                      val = `"${val.replace(/"/g, '""')}"`;
+                    }
+                    return val;
+                  }).join(",");
+                  csvStr += rowStr + "\n";
+                }
+                controller.enqueue(encoder.encode(csvStr));
+              }
+              isFirstChunk = false;
+              batchOffset += batchSize;
+              if (batch.rows.length < batchSize) {
+                hasMore = false;
+              }
+            }
+            if (format === "json") {
+              controller.enqueue(encoder.encode("\n]"));
+            }
+            controller.close();
+          } catch (e) {
+            controller.error(e);
+          }
+        }
+      });
+      c.header(
+        "Content-Disposition",
+        `attachment; filename="${exportFilename}.${format}"`
+      );
+      c.header(
+        "Content-Type",
+        format === "json" ? "application/json" : "text/csv"
+      );
+      return c.body(stream);
     } catch (e) {
       return c.text(`Export Failed: ${e.message}`, 500);
     }
@@ -1239,13 +1930,19 @@ function registerApiRoutes(app, dbConfig) {
         return new Promise((resolve, reject) => {
           const cp = spawn(cmd, args);
           let started = false;
+          const stream = nodeToWebStream(cp.stdout);
           cp.on("error", (err) => {
-            if (!started) reject(new Error(`Native tool '${cmd}' not found. Please install ${envName}.`));
+            if (!started)
+              reject(
+                new Error(
+                  `Native tool '${cmd}' not found. Please install ${envName}.`
+                )
+              );
           });
           setTimeout(() => {
             if (!cp.killed) {
               started = true;
-              resolve(nodeToWebStream(cp.stdout));
+              resolve(stream);
             }
           }, 100);
         });
@@ -1257,7 +1954,11 @@ function registerApiRoutes(app, dbConfig) {
         filename = `${baseName}_backup_${timeStr}.sql`;
         if (type === "sqlite") {
           const dbPath = url.replace("file:", "");
-          stream = await executeNativeDump("sqlite3", [dbPath, ".dump"], "SQLite CLI");
+          stream = await executeNativeDump(
+            "sqlite3",
+            [dbPath, ".dump"],
+            "SQLite CLI"
+          );
         } else if (type === "mysql") {
           const parsed = new URL(url);
           const user = parsed.username;
@@ -1265,23 +1966,44 @@ function registerApiRoutes(app, dbConfig) {
           const host = parsed.hostname;
           const port = parsed.port || "3306";
           const dbname = parsed.pathname.substring(1);
-          stream = await executeNativeDump("mysqldump", ["-u", user, `-p${pass}`, "-h", host, "-P", port, dbname], "MySQL Client");
+          stream = await executeNativeDump(
+            "mysqldump",
+            ["-u", user, `-p${pass}`, "-h", host, "-P", port, dbname],
+            "MySQL Client"
+          );
         } else if (type === "postgres") {
-          stream = await executeNativeDump("pg_dump", [url], "PostgreSQL CLI");
+          stream = await executeNativeDump(
+            "pg_dump",
+            [url],
+            "PostgreSQL CLI"
+          );
         } else {
           throw new Error("Unsupported database type for native export");
         }
-        c.header("Content-Disposition", `attachment; filename="${filename}"`);
+        c.header(
+          "Content-Disposition",
+          `attachment; filename="${filename}"`
+        );
         c.header("Content-Type", "application/sql");
         return c.body(stream);
       } catch (err) {
-        if (type === "sqlite" && err.message.includes("Native tool")) {
-          const sql = await generateSqliteDump(adapter);
+        if (err.message.includes("Native tool")) {
+          let fallbackStream;
           const baseName = getDbName();
           const timeStr = getDatetimeStr();
-          c.header("Content-Disposition", `attachment; filename="${baseName}_backup_${timeStr}.sql"`);
+          if (type === "sqlite") {
+            fallbackStream = generateSqliteDumpStream(adapter);
+          } else if (type === "mysql") {
+            fallbackStream = generateMysqlDumpStream(adapter);
+          } else {
+            throw err;
+          }
+          c.header(
+            "Content-Disposition",
+            `attachment; filename="${baseName}_backup_${timeStr}.sql"`
+          );
           c.header("Content-Type", "application/sql");
-          return c.body(sql);
+          return c.body(fallbackStream);
         }
         throw err;
       }
@@ -1291,6 +2013,89 @@ function registerApiRoutes(app, dbConfig) {
       return c.body(errorHtml);
     }
   });
+  api.post("/database/import", async (c) => {
+    try {
+      const body = await c.req.parseBody();
+      const file = body["file"];
+      if (!(file instanceof File)) {
+        return c.json({ success: false, error: "No file uploaded" }, 400);
+      }
+      const sqlContent = await file.text();
+      const type = dbConfig.type;
+      const url = dbConfig.targetUrl;
+      const executeNativeImport = (cmd, args, fileContent, envName) => {
+        return new Promise((resolve, reject) => {
+          const cp = spawn(cmd, args);
+          let started = false;
+          let errStr = "";
+          cp.on("error", (err) => {
+            if (!started)
+              reject(
+                new Error(
+                  `Native tool '${cmd}' not found. Please install ${envName}.`
+                )
+              );
+          });
+          cp.stderr.on("data", (d) => errStr += d.toString());
+          cp.on("close", (code) => {
+            if (code === 0) resolve();
+            else reject(new Error(`Native import failed: ${errStr}`));
+          });
+          cp.stdin.write(fileContent);
+          cp.stdin.end();
+          started = true;
+        });
+      };
+      try {
+        if (type === "sqlite") {
+          const dbPath = url.replace("file:", "");
+          await executeNativeImport(
+            "sqlite3",
+            [dbPath],
+            sqlContent,
+            "SQLite CLI"
+          );
+        } else if (type === "mysql") {
+          const parsed = new URL(url);
+          const user = parsed.username;
+          const pass = parsed.password;
+          const host = parsed.hostname;
+          const port = parsed.port || "3306";
+          const dbname = parsed.pathname.substring(1);
+          await executeNativeImport(
+            "mysql",
+            ["-u", user, `-p${pass}`, "-h", host, "-P", port, dbname],
+            sqlContent,
+            "MySQL Client"
+          );
+        } else if (type === "postgres") {
+          await executeNativeImport(
+            "psql",
+            [url],
+            sqlContent,
+            "PostgreSQL CLI"
+          );
+        } else {
+          throw new Error("Unsupported database type for native import");
+        }
+      } catch (err) {
+        if (err.message.includes("Native tool")) {
+          await adapter.executeSql(sqlContent);
+        } else {
+          throw err;
+        }
+      }
+      return c.json({
+        success: true,
+        message: "Import completed successfully"
+      });
+    } catch (e) {
+      return c.json(
+        { success: false, error: `Import Failed: ${e.message}` },
+        500
+      );
+    }
+  });
   api.get("/database/dictionary", async (c) => {
     try {
       const dbName = getDbName();
@@ -1313,7 +2118,10 @@ function registerApiRoutes(app, dbConfig) {
         md += `
 `;
       }
-      c.header("Content-Disposition", `attachment; filename="${dbName}_dictionary_${getDatetimeStr()}.md"`);
+      c.header(
+        "Content-Disposition",
+        `attachment; filename="${dbName}_dictionary_${getDatetimeStr()}.md"`
+      );
       c.header("Content-Type", "text/markdown");
       return c.body(md);
     } catch (e) {
@@ -1327,17 +2135,25 @@ function registerApiRoutes(app, dbConfig) {
       const filename = `${getDbName()}_schema_${getDatetimeStr()}.sql`;
       if (type === "sqlite") {
         let sqlDump = "-- Drixio SQLite Schema Dump\n\n";
-        const tablesResult = await adapter.query("SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';");
+        const tablesResult = await adapter.query(
+          "SELECT sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';"
+        );
         for (const row of tablesResult.rows) {
           if (row.sql) sqlDump += `${row.sql};
 
 `;
         }
-        c.header("Content-Disposition", `attachment; filename="${filename}"`);
+        c.header(
+          "Content-Disposition",
+          `attachment; filename="${filename}"`
+        );
         c.header("Content-Type", "application/sql");
         return c.body(sqlDump);
       } else {
-        return c.text("Schema-only export for this DB type currently requires manual DDL extraction. Coming soon!", 501);
+        return c.text(
+          "Schema-only export for this DB type currently requires manual DDL extraction. Coming soon!",
+          501
+        );
       }
     } catch (e) {
       return c.text(`Schema Export Failed: ${e.message}`, 500);
@@ -1345,38 +2161,150 @@ function registerApiRoutes(app, dbConfig) {
   });
   app.route("/api", api);
 }
-async function generateSqliteDump(adapter) {
-  let sqlDump = "-- Drixio SQLite Fallback Backup\n\n";
-  try {
-    const tablesResult = await adapter.query("SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';");
-    for (const row of tablesResult.rows) {
-      if (!row.sql) continue;
-      sqlDump += `${row.sql};
+function generateSqliteDumpStream(adapter) {
+  return new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      try {
+        controller.enqueue(
+          encoder.encode("-- Drixio SQLite Fallback Backup\n\n")
+        );
+        const tablesResult = await adapter.query(
+          "SELECT name, sql FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';"
+        );
+        for (const row of tablesResult.rows) {
+          if (!row.sql) continue;
+          controller.enqueue(encoder.encode(`${row.sql};
 
+`));
+          const tableName = row.name;
+          const batchSize = 1e3;
+          let offset = 0;
+          let hasMore = true;
+          while (hasMore) {
+            const batch = await adapter.getData(
+              tableName,
+              batchSize,
+              offset
+            );
+            if (batch.rows.length === 0) {
+              break;
+            }
+            let insertStrs = "";
+            for (const d of batch.rows) {
+              const keys = Object.keys(d).map((k) => adapter.quoteIdentifier(k)).join(", ");
+              const vals = Object.values(d).map((v) => {
+                if (v === null) return "NULL";
+                if (typeof v === "number") return v;
+                return `'${String(v).replace(/'/g, "''")}'`;
+              }).join(", ");
+              insertStrs += `INSERT INTO ${adapter.quoteIdentifier(tableName)} (${keys}) VALUES (${vals});
 `;
-      const data = await adapter.query(`SELECT * FROM ${adapter.quoteIdentifier(row.name)}`);
-      for (const d of data.rows) {
-        const keys = Object.keys(d).map((k) => adapter.quoteIdentifier(k)).join(", ");
-        const vals = Object.values(d).map((v) => {
-          if (v === null) return "NULL";
-          if (typeof v === "number") return v;
-          return `'${String(v).replace(/'/g, "''")}'`;
-        }).join(", ");
-        sqlDump += `INSERT INTO ${adapter.quoteIdentifier(row.name)} (${keys}) VALUES (${vals});
-`;
+            }
+            controller.enqueue(encoder.encode(insertStrs));
+            offset += batchSize;
+            if (batch.rows.length < batchSize) {
+              hasMore = false;
+            }
+          }
+          controller.enqueue(encoder.encode("\n"));
+        }
+        controller.close();
+      } catch (e) {
+        controller.enqueue(
+          encoder.encode(`-- Error generating backup: ${e}
+`)
+        );
+        controller.close();
       }
-      sqlDump += "\n";
     }
-  } catch (e) {
-    sqlDump += `-- Error generating backup: ${e}
+  });
+}
+function generateMysqlDumpStream(adapter) {
+  return new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      try {
+        controller.enqueue(
+          encoder.encode("-- Drixio MySQL Fallback Backup\n\n")
+        );
+        const tables = await adapter.getTables();
+        for (const table of tables) {
+          try {
+            const createTableResult = await adapter.query(
+              `SHOW CREATE TABLE ${adapter.quoteIdentifier(table)}`
+            );
+            if (createTableResult.rows && createTableResult.rows.length > 0) {
+              const row = createTableResult.rows[0];
+              const vals = Object.values(row);
+              const createSql = row["Create Table"] || row["Create View"] || (vals.length > 1 ? vals[1] : null);
+              if (createSql) {
+                controller.enqueue(encoder.encode(`${createSql};
+
+`));
+              }
+            }
+            const batchSize = 1e3;
+            let offset = 0;
+            let hasMore = true;
+            while (hasMore) {
+              const batch = await adapter.getData(
+                table,
+                batchSize,
+                offset
+              );
+              if (batch.rows.length === 0) {
+                break;
+              }
+              let insertStrs = "";
+              for (const d of batch.rows) {
+                const keys = Object.keys(d).map((k) => adapter.quoteIdentifier(k)).join(", ");
+                const vals = Object.values(d).map((v) => {
+                  if (v === null) return "NULL";
+                  if (typeof v === "number") return v;
+                  let str = String(v);
+                  str = str.replace(/\\/g, "\\\\");
+                  str = str.replace(/'/g, "''");
+                  str = str.replace(/\n/g, "\\n");
+                  str = str.replace(/\r/g, "\\r");
+                  return `'${str}'`;
+                }).join(", ");
+                insertStrs += `INSERT INTO ${adapter.quoteIdentifier(table)} (${keys}) VALUES (${vals});
 `;
-  }
-  return sqlDump;
+              }
+              controller.enqueue(encoder.encode(insertStrs));
+              offset += batchSize;
+              if (batch.rows.length < batchSize) {
+                hasMore = false;
+              }
+            }
+            controller.enqueue(encoder.encode("\n"));
+          } catch (tableErr) {
+            controller.enqueue(
+              encoder.encode(
+                `-- Error backing up table ${table}: ${tableErr}
+
+`
+              )
+            );
+          }
+        }
+        controller.close();
+      } catch (e) {
+        controller.enqueue(
+          encoder.encode(`-- Error generating backup: ${e}
+`)
+        );
+        controller.close();
+      }
+    }
+  });
 }
 var init_api = __esm({
   "src/server/api.ts"() {
     "use strict";
     init_factory();
+    init_seeder();
   }
 });
 
@@ -1658,40 +2586,6 @@ __export(seed_exports, {
   runSeedCommand: () => runSeedCommand
 });
 import pc14 from "picocolors";
-function generateRandomString(length) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < length; i++) result += chars.charAt(Math.floor(Math.random() * chars.length));
-  return result;
-}
-function generateRandomEmail() {
-  const domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com"];
-  const name = generateRandomString(8).toLowerCase();
-  const domain = domains[Math.floor(Math.random() * domains.length)];
-  return `${name}@${domain}`;
-}
-function generateFakeData(col) {
-  const name = col.name.toLowerCase();
-  if (name.includes("email")) return generateRandomEmail();
-  if (name.includes("phone")) return `+1${Math.floor(Math.random() * 9e9 + 1e9)}`;
-  if (name.includes("name")) return `User_${generateRandomString(5)}`;
-  if (name.includes("url") || name.includes("link")) return `https://example.com/${generateRandomString(6)}`;
-  if (name.includes("date") || name.includes("time") || name.includes("created") || name.includes("updated")) {
-    const d = new Date(Date.now() - Math.floor(Math.random() * 1e10));
-    return d.toISOString().replace("T", " ").slice(0, 19);
-  }
-  const type = col.type.toLowerCase();
-  if (type.includes("int") || type.includes("num") || type.includes("float") || type.includes("double")) {
-    return Math.floor(Math.random() * 1e3);
-  }
-  if (type.includes("bool") || type === "tinyint(1)") {
-    return Math.random() > 0.5;
-  }
-  if (type.includes("char") || type.includes("text") || type.includes("string")) {
-    return generateRandomString(10);
-  }
-  return generateRandomString(5);
-}
 async function runSeedCommand(dbConfig, args) {
   if (dbConfig.type === "unknown") {
     console.log(pc14.red("Error: No database connection found. Cannot run seed."));
@@ -1708,7 +2602,7 @@ async function runSeedCommand(dbConfig, args) {
       process.exit(1);
     }
     tableName = await select11({
-      message: "Which table do you want to seed with fake data?",
+      message: "Which table do you want to seed with realistic fake data?",
       choices: allTables.map((t) => ({ name: t, value: t }))
     });
   }
@@ -1722,52 +2616,23 @@ async function runSeedCommand(dbConfig, args) {
     }
   }
   console.log(pc14.cyan(`
-Analyzing schema for table '${tableName}'...`));
-  let schema;
+Analyzing schema & foreign keys for table '${tableName}'...`));
   try {
-    schema = await adapter.getSchema(tableName);
-  } catch (e) {
-    console.log(pc14.red(`Error: ${e.message}`));
-    process.exit(1);
-  }
-  const targetCols = schema.filter((c) => !c.isPk);
-  if (targetCols.length === 0) {
-    console.log(pc14.yellow("Table only has Primary Key columns. Seeding might fail if they don't auto-increment."));
-  }
-  console.log(pc14.cyan(`Generating ${count} records...`));
-  const rowsToInsert = [];
-  for (let i = 0; i < count; i++) {
-    const row = {};
-    for (const col of targetCols.length > 0 ? targetCols : schema) {
-      row[col.name] = generateFakeData(col);
-    }
-    rowsToInsert.push(row);
-  }
-  const CHUNK_SIZE = 500;
-  let inserted = 0;
-  try {
-    if (dbConfig.type === "sqlite") await adapter.executeSql("PRAGMA foreign_keys = OFF;");
-    else if (dbConfig.type === "mysql") await adapter.executeSql("SET FOREIGN_KEY_CHECKS = 0;");
-    else if (dbConfig.type === "postgres") await adapter.executeSql("SET session_replication_role = replica;");
-    for (let i = 0; i < rowsToInsert.length; i += CHUNK_SIZE) {
-      const chunk = rowsToInsert.slice(i, i + CHUNK_SIZE);
-      await adapter.insert(tableName, chunk);
-      inserted += chunk.length;
-      process.stdout.write(`\r${pc14.dim(`Progress: ${inserted} / ${count}`)}`);
-    }
+    const inserted = await generateAndInsertMockData(
+      adapter,
+      tableName,
+      count,
+      (current, total) => {
+        process.stdout.write(`\r${pc14.dim(`Progress: ${current} / ${total}`)}`);
+      }
+    );
     console.log(pc14.green(`
 
-\u2714 Successfully seeded ${inserted} fake records into ${tableName}!`));
+\u2714 Successfully generated and seeded ${inserted} realistic records into ${tableName}!`));
   } catch (e) {
     console.log(pc14.red(`
 \u2718 Seed failed: ${e.message}`));
   } finally {
-    try {
-      if (dbConfig.type === "sqlite") await adapter.executeSql("PRAGMA foreign_keys = ON;");
-      else if (dbConfig.type === "mysql") await adapter.executeSql("SET FOREIGN_KEY_CHECKS = 1;");
-      else if (dbConfig.type === "postgres") await adapter.executeSql("SET session_replication_role = DEFAULT;");
-    } catch (e) {
-    }
     await adapter.close();
   }
   process.exit(0);
@@ -1776,6 +2641,7 @@ var init_seed = __esm({
   "subcommands/seed.ts"() {
     "use strict";
     init_factory();
+    init_seeder();
   }
 });