drixio 1.1.10 → 1.2.0

package/dist/cli.js

@@ -283,6 +283,23 @@ async function saveDatabaseUrl(url) {
     );
   }
 }
+function assembleConnectionUrl(type, host, port, user, password, database) {
+  const targetHost = host || "localhost";
+  const targetPort = port || (type === "postgres" ? "5432" : "3306");
+  const targetUser = user || (type === "postgres" ? "postgres" : "root");
+  const auth = password ? `${encodeURIComponent(targetUser)}:${encodeURIComponent(password)}` : encodeURIComponent(targetUser);
+  const defaultDb = type === "postgres" ? "postgres" : "";
+  const dbNameStr = database || defaultDb;
+  return `${type}://${auth}@${targetHost}:${targetPort}/${dbNameStr}`;
+}
+function resolveLocalDbPath(targetUrl, cwd) {
+  const cleanPath = targetUrl.replace(/^file:/, "").trim();
+  return path.isAbsolute(cleanPath) ? cleanPath : path.resolve(cwd, cleanPath);
+}
+function isConnectionString(url) {
+  const trimmed = url.trim();
+  return trimmed.startsWith("postgres://") || trimmed.startsWith("postgresql://") || trimmed.startsWith("mysql://");
+}
 var DB_ENV_KEYS;
 var init_loader = __esm({
   "src/logic/loader.ts"() {
@@ -307,11 +324,319 @@ var init_loader = __esm({
   }
 });
 
+// src/logic/dialect.ts
+function getDialect(type) {
+  switch (type) {
+    case "sqlite":
+      return new SqliteDialect();
+    case "postgres":
+      return new PostgresDialect();
+    case "mysql":
+      return new MysqlDialect();
+    default:
+      return new SqliteDialect();
+  }
+}
+function buildSearchWhereClause(adapter, dbType, columns, searchInput) {
+  const searchVal = (searchInput || "").trim();
+  if (!searchVal) return "";
+  const isSqlCondition = /[=<>]|LIKE|IN|AND|OR/i.test(searchVal);
+  if (isSqlCondition) {
+    return searchVal;
+  }
+  const dialect = getDialect(dbType);
+  const strCols = columns.filter((c) => {
+    const t = c.type.toLowerCase();
+    return t.includes("char") || t.includes("text") || t.includes("string") || t.includes("uuid");
+  });
+  if (strCols.length > 0) {
+    const likeOp = dbType === "postgres" ? "ILIKE" : "LIKE";
+    const escaped = dialect.escapeString(searchVal);
+    const conditions = strCols.map(
+      (c) => `${adapter.quoteIdentifier(c.name)} ${likeOp} '%${escaped}%'`
+    );
+    return conditions.join(" OR ");
+  }
+  if (columns.length > 0) {
+    const col = columns[0];
+    const escaped = dialect.escapeString(searchVal);
+    return `${adapter.quoteIdentifier(col.name)} = '${escaped}'`;
+  }
+  return "";
+}
+function formatSqlDefaultValue(rawDefault) {
+  if (rawDefault === void 0 || rawDefault === null) return null;
+  let trimmed = String(rawDefault).trim();
+  if (!trimmed || trimmed.toLowerCase() === "null" || trimmed === "-") {
+    return null;
+  }
+  while (trimmed.startsWith("''") && trimmed.endsWith("''") && trimmed.length > 4) {
+    trimmed = trimmed.slice(1, -1);
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return trimmed;
+  }
+  const lower = trimmed.toLowerCase();
+  if (lower === "true" || lower === "false") {
+    return lower.toUpperCase();
+  }
+  const upper = trimmed.toUpperCase();
+  if (upper === "CURRENT_TIMESTAMP" || upper === "CURRENT_DATE" || upper === "CURRENT_TIME" || upper === "NOW()" || upper === "TIMESTAMP" || upper.startsWith("CURRENT_TIMESTAMP") || upper.startsWith("NOW()") || upper.startsWith("GEN_RANDOM_UUID(") || upper.startsWith("UUID_GENERATE_") || upper.startsWith("UUID(") || trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    return upper === "TIMESTAMP" ? "CURRENT_TIMESTAMP" : trimmed;
+  }
+  const pgCastMatch = trimmed.match(/^('[\s\S]*')(?:::[\w\s()]+)$/);
+  if (pgCastMatch) {
+    return pgCastMatch[1];
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") && trimmed.length >= 2) {
+    return trimmed;
+  }
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+    const inner = trimmed.slice(1, -1).replace(/'/g, "''");
+    return `'${inner}'`;
+  }
+  const escaped = trimmed.replace(/'/g, "''");
+  return `'${escaped}'`;
+}
+function generateExplainQuery(rawSql, dbType) {
+  let cleanSql = rawSql.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trim().replace(/;+$/, "").trim();
+  if (!cleanSql) {
+    return { sql: "", error: "SQL query is empty after stripping comments" };
+  }
+  if (/^(CREATE|DROP|ALTER|TRUNCATE)\s+/i.test(cleanSql)) {
+    return {
+      sql: "",
+      error: "DDL statements (CREATE, DROP, ALTER, TRUNCATE) do not have query execution plans to explain."
+    };
+  }
+  const hasUserExplain = /^EXPLAIN\b/i.test(cleanSql);
+  let targetSql = cleanSql;
+  if (hasUserExplain) {
+    targetSql = cleanSql.replace(/^EXPLAIN\s+(QUERY\s+PLAN\s+)?/i, "").replace(
+      /^\((ANALYZE|COSTS|VERBOSE|BUFFERS|FORMAT\s+\w+|,|\s)+\)\s*/i,
+      ""
+    ).trim();
+  }
+  let explainSql = "";
+  const isDmlWrite = /^(INSERT|UPDATE|DELETE)\s+/i.test(targetSql);
+  if (dbType === "sqlite") {
+    explainSql = `EXPLAIN QUERY PLAN ${targetSql}`;
+  } else if (dbType === "postgres") {
+    if (isDmlWrite) {
+      explainSql = `EXPLAIN (COSTS, VERBOSE) ${targetSql}`;
+    } else {
+      explainSql = `EXPLAIN (ANALYZE, COSTS, VERBOSE, BUFFERS) ${targetSql}`;
+    }
+  } else if (dbType === "mysql") {
+    explainSql = `EXPLAIN ${targetSql}`;
+  } else {
+    explainSql = `EXPLAIN ${targetSql}`;
+  }
+  return { sql: explainSql };
+}
+var SqliteDialect, PostgresDialect, MysqlDialect;
+var init_dialect = __esm({
+  "src/logic/dialect.ts"() {
+    "use strict";
+    SqliteDialect = class {
+      quoteIdentifier(name) {
+        return `"${name}"`;
+        return `"${name.replace(/"/g, '""')}"`;
+      }
+      escapeString(val) {
+        return val.replace(/'/g, "''");
+      }
+      buildCreateTable(tableName, columns) {
+        const lines = columns.map((col) => {
+          const isPk = !!(col.isPk || col.primaryKey);
+          const tLower = col.type.toLowerCase();
+          let typeStr = col.type;
+          if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
+          else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
+          else if (tLower === "boolean" || tLower === "bool")
+            typeStr = "BOOLEAN";
+          else if (tLower === "decimal" || tLower === "numeric" || tLower === "float" || tLower === "double")
+            typeStr = "REAL";
+          else if (tLower === "datetime" || tLower === "timestamp")
+            typeStr = "DATETIME";
+          else if (col.enumValues && col.enumValues.length > 0) {
+            typeStr = `TEXT CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
+          }
+          if (isPk && (tLower.includes("int") || typeStr === "INTEGER")) {
+            typeStr = "INTEGER PRIMARY KEY AUTOINCREMENT";
+          } else if (isPk) {
+            typeStr += " PRIMARY KEY";
+          } else {
+            if (!col.nullable) typeStr += " NOT NULL";
+            if (col.isUnique) typeStr += " UNIQUE";
+          }
+          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
+            const formatted = formatSqlDefaultValue(col.defaultValue);
+            if (formatted !== null) {
+              typeStr += ` DEFAULT ${formatted}`;
+            }
+          }
+          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
+        });
+        const fks = columns.filter(
+          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
+        ).map((col) => {
+          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
+            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
+          }
+          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
+            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+          }
+          return fkStr;
+        });
+        if (fks.length > 0) {
+          lines.push(...fks);
+        }
+        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
+${lines.join(",\n")}
+);`;
+      }
+    };
+    PostgresDialect = class {
+      quoteIdentifier(name) {
+        return `"${name}"`;
+        return `"${name.replace(/"/g, '""')}"`;
+      }
+      escapeString(val) {
+        return val.replace(/'/g, "''");
+      }
+      buildCreateTable(tableName, columns) {
+        const lines = columns.map((col) => {
+          const isPk = !!(col.isPk || col.primaryKey);
+          const tLower = col.type.toLowerCase();
+          let typeStr = col.type;
+          if (isPk && (tLower === "integer" || tLower === "int")) {
+            typeStr = "SERIAL PRIMARY KEY";
+          } else {
+            if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
+            else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
+            else if (tLower === "boolean" || tLower === "bool")
+              typeStr = "BOOLEAN";
+            else if (tLower === "decimal" || tLower === "numeric")
+              typeStr = "NUMERIC";
+            else if (tLower === "datetime" || tLower === "timestamp")
+              typeStr = "TIMESTAMP";
+            else if (col.enumValues && col.enumValues.length > 0) {
+              if (col.type && ![
+                "enum",
+                "varchar",
+                "varchar(255)",
+                "text",
+                "string"
+              ].includes(tLower)) {
+                typeStr = this.quoteIdentifier(col.type);
+              } else {
+                typeStr = `VARCHAR(255) CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
+              }
+            }
+            if (isPk) typeStr += " PRIMARY KEY";
+            if (!col.nullable && !isPk) typeStr += " NOT NULL";
+            if (col.isUnique && !isPk) typeStr += " UNIQUE";
+          }
+          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
+            const formatted = formatSqlDefaultValue(col.defaultValue);
+            if (formatted !== null) {
+              typeStr += ` DEFAULT ${formatted}`;
+            }
+          }
+          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
+        });
+        const fks = columns.filter(
+          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
+        ).map((col) => {
+          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
+            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
+          }
+          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
+            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+          }
+          return fkStr;
+        });
+        if (fks.length > 0) {
+          lines.push(...fks);
+        }
+        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
+${lines.join(",\n")}
+);`;
+      }
+    };
+    MysqlDialect = class {
+      quoteIdentifier(name) {
+        return `\`${name}\``;
+        return `\`${name.replace(/`/g, "``")}\``;
+      }
+      escapeString(val) {
+        return val.replace(/'/g, "''");
+        return val.replace(/\\/g, "\\\\").replace(/'/g, "''");
+      }
+      buildCreateTable(tableName, columns) {
+        const lines = columns.map((col) => {
+          const isPk = !!(col.isPk || col.primaryKey);
+          const tLower = col.type.toLowerCase();
+          let typeStr = col.type;
+          if (tLower === "integer" || tLower === "int") typeStr = "INT";
+          else if (tLower === "text" || tLower === "string")
+            typeStr = "VARCHAR(255)";
+          else if (tLower === "boolean" || tLower === "bool")
+            typeStr = "BOOLEAN";
+          else if (tLower === "decimal" || tLower === "numeric")
+            typeStr = "DOUBLE";
+          else if (tLower === "datetime" || tLower === "timestamp")
+            typeStr = "DATETIME";
+          else if (col.enumValues && col.enumValues.length > 0) {
+            typeStr = `ENUM(${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")})`;
+          }
+          if (isPk && (tLower.includes("int") || typeStr === "INT")) {
+            typeStr += " AUTO_INCREMENT PRIMARY KEY";
+          } else if (isPk) {
+            typeStr += " PRIMARY KEY";
+          }
+          if (!col.nullable && !isPk) typeStr += " NOT NULL";
+          if (col.isUnique && !isPk) typeStr += " UNIQUE";
+          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
+            const formatted = formatSqlDefaultValue(col.defaultValue);
+            if (formatted !== null) {
+              typeStr += ` DEFAULT ${formatted}`;
+            }
+          }
+          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
+        });
+        const fks = columns.filter(
+          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
+        ).map((col) => {
+          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
+          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
+            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
+          }
+          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
+            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
+          }
+          return fkStr;
+        });
+        if (fks.length > 0) {
+          lines.push(...fks);
+        }
+        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
+${lines.join(",\n")}
+);`;
+      }
+    };
+  }
+});
+
 // src/logic/adapters/sqlite.ts
 var SqliteAdapter;
 var init_sqlite = __esm({
   "src/logic/adapters/sqlite.ts"() {
     "use strict";
+    init_dialect();
     SqliteAdapter = class {
       dbPath;
       db = null;
@@ -589,15 +914,21 @@ var init_sqlite = __esm({
         const isCompositePk = pkColumns.length > 1;
         const colDefs = [];
         for (const col of newColumns) {
-          let def = `${this.quoteIdentifier(col.name)} ${col.type || "TEXT"}`;
+          let colType = col.type || "TEXT";
+          if (col.enumValues && col.enumValues.length > 0) {
+            const vals = col.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+            colType = `TEXT CHECK(${this.quoteIdentifier(col.name)} IN (${vals}))`;
+          }
+          let def = `${this.quoteIdentifier(col.name)} ${colType}`;
           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, "''")}'`;
+          const formattedDef = formatSqlDefaultValue(col.defaultValue);
+          if (formattedDef !== null) {
+            def += ` DEFAULT ${formattedDef}`;
           }
           if (col.fkTarget && col.fkTarget.table && col.fkTarget.column) {
             def += ` REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
@@ -704,17 +1035,45 @@ var PostgresAdapter;
 var init_postgres = __esm({
   "src/logic/adapters/postgres.ts"() {
     "use strict";
-    PostgresAdapter = class {
+    PostgresAdapter = class _PostgresAdapter {
       connectionString;
       pool = null;
+      currentSchema;
       constructor(connection) {
         this.connectionString = connection;
+        this.currentSchema = _PostgresAdapter.extractSchema(connection);
+      }
+      /**
+       * Extract the schema parameter from a PostgreSQL connection URL.
+       * Supports both `?schema=xxx` (Prisma-style) and `?options=-c search_path%3Dxxx`.
+       * Defaults to 'public' if not found.
+       */
+      static extractSchema(url) {
+        try {
+          const qIdx = url.indexOf("?");
+          if (qIdx === -1) return "public";
+          const params = new URLSearchParams(url.slice(qIdx + 1));
+          const schema = params.get("schema");
+          if (schema) return schema;
+          const opts = params.get("options");
+          if (opts) {
+            const m = opts.match(/search_path[=](\w+)/);
+            if (m) return m[1];
+          }
+        } catch {
+        }
+        return "public";
       }
       getPool() {
         if (!this.pool) {
           this.pool = new pg.Pool(buildPgPoolConfig(this.connectionString));
           this.pool.on("error", () => {
           });
+          this.pool.on("connect", (client) => {
+            const quoted = this.currentSchema.replace(/"/g, '""');
+            client.query(`SET search_path TO "${quoted}", public`).catch(() => {
+            });
+          });
         }
         return this.pool;
       }
@@ -775,15 +1134,15 @@ var init_postgres = __esm({
         const query = `
       SELECT tablename 
       FROM pg_catalog.pg_tables 
-      WHERE schemaname = 'public'
+      WHERE schemaname = $1
       ORDER BY tablename;
     `;
-        const res = await this.getPool().query(query);
+        const res = await this.getPool().query(query, [this.currentSchema]);
         return res.rows.map((row) => row.tablename);
       }
       async getSchema(tableName) {
         const query = `
-      SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
+      SELECT c.column_name, c.data_type, c.udt_name, c.is_nullable, c.column_default,
              (SELECT count(*) 
               FROM information_schema.key_column_usage kcu 
               JOIN information_schema.table_constraints tc 
@@ -841,11 +1200,44 @@ var init_postgres = __esm({
                  AND kcu.column_name = c.column_name
                LIMIT 1) as fk_on_update
       FROM information_schema.columns c
-      WHERE c.table_name = $1 AND c.table_schema = 'public'
+      WHERE c.table_name = $1 AND c.table_schema = $2
       ORDER BY c.ordinal_position;
     `;
-        const res = await this.getPool().query(query, [tableName]);
+        const res = await this.getPool().query(query, [
+          tableName,
+          this.currentSchema
+        ]);
         const enumMap = /* @__PURE__ */ new Map();
+        try {
+          const nativeEnumQuery = `
+            SELECT 
+                a.attname AS column_name,
+                t.typname AS enum_name,
+                e.enumlabel AS enum_value
+            FROM pg_attribute a
+            JOIN pg_class c ON a.attrelid = c.oid
+            JOIN pg_namespace nc ON nc.oid = c.relnamespace
+            JOIN pg_type t ON a.atttypid = t.oid
+            JOIN pg_enum e ON t.oid = e.enumtypid
+            WHERE c.relname = $1
+              AND nc.nspname = $2
+              AND a.attnum > 0
+              AND NOT a.attisdropped
+            ORDER BY a.attnum, e.enumsortorder;
+         `;
+          const nativeEnumRes = await this.getPool().query(nativeEnumQuery, [
+            tableName,
+            this.currentSchema
+          ]);
+          for (const r of nativeEnumRes.rows) {
+            const colName = r.column_name;
+            if (!enumMap.has(colName)) {
+              enumMap.set(colName, []);
+            }
+            enumMap.get(colName).push(r.enum_value);
+          }
+        } catch {
+        }
         try {
           const checkQuery = `
             SELECT cc.check_clause
@@ -853,16 +1245,19 @@ var init_postgres = __esm({
             JOIN information_schema.table_constraints tc 
               ON cc.constraint_name = tc.constraint_name 
              AND cc.constraint_schema = tc.constraint_schema
-            WHERE tc.table_name = $1 AND tc.table_schema = 'public';
+            WHERE tc.table_name = $1 AND tc.table_schema = $2;
          `;
-          const checkRes = await this.getPool().query(checkQuery, [tableName]);
+          const checkRes = await this.getPool().query(checkQuery, [
+            tableName,
+            this.currentSchema
+          ]);
           for (const r of checkRes.rows) {
             const inRegex = /["'`]?(\w+)["'`]?\s+(?:COLLATE\s+\w+\s+)?IN\s*\(([^)]+)\)/gi;
             let inMatch;
             while ((inMatch = inRegex.exec(r.check_clause)) !== null) {
               const colName = inMatch[1];
               const values = inMatch[2].split(",").map((s) => s.trim().replace(/^['"`]|['"`]$/g, "")).filter((s) => s.length > 0);
-              if (values.length > 0) {
+              if (values.length > 0 && !enumMap.has(colName)) {
                 enumMap.set(colName, values);
               }
             }
@@ -880,13 +1275,22 @@ var init_postgres = __esm({
               onUpdate: col.fk_on_update && col.fk_on_update.toUpperCase() !== "NO ACTION" ? col.fk_on_update.toUpperCase() : void 0
             };
           }
+          let colType = col.data_type;
+          if (col.data_type === "USER-DEFINED" && col.udt_name) {
+            colType = col.udt_name;
+          }
           return {
             name: col.column_name,
-            type: col.data_type,
+            type: colType,
             isPk: parseInt(col.is_pk) > 0,
             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,
+            defaultValue: (() => {
+              if (col.column_default == null) return void 0;
+              const raw = String(col.column_default).trim();
+              const castMatch = raw.match(/^('[\s\S]*')(?:::[\w\s()]+)$/);
+              return castMatch ? castMatch[1] : raw;
+            })(),
             enumValues: enumMap.get(col.column_name),
             fkTarget
           };
@@ -900,22 +1304,22 @@ var init_postgres = __esm({
           ix.indisunique as is_unique,
           ix.indisprimary as is_primary
       FROM
-          pg_class t,
-          pg_class i,
-          pg_index ix,
-          pg_attribute a
+          pg_class t
+          JOIN pg_namespace n ON n.oid = t.relnamespace
+          JOIN pg_index ix ON t.oid = ix.indrelid
+          JOIN pg_class i ON i.oid = ix.indexrelid
+          JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
       WHERE
-          t.oid = ix.indrelid
-          AND i.oid = ix.indexrelid
-          AND a.attrelid = t.oid
-          AND a.attnum = ANY(ix.indkey)
-          AND t.relkind = 'r'
+          t.relkind = 'r'
           AND t.relname = $1
-          AND t.relnamespace = 'public'::regnamespace
+          AND n.nspname = $2
       ORDER BY
           i.relname, array_position(ix.indkey, a.attnum);
     `;
-        const res = await this.getPool().query(query, [tableName]);
+        const res = await this.getPool().query(query, [
+          tableName,
+          this.currentSchema
+        ]);
         const rows = res.rows;
         const indexMap = /* @__PURE__ */ new Map();
         for (const row of rows) {
@@ -935,7 +1339,7 @@ var init_postgres = __esm({
       async getData(tableName, limit = 50, offset = 0, whereClause, orderBy) {
         const schema = await this.getSchema(tableName);
         const columns = schema.map((col) => col.name);
-        let sql = `SELECT * FROM ${this.quoteIdentifier(tableName)}`;
+        let sql = `SELECT * FROM ${this.quoteTable(tableName)}`;
         if (whereClause) {
           sql += ` WHERE ${whereClause}`;
         }
@@ -977,7 +1381,7 @@ var init_postgres = __esm({
           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 sql = `INSERT INTO ${this.quoteTable(tableName)} (${colsQuoted}) VALUES (${placeholders})`;
             const values = cols.map((c) => row[c]);
             await client.query(sql, values);
           }
@@ -990,11 +1394,82 @@ var init_postgres = __esm({
         }
       }
       async truncateTable(tableName) {
-        const quoted = this.quoteIdentifier(tableName);
+        const quoted = this.quoteTable(tableName);
         await this.getPool().query(
           `TRUNCATE TABLE ${quoted} RESTART IDENTITY CASCADE;`
         );
       }
+      /**
+       * Quote a table name with schema prefix, e.g. "zen_stream"."users".
+       * When the schema is 'public', only the table name is quoted for simplicity.
+       */
+      quoteTable(tableName) {
+        if (this.currentSchema === "public") {
+          return this.quoteIdentifier(tableName);
+        }
+        return `${this.quoteIdentifier(this.currentSchema)}.${this.quoteIdentifier(tableName)}`;
+      }
+      /**
+       * List all user-accessible schemas (excluding internal PostgreSQL schemas).
+       */
+      async getSchemas() {
+        const query = `
+         SELECT schema_name
+         FROM information_schema.schemata
+         WHERE schema_name NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+           AND schema_name NOT LIKE 'pg_temp_%'
+           AND schema_name NOT LIKE 'pg_toast_temp_%'
+         ORDER BY schema_name;
+      `;
+        const res = await this.getPool().query(query);
+        return res.rows.map((row) => row.schema_name);
+      }
+      getCurrentSchema() {
+        return this.currentSchema;
+      }
+      async setSchema(schema) {
+        this.currentSchema = schema;
+        if (this.pool) {
+          await this.pool.end();
+          this.pool = null;
+        }
+      }
+      /**
+       * List all user-defined enum types in the current schema or public.
+       * Prioritizes enums in the current active schema over public.
+       */
+      async getCustomEnums() {
+        const query = `
+         SELECT 
+             t.typname AS name,
+             n.nspname AS schema_name,
+             array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+         FROM pg_type t
+         JOIN pg_enum e ON t.oid = e.enumtypid
+         JOIN pg_namespace n ON n.oid = t.typnamespace
+         WHERE n.nspname = $1 OR n.nspname = 'public'
+         GROUP BY t.oid, t.typname, n.nspname
+         ORDER BY (CASE WHEN n.nspname = $1 THEN 0 ELSE 1 END), t.typname;
+      `;
+        try {
+          const res = await this.getPool().query(query, [this.currentSchema]);
+          const seen = /* @__PURE__ */ new Set();
+          const result = [];
+          for (const row of res.rows) {
+            const lower = row.name.toLowerCase();
+            if (!seen.has(lower)) {
+              seen.add(lower);
+              result.push({
+                name: row.name,
+                values: Array.isArray(row.values) ? row.values : []
+              });
+            }
+          }
+          return result;
+        } catch {
+          return [];
+        }
+      }
     };
   }
 });
@@ -1265,245 +1740,20 @@ var init_adapters = __esm({
 // src/logic/factory.ts
 function createDBAdapter(config) {
   switch (config.type) {
-    case "sqlite":
-      return new SqliteAdapter(config.targetUrl);
-    case "postgres":
-      return new PostgresAdapter(config.targetUrl);
-    case "mysql":
-      return new MysqlAdapter(config.targetUrl);
-    default:
-      throw new Error(`Unsupported database type: ${config.type}`);
-  }
-}
-var init_factory = __esm({
-  "src/logic/factory.ts"() {
-    "use strict";
-    init_adapters();
-  }
-});
-
-// src/logic/dialect.ts
-function getDialect(type) {
-  switch (type) {
-    case "sqlite":
-      return new SqliteDialect();
-    case "postgres":
-      return new PostgresDialect();
-    case "mysql":
-      return new MysqlDialect();
-    default:
-      return new SqliteDialect();
-  }
-}
-function buildSearchWhereClause(adapter, dbType, columns, searchInput) {
-  const searchVal = (searchInput || "").trim();
-  if (!searchVal) return "";
-  const isSqlCondition = /[=<>]|LIKE|IN|AND|OR/i.test(searchVal);
-  if (isSqlCondition) {
-    return searchVal;
-  }
-  const strCols = columns.filter((c) => {
-    const t = c.type.toLowerCase();
-    return t.includes("char") || t.includes("text") || t.includes("string") || t.includes("uuid");
-  });
-  if (strCols.length > 0) {
-    const likeOp = dbType === "postgres" ? "ILIKE" : "LIKE";
-    const escaped = searchVal.replace(/'/g, "''");
-    const conditions = strCols.map(
-      (c) => `${adapter.quoteIdentifier(c.name)} ${likeOp} '%${escaped}%'`
-    );
-    return conditions.join(" OR ");
-  }
-  if (columns.length > 0) {
-    const col = columns[0];
-    const escaped = searchVal.replace(/'/g, "''");
-    return `${adapter.quoteIdentifier(col.name)} = '${escaped}'`;
-  }
-  return "";
-}
-var SqliteDialect, PostgresDialect, MysqlDialect;
-var init_dialect = __esm({
-  "src/logic/dialect.ts"() {
-    "use strict";
-    SqliteDialect = class {
-      quoteIdentifier(name) {
-        return `"${name}"`;
-      }
-      escapeString(val) {
-        return val.replace(/'/g, "''");
-      }
-      buildCreateTable(tableName, columns) {
-        const lines = columns.map((col) => {
-          const isPk = !!(col.isPk || col.primaryKey);
-          const tLower = col.type.toLowerCase();
-          let typeStr = col.type;
-          if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
-          else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
-          else if (tLower === "boolean" || tLower === "bool")
-            typeStr = "BOOLEAN";
-          else if (tLower === "decimal" || tLower === "numeric" || tLower === "float" || tLower === "double")
-            typeStr = "REAL";
-          else if (tLower === "datetime" || tLower === "timestamp")
-            typeStr = "DATETIME";
-          else if (col.enumValues && col.enumValues.length > 0) {
-            typeStr = `TEXT CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
-          }
-          if (isPk && (tLower.includes("int") || typeStr === "INTEGER")) {
-            typeStr = "INTEGER PRIMARY KEY AUTOINCREMENT";
-          } else if (isPk) {
-            typeStr += " PRIMARY KEY";
-          } else {
-            if (!col.nullable) typeStr += " NOT NULL";
-            if (col.isUnique) typeStr += " UNIQUE";
-          }
-          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
-            if (col.defaultValue === "Timestamp") {
-              typeStr += " DEFAULT CURRENT_TIMESTAMP";
-            } else {
-              typeStr += ` DEFAULT ${col.defaultValue}`;
-            }
-          }
-          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
-        });
-        const fks = columns.filter(
-          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
-        ).map((col) => {
-          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
-          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
-            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
-          }
-          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
-            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
-          }
-          return fkStr;
-        });
-        if (fks.length > 0) {
-          lines.push(...fks);
-        }
-        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
-${lines.join(",\n")}
-);`;
-      }
-    };
-    PostgresDialect = class {
-      quoteIdentifier(name) {
-        return `"${name}"`;
-      }
-      escapeString(val) {
-        return val.replace(/'/g, "''");
-      }
-      buildCreateTable(tableName, columns) {
-        const lines = columns.map((col) => {
-          const isPk = !!(col.isPk || col.primaryKey);
-          const tLower = col.type.toLowerCase();
-          let typeStr = col.type;
-          if (isPk && (tLower === "integer" || tLower === "int")) {
-            typeStr = "SERIAL PRIMARY KEY";
-          } else {
-            if (tLower === "integer" || tLower === "int") typeStr = "INTEGER";
-            else if (tLower === "text" || tLower === "string") typeStr = "TEXT";
-            else if (tLower === "boolean" || tLower === "bool")
-              typeStr = "BOOLEAN";
-            else if (tLower === "decimal" || tLower === "numeric")
-              typeStr = "NUMERIC";
-            else if (tLower === "datetime" || tLower === "timestamp")
-              typeStr = "TIMESTAMP";
-            else if (col.enumValues && col.enumValues.length > 0) {
-              typeStr = `VARCHAR(255) CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
-            }
-            if (isPk) typeStr += " PRIMARY KEY";
-            if (!col.nullable && !isPk) typeStr += " NOT NULL";
-            if (col.isUnique && !isPk) typeStr += " UNIQUE";
-          }
-          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
-            if (col.defaultValue === "Timestamp") {
-              typeStr += " DEFAULT CURRENT_TIMESTAMP";
-            } else {
-              typeStr += ` DEFAULT ${col.defaultValue}`;
-            }
-          }
-          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
-        });
-        const fks = columns.filter(
-          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
-        ).map((col) => {
-          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
-          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
-            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
-          }
-          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
-            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
-          }
-          return fkStr;
-        });
-        if (fks.length > 0) {
-          lines.push(...fks);
-        }
-        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
-${lines.join(",\n")}
-);`;
-      }
-    };
-    MysqlDialect = class {
-      quoteIdentifier(name) {
-        return `\`${name}\``;
-      }
-      escapeString(val) {
-        return val.replace(/'/g, "''");
-      }
-      buildCreateTable(tableName, columns) {
-        const lines = columns.map((col) => {
-          const isPk = !!(col.isPk || col.primaryKey);
-          const tLower = col.type.toLowerCase();
-          let typeStr = col.type;
-          if (tLower === "integer" || tLower === "int") typeStr = "INT";
-          else if (tLower === "text" || tLower === "string")
-            typeStr = "VARCHAR(255)";
-          else if (tLower === "boolean" || tLower === "bool")
-            typeStr = "BOOLEAN";
-          else if (tLower === "decimal" || tLower === "numeric")
-            typeStr = "DOUBLE";
-          else if (tLower === "datetime" || tLower === "timestamp")
-            typeStr = "DATETIME";
-          else if (col.enumValues && col.enumValues.length > 0) {
-            typeStr = `VARCHAR(255) CHECK(${this.quoteIdentifier(col.name)} IN (${col.enumValues.map((v) => `'${this.escapeString(v)}'`).join(", ")}))`;
-          }
-          if (isPk && (tLower.includes("int") || typeStr === "INT")) {
-            typeStr += " AUTO_INCREMENT PRIMARY KEY";
-          } else if (isPk) {
-            typeStr += " PRIMARY KEY";
-          }
-          if (!col.nullable && !isPk) typeStr += " NOT NULL";
-          if (col.isUnique && !isPk) typeStr += " UNIQUE";
-          if (col.defaultValue && col.defaultValue !== "AutoInc" && !col.defaultValue.startsWith("FK ->")) {
-            if (col.defaultValue === "Timestamp") {
-              typeStr += " DEFAULT CURRENT_TIMESTAMP";
-            } else {
-              typeStr += ` DEFAULT ${col.defaultValue}`;
-            }
-          }
-          return `  ${this.quoteIdentifier(col.name)} ${typeStr}`;
-        });
-        const fks = columns.filter(
-          (col) => col.fkTarget && col.fkTarget.table && col.fkTarget.column
-        ).map((col) => {
-          let fkStr = `  FOREIGN KEY (${this.quoteIdentifier(col.name)}) REFERENCES ${this.quoteIdentifier(col.fkTarget.table)}(${this.quoteIdentifier(col.fkTarget.column)})`;
-          if (col.fkTarget.onDelete && col.fkTarget.onDelete !== "NO ACTION") {
-            fkStr += ` ON DELETE ${col.fkTarget.onDelete}`;
-          }
-          if (col.fkTarget.onUpdate && col.fkTarget.onUpdate !== "NO ACTION") {
-            fkStr += ` ON UPDATE ${col.fkTarget.onUpdate}`;
-          }
-          return fkStr;
-        });
-        if (fks.length > 0) {
-          lines.push(...fks);
-        }
-        return `CREATE TABLE ${this.quoteIdentifier(tableName)} (
-${lines.join(",\n")}
-);`;
-      }
-    };
+    case "sqlite":
+      return new SqliteAdapter(config.targetUrl);
+    case "postgres":
+      return new PostgresAdapter(config.targetUrl);
+    case "mysql":
+      return new MysqlAdapter(config.targetUrl);
+    default:
+      throw new Error(`Unsupported database type: ${config.type}`);
+  }
+}
+var init_factory = __esm({
+  "src/logic/factory.ts"() {
+    "use strict";
+    init_adapters();
   }
 });
 
@@ -1611,12 +1861,18 @@ async function batchMutateTableData(adapter, dbType, options) {
   }
   let executedCount = 0;
   try {
+    await adapter.executeSql("BEGIN;");
     for (const sql of sqls) {
       await adapter.executeSql(sql);
       executedCount++;
     }
+    await adapter.executeSql("COMMIT;");
     return ok({ modifiedCount: executedCount, executedCount });
   } catch (e) {
+    try {
+      await adapter.executeSql("ROLLBACK;");
+    } catch {
+    }
     return err(
       e.message || "Failed to execute database mutations",
       void 0,
@@ -1635,6 +1891,33 @@ var init_mutation = __esm({
 // src/logic/schema.ts
 async function createTable(adapter, dbType, tableName, columns) {
   try {
+    if (dbType === "postgres") {
+      const processedEnums = /* @__PURE__ */ new Set();
+      for (const col of columns) {
+        if (col.enumValues && col.enumValues.length > 0 && col.type && !["enum", "varchar", "varchar(255)", "text", "string"].includes(
+          col.type.toLowerCase()
+        ) && !processedEnums.has(col.type.toLowerCase())) {
+          processedEnums.add(col.type.toLowerCase());
+          const vals = col.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+          const enumTypeQuoted = adapter.quoteIdentifier(col.type);
+          const escapedName = col.type.replace(/'/g, "''");
+          const createTypeSql = `
+                  DO $$
+                  BEGIN
+                     IF NOT EXISTS (
+                        SELECT 1 FROM pg_type t
+                        JOIN pg_namespace n ON n.oid = t.typnamespace
+                        WHERE t.typname = '${escapedName}'
+                          AND (n.nspname = current_schema() OR n.nspname = 'public')
+                     ) THEN
+                        CREATE TYPE ${enumTypeQuoted} AS ENUM (${vals});
+                     END IF;
+                  END$$;
+               `;
+          await adapter.executeSql(createTypeSql);
+        }
+      }
+    }
     const dialect = getDialect(dbType);
     const sql = dialect.buildCreateTable(tableName, columns);
     await adapter.executeSql(sql);
@@ -1725,6 +2008,7 @@ async function applySchemaChanges(adapter, dbType, options) {
           let nullable = edits.nullable !== void 0 ? !!edits.nullable : col.nullable;
           let defaultValue = edits.defaultValue !== void 0 ? edits.defaultValue : col.defaultValue;
           let isUnique = edits.isUnique !== void 0 ? !!edits.isUnique : col.isPk && !isPk ? false : !!col.isUnique;
+          let enumValues = edits.enumValues !== void 0 ? edits.enumValues : col.enumValues;
           if (edits.name && edits.name !== col.name) {
             renames[col.name] = edits.name;
           }
@@ -1735,7 +2019,8 @@ async function applySchemaChanges(adapter, dbType, options) {
             nullable,
             defaultValue,
             isUnique,
-            fkTarget
+            fkTarget,
+            enumValues
           });
         }
         for (const ins of pendingInserts) {
@@ -1770,7 +2055,8 @@ async function applySchemaChanges(adapter, dbType, options) {
             nullable: ins.nullable !== void 0 ? !!ins.nullable : true,
             defaultValue: ins.defaultValue,
             isUnique: !!ins.isUnique,
-            fkTarget
+            fkTarget,
+            enumValues: ins.enumValues
           });
         }
         targetColumns = updated;
@@ -1828,8 +2114,32 @@ async function applySchemaChanges(adapter, dbType, options) {
       const quotedCol = dialect.quoteIdentifier(currentName);
       const type = edits.type || "TEXT";
       if (dbType === "postgres") {
+        let pgType = type;
+        if (edits.enumValues && edits.enumValues.length > 0) {
+          if (edits.isNewEnum && edits.type) {
+            const escapedName = edits.type.replace(/'/g, "''");
+            const vals = edits.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+            const quotedType = dialect.quoteIdentifier(edits.type);
+            sqls.push(`
+                     DO $$
+                     BEGIN
+                        IF NOT EXISTS (
+                           SELECT 1 FROM pg_type t
+                           JOIN pg_namespace n ON n.oid = t.typnamespace
+                           WHERE t.typname = '${escapedName}'
+                             AND (n.nspname = current_schema() OR n.nspname = 'public')
+                        ) THEN
+                           CREATE TYPE ${quotedType} AS ENUM (${vals});
+                        END IF;
+                     END$$;
+                  `);
+            pgType = quotedType;
+          } else if (edits.type) {
+            pgType = dialect.quoteIdentifier(edits.type);
+          }
+        }
         sqls.push(
-          `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${type};`
+          `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} TYPE ${pgType} USING ${quotedCol}::text::${pgType};`
         );
         if (edits.nullable === false) {
           sqls.push(
@@ -1840,17 +2150,29 @@ async function applySchemaChanges(adapter, dbType, options) {
             `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} DROP NOT NULL;`
           );
         }
-        if (edits.defaultValue) {
-          const escapedDef = dialect.escapeString(edits.defaultValue);
-          sqls.push(
-            `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} SET DEFAULT '${escapedDef}';`
-          );
+        if (edits.defaultValue !== void 0) {
+          const formatted = formatSqlDefaultValue(edits.defaultValue);
+          if (formatted !== null) {
+            sqls.push(
+              `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} SET DEFAULT ${formatted};`
+            );
+          } else {
+            sqls.push(
+              `ALTER TABLE ${quotedTable} ALTER COLUMN ${quotedCol} DROP DEFAULT;`
+            );
+          }
         }
       } else if (dbType === "mysql") {
+        let mysqlType = type;
+        if (edits.enumValues && edits.enumValues.length > 0) {
+          const vals = edits.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+          mysqlType = `ENUM(${vals})`;
+        }
         const nullStr = edits.nullable === false ? "NOT NULL" : "NULL";
-        const defStr = edits.defaultValue ? `DEFAULT '${dialect.escapeString(edits.defaultValue)}'` : "";
+        const formatted = formatSqlDefaultValue(edits.defaultValue);
+        const defStr = formatted !== null ? `DEFAULT ${formatted}` : "";
         sqls.push(
-          `ALTER TABLE ${quotedTable} MODIFY COLUMN ${quotedCol} ${type} ${nullStr} ${defStr};`
+          `ALTER TABLE ${quotedTable} MODIFY COLUMN ${quotedCol} ${mysqlType} ${nullStr} ${defStr};`
         );
       }
     }
@@ -1858,9 +2180,36 @@ async function applySchemaChanges(adapter, dbType, options) {
   for (const ins of pendingInserts) {
     if (!ins.name || ins.name.trim() === "") continue;
     const quotedCol = dialect.quoteIdentifier(ins.name.trim());
-    const type = ins.type || "TEXT";
+    let type = ins.type || "TEXT";
+    if (dbType === "postgres" && ins.enumValues && ins.enumValues.length > 0) {
+      if (ins.isNewEnum && ins.type) {
+        const escapedName = ins.type.replace(/'/g, "''");
+        const vals = ins.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+        const quotedType = dialect.quoteIdentifier(ins.type);
+        sqls.push(`
+               DO $$
+               BEGIN
+                  IF NOT EXISTS (
+                     SELECT 1 FROM pg_type t
+                     JOIN pg_namespace n ON n.oid = t.typnamespace
+                     WHERE t.typname = '${escapedName}'
+                       AND (n.nspname = current_schema() OR n.nspname = 'public')
+                  ) THEN
+                     CREATE TYPE ${quotedType} AS ENUM (${vals});
+                  END IF;
+               END$$;
+            `);
+        type = quotedType;
+      } else if (ins.type) {
+        type = dialect.quoteIdentifier(ins.type);
+      }
+    } else if (dbType === "mysql" && ins.enumValues && ins.enumValues.length > 0) {
+      const vals = ins.enumValues.map((v) => `'${dialect.escapeString(v)}'`).join(", ");
+      type = `ENUM(${vals})`;
+    }
     const nullStr = ins.nullable === false ? "NOT NULL" : "";
-    const defStr = ins.defaultValue ? `DEFAULT '${dialect.escapeString(ins.defaultValue)}'` : "";
+    const formattedDef = formatSqlDefaultValue(ins.defaultValue);
+    const defStr = formattedDef !== null ? `DEFAULT ${formattedDef}` : "";
     sqls.push(
       `ALTER TABLE ${quotedTable} ADD COLUMN ${quotedCol} ${type} ${nullStr} ${defStr};`
     );
@@ -1899,7 +2248,7 @@ async function applySchemaChanges(adapter, dbType, options) {
 }
 async function getTableRowCount(adapter, tableName) {
   try {
-    const quoted = adapter.quoteIdentifier(tableName);
+    const quoted = adapter.quoteTable ? adapter.quoteTable(tableName) : adapter.quoteIdentifier(tableName);
     const countRes = await adapter.query(
       `SELECT COUNT(*) as cnt FROM ${quoted}`
     );
@@ -2071,6 +2420,43 @@ async function exportDatabaseSchemaDdl(adapter, dbType) {
     );
   }
 }
+async function getDatabaseEnums(adapter) {
+  try {
+    if (adapter.getCustomEnums) {
+      const enums = await adapter.getCustomEnums();
+      return ok(enums);
+    }
+    const enumsMap = /* @__PURE__ */ new Map();
+    try {
+      const tables = await adapter.getTables();
+      for (const t of tables.slice(0, 30)) {
+        const cols = await adapter.getSchema(t);
+        for (const col of cols) {
+          if (col.enumValues && col.enumValues.length > 0) {
+            const key = col.type && ![
+              "enum",
+              "varchar",
+              "varchar(255)",
+              "text",
+              "string"
+            ].includes(col.type.toLowerCase()) ? col.type : col.name;
+            if (!enumsMap.has(key)) {
+              enumsMap.set(key, col.enumValues);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    const data = Array.from(enumsMap.entries()).map(([name, values]) => ({
+      name,
+      values
+    }));
+    return ok(data);
+  } catch (e) {
+    return err(e.message || "Failed to get database enums", void 0, e);
+  }
+}
 var init_schema = __esm({
   "src/logic/schema.ts"() {
     "use strict";
@@ -2443,6 +2829,27 @@ var init_seeder = __esm({
 // src/logic/transfer.ts
 import fs2 from "fs/promises";
 import path2 from "path";
+async function getRestoreCandidates(dir) {
+  const candidates = [];
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("drixio_backup_")) {
+        candidates.push({
+          name: `\u{1F4C1} ${entry.name} (Backup Directory)`,
+          value: entry.name
+        });
+      } else if (entry.isFile() && (entry.name.endsWith(".sql") || entry.name.endsWith(".json"))) {
+        candidates.push({
+          name: `\u{1F4C4} ${entry.name} (${entry.name.endsWith(".sql") ? "SQL Script" : "JSON Dump"})`,
+          value: entry.name
+        });
+      }
+    }
+  } catch {
+  }
+  return candidates;
+}
 function formatCsvValue(val) {
   if (val === null || val === void 0) return "";
   const str = String(val);
@@ -2941,6 +3348,153 @@ function generateDatabaseSqlDumpStream(adapter, dbType) {
     }
   });
 }
+function nodeToWebStream(nodeStream) {
+  return new ReadableStream({
+    start(controller) {
+      nodeStream.on("data", (chunk) => controller.enqueue(chunk));
+      nodeStream.on("end", () => controller.close());
+      nodeStream.on("error", (err2) => controller.error(err2));
+    },
+    cancel() {
+      nodeStream.destroy();
+    }
+  });
+}
+async function exportDatabaseNative(dbType, connectionUrl, schemaOnly) {
+  try {
+    const executeNativeDump = (cmd, args, envName) => {
+      return new Promise((resolve, reject) => {
+        const cp = import("child_process").then((m) => m.spawn(cmd, args));
+        let started = false;
+        cp.then((cpInstance) => {
+          const stream2 = nodeToWebStream(cpInstance.stdout);
+          cpInstance.on("error", (e) => {
+            if (!started)
+              reject(
+                new Error(
+                  `Native tool '${cmd}' not found. Please install ${envName}.`
+                )
+              );
+          });
+          setTimeout(() => {
+            if (!cpInstance.killed) {
+              started = true;
+              resolve(stream2);
+            }
+          }, 100);
+        });
+      });
+    };
+    let stream;
+    if (dbType === "sqlite") {
+      const dbPath = connectionUrl.replace("file:", "");
+      stream = await executeNativeDump(
+        "sqlite3",
+        [dbPath, schemaOnly ? ".schema" : ".dump"],
+        "SQLite CLI"
+      );
+    } else if (dbType === "mysql") {
+      const parsed = new URL(connectionUrl);
+      const user = parsed.username;
+      const pass = parsed.password;
+      const host = parsed.hostname;
+      const port = parsed.port || "3306";
+      const dbname = parsed.pathname.substring(1);
+      const args = ["-u", user, `-p${pass}`, "-h", host, "-P", port];
+      if (schemaOnly) args.push("--no-data");
+      args.push(dbname);
+      stream = await executeNativeDump(
+        "mysqldump",
+        args,
+        "MySQL Client"
+      );
+    } else if (dbType === "postgres") {
+      const args = [connectionUrl];
+      if (schemaOnly) args.push("--schema-only");
+      stream = await executeNativeDump(
+        "pg_dump",
+        args,
+        "PostgreSQL CLI"
+      );
+    } else {
+      return err("Unsupported database type for native export");
+    }
+    return ok(stream);
+  } catch (e) {
+    return err(e.message || "Failed to export database using native tool", void 0, e);
+  }
+}
+async function importDatabaseNative(adapter, dbType, connectionUrl, sqlContent) {
+  try {
+    const executeNativeImport = (cmd, args, fileContent, envName) => {
+      return new Promise((resolve, reject) => {
+        import("child_process").then((m) => {
+          const cp = m.spawn(cmd, args);
+          let started = false;
+          let errStr = "";
+          cp.on("error", (e) => {
+            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 (dbType === "sqlite") {
+        const dbPath = connectionUrl.replace("file:", "");
+        await executeNativeImport(
+          "sqlite3",
+          [dbPath],
+          sqlContent,
+          "SQLite CLI"
+        );
+      } else if (dbType === "mysql") {
+        const parsed = new URL(connectionUrl);
+        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 (dbType === "postgres") {
+        await executeNativeImport(
+          "psql",
+          [connectionUrl],
+          sqlContent,
+          "PostgreSQL CLI"
+        );
+      } else {
+        return err("Unsupported database type for native import");
+      }
+    } catch (e) {
+      if (e.message.includes("Native tool")) {
+        await adapter.executeSql(sqlContent);
+      } else {
+        throw e;
+      }
+    }
+    return ok({ message: "Import completed successfully" });
+  } catch (e) {
+    return err(`Import Failed: ${e.message}`, void 0, e);
+  }
+}
 var init_transfer = __esm({
   "src/logic/transfer.ts"() {
     "use strict";
@@ -3000,6 +3554,10 @@ async function createDatabase(options) {
       });
       try {
         await conn.query(`CREATE DATABASE IF NOT EXISTS \`${dbName}\``);
+        const quotedDbName = dbName.replace(/`/g, "``");
+        await conn.query(
+          `CREATE DATABASE IF NOT EXISTS \`${quotedDbName}\``
+        );
       } finally {
         await conn.end();
       }
@@ -3030,6 +3588,8 @@ async function createDatabase(options) {
         );
         if (res.rowCount === 0) {
           await conn.query(`CREATE DATABASE "${dbName}"`);
+          const quotedDbName = dbName.replace(/"/g, '""');
+          await conn.query(`CREATE DATABASE "${quotedDbName}"`);
         }
       } finally {
         await conn.end();
@@ -3081,6 +3641,8 @@ async function dropDatabase(options) {
       });
       try {
         await conn.query(`DROP DATABASE IF EXISTS \`${dbName}\``);
+        const quotedDbName = dbName.replace(/`/g, "``");
+        await conn.query(`DROP DATABASE IF EXISTS \`${quotedDbName}\``);
       } finally {
         await conn.end();
       }
@@ -3107,6 +3669,8 @@ async function dropDatabase(options) {
       await conn.connect();
       try {
         await conn.query(`DROP DATABASE IF EXISTS "${dbName}"`);
+        const quotedDbName = dbName.replace(/"/g, '""');
+        await conn.query(`DROP DATABASE IF EXISTS "${quotedDbName}"`);
       } finally {
         await conn.end();
       }
@@ -3838,7 +4402,10 @@ function generateMigrationSql(diff, dbType) {
         let typeStr = col.type || "TEXT";
         if (col.nullable === false) typeStr += " NOT NULL";
         if (col.defaultValue !== void 0 && col.defaultValue !== null) {
-          typeStr += ` DEFAULT '${dialect.escapeString(col.defaultValue)}'`;
+          const formatted = formatSqlDefaultValue(col.defaultValue);
+          if (formatted !== null) {
+            typeStr += ` DEFAULT ${formatted}`;
+          }
         }
         lines.push(`ALTER TABLE ${qTable} ADD COLUMN ${qCol} ${typeStr};`);
       }
@@ -3967,7 +4534,10 @@ function generateRollbackSql(diff, dbType) {
         let typeStr = col.type || "TEXT";
         if (col.nullable === false) typeStr += " NOT NULL";
         if (col.defaultValue !== void 0 && col.defaultValue !== null) {
-          typeStr += ` DEFAULT '${dialect.escapeString(col.defaultValue)}'`;
+          const formatted = formatSqlDefaultValue(col.defaultValue);
+          if (formatted !== null) {
+            typeStr += ` DEFAULT ${formatted}`;
+          }
         }
         lines.push(`ALTER TABLE ${qTable} ADD COLUMN ${qCol} ${typeStr};`);
       }
@@ -4208,9 +4778,18 @@ function extractSnippetParams(sql) {
 function substituteSnippetParams(sql, params, dbType = "sqlite") {
   if (!sql) return "";
   const dialect = getDialect(dbType);
+  const identifierKeys = /* @__PURE__ */ new Set([
+    "table",
+    "column",
+    "child_table",
+    "parent_table",
+    "fk_col",
+    "pk_col"
+  ]);
   let result = sql;
   for (const [key, rawValue] of Object.entries(params)) {
     const valStr = rawValue !== void 0 && rawValue !== null ? String(rawValue) : "";
+    const isIdentifier = identifierKeys.has(key);
     const isNumber = !isNaN(Number(valStr)) && valStr.trim() !== "";
     const quotedMustache = new RegExp(`'\\{\\{\\s*${key}\\s*\\}\\}'`, "g");
     const quotedColon = new RegExp(`':${key}'`, "g");
@@ -4220,10 +4799,16 @@ function substituteSnippetParams(sql, params, dbType = "sqlite") {
     const rawMustache = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
     result = result.replace(rawMustache, () => {
       return isNumber ? valStr : valStr;
+      if (isIdentifier) return dialect.quoteIdentifier(valStr);
+      if (isNumber) return valStr;
+      return `'${escapedVal}'`;
     });
     const rawColon = new RegExp(`(^|[^:]):${key}\\b`, "g");
     result = result.replace(rawColon, (_match, prefix) => {
       return `${prefix}${valStr}`;
+      if (isIdentifier) return `${prefix}${dialect.quoteIdentifier(valStr)}`;
+      if (isNumber) return `${prefix}${valStr}`;
+      return `${prefix}'${escapedVal}'`;
     });
   }
   return result;
@@ -4282,8 +4867,8 @@ function getDrixioVersion() {
   if (cachedVersion) {
     return cachedVersion;
   }
-  if ("1.1.10") {
-    cachedVersion = "1.1.10";
+  if ("1.2.0") {
+    cachedVersion = "1.2.0";
     return cachedVersion;
   }
   try {
@@ -4340,6 +4925,30 @@ var init_serialization = __esm({
   }
 });
 
+// src/logic/repl.ts
+function parseReplCommand(rawSql) {
+  const trimmed = rawSql.trim();
+  const connectMatch = trimmed.match(/^CONNECT\s+([^\s;]+)\s*;?$/i);
+  if (connectMatch) {
+    return { type: "connect", url: connectMatch[1], originalSql: rawSql };
+  }
+  if (/^DISCONNECT\s*;?$/i.test(trimmed)) {
+    return { type: "disconnect", originalSql: rawSql };
+  }
+  const createDbMatch = trimmed.match(
+    /^CREATE\s+DATABASE\s+(?:IF\s+NOT\s+EXISTS\s+)?['"`]?([^'";`\s]+)['"`]?\s*;?$/i
+  );
+  if (createDbMatch) {
+    return { type: "create_database", dbName: createDbMatch[1], originalSql: rawSql };
+  }
+  return { type: "sql", originalSql: rawSql };
+}
+var init_repl = __esm({
+  "src/logic/repl.ts"() {
+    "use strict";
+  }
+});
+
 // src/logic/index.ts
 var init_logic = __esm({
   "src/logic/index.ts"() {
@@ -4360,6 +4969,7 @@ var init_logic = __esm({
     init_snippets();
     init_version();
     init_serialization();
+    init_repl();
   }
 });
 
@@ -5862,21 +6472,8 @@ var init_diffWizard = __esm({
 
 // src/studio/api.ts
 import { Hono } from "hono";
-import { spawn } from "child_process";
 import path18 from "path";
 import fs18 from "fs";
-function nodeToWebStream(nodeStream) {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => controller.enqueue(chunk));
-      nodeStream.on("end", () => controller.close());
-      nodeStream.on("error", (err2) => controller.error(err2));
-    },
-    cancel() {
-      nodeStream.destroy();
-    }
-  });
-}
 function registerApiRoutes(app, dbConfig) {
   const api = new Hono();
   let currentDbConfig = { ...dbConfig };
@@ -5962,7 +6559,11 @@ function registerApiRoutes(app, dbConfig) {
   });
   const detectHostEnvironment = (cfg) => {
     if (cfg.type === "sqlite") {
-      return { isRemote: false, host: "local", badgeLabel: "LOCAL (SQLite)" };
+      return {
+        isRemote: false,
+        host: "local",
+        badgeLabel: "LOCAL (SQLite)"
+      };
     }
     if (cfg.type === "mysql" || cfg.type === "postgres") {
       let host = "localhost";
@@ -6241,7 +6842,7 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
-  api.post("/analyze-query", async (c) => {
+  api.post("/query/analyze", async (c) => {
     try {
       const { sql } = await c.req.json().catch(() => ({}));
       const result = analyzeDangerousQuery(sql);
@@ -6259,10 +6860,9 @@ function registerApiRoutes(app, dbConfig) {
           400
         );
       }
-      const trimmed = sql.trim();
-      const connectMatch = trimmed.match(/^CONNECT\s+([^\s;]+)\s*;?$/i);
-      if (connectMatch) {
-        const rawUrl = connectMatch[1];
+      const replCmd = parseReplCommand(sql);
+      if (replCmd.type === "connect" && replCmd.url) {
+        const rawUrl = replCmd.url;
         const newConfig = await detectDatabase(rawUrl);
         const newAdapter = createDBAdapter(newConfig);
         await newAdapter.getTables();
@@ -6294,7 +6894,7 @@ function registerApiRoutes(app, dbConfig) {
           }
         });
       }
-      if (/^DISCONNECT\s*;?$/i.test(trimmed)) {
+      if (replCmd.type === "disconnect") {
         if (currentAdapter) {
           try {
             await currentAdapter.close();
@@ -6321,11 +6921,8 @@ function registerApiRoutes(app, dbConfig) {
           }
         });
       }
-      const createDbMatch = trimmed.match(
-        /^CREATE\s+DATABASE\s+(?:IF\s+NOT\s+EXISTS\s+)?['"`]?([^'";`\s]+)['"`]?\s*;?$/i
-      );
-      if (createDbMatch) {
-        const dbName = createDbMatch[1];
+      if (replCmd.type === "create_database" && replCmd.dbName) {
+        const dbName = replCmd.dbName;
         if (currentAdapter && (currentDbConfig.type === "postgres" || currentDbConfig.type === "mysql")) {
           const quote = currentDbConfig.type === "mysql" ? "`" : '"';
           await currentAdapter.executeSql(
@@ -6407,24 +7004,19 @@ function registerApiRoutes(app, dbConfig) {
         );
       }
       const adapter = getAdapter();
-      const cleanSql = sql.trim().replace(/;+$/, "");
-      let explainSql = "";
-      if (currentDbConfig.type === "sqlite") {
-        explainSql = `EXPLAIN QUERY PLAN ${cleanSql}`;
-      } else if (currentDbConfig.type === "postgres") {
-        explainSql = `EXPLAIN (ANALYZE, COSTS, VERBOSE, BUFFERS) ${cleanSql}`;
-      } else if (currentDbConfig.type === "mysql") {
-        explainSql = `EXPLAIN ${cleanSql}`;
-      } else {
-        explainSql = `EXPLAIN ${cleanSql}`;
+      const explainRes = generateExplainQuery(sql, currentDbConfig.type);
+      if (explainRes.error || !explainRes.sql) {
+        return c.json({ success: false, error: explainRes.error }, 400);
       }
+      let explainSql = explainRes.sql;
       const startTime = performance.now();
       let res;
       try {
         res = await adapter.query(explainSql);
       } catch (primaryErr) {
         if (currentDbConfig.type === "postgres") {
-          explainSql = `EXPLAIN ${cleanSql}`;
+          const fallbackRes = generateExplainQuery(sql, "unknown");
+          explainSql = fallbackRes.sql;
           res = await adapter.query(explainSql);
         } else {
           throw primaryErr;
@@ -6517,68 +7109,25 @@ function registerApiRoutes(app, dbConfig) {
       }
       const type = currentDbConfig.type;
       const url = currentDbConfig.targetUrl;
-      let child;
       let filename = "backup.sql";
-      const executeNativeDump = (cmd, args, envName) => {
-        return new Promise((resolve, reject) => {
-          const cp = spawn(cmd, args);
-          let started = false;
-          const stream = nodeToWebStream(cp.stdout);
-          cp.on("error", (err2) => {
-            if (!started)
-              reject(
-                new Error(
-                  `Native tool '${cmd}' not found. Please install ${envName}.`
-                )
-              );
-          });
-          setTimeout(() => {
-            if (!cp.killed) {
-              started = true;
-              resolve(stream);
-            }
-          }, 100);
-        });
-      };
       try {
-        let stream;
         const baseName = getDbName();
         const timeStr = getDatetimeStr();
         filename = `${baseName}_backup_${timeStr}.sql`;
-        if (type === "sqlite") {
-          const dbPath = url.replace("file:", "");
-          stream = await executeNativeDump(
-            "sqlite3",
-            [dbPath, ".dump"],
-            "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);
-          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"
-          );
-        } else {
-          throw new Error("Unsupported database type for native export");
+        const exportRes = await exportDatabaseNative(
+          type,
+          url,
+          false
+        );
+        if (!exportRes.success) {
+          throw new Error(exportRes.error);
         }
         c.header(
           "Content-Disposition",
           `attachment; filename="${filename}"`
         );
         c.header("Content-Type", "application/sql");
-        return c.body(stream);
+        return c.body(exportRes.data);
       } catch (err2) {
         if (err2.message.includes("Native tool")) {
           const baseName = getDbName();
@@ -6634,67 +7183,14 @@ function registerApiRoutes(app, dbConfig) {
       const sqlContent = await file.text();
       const type = currentDbConfig.type;
       const url = currentDbConfig.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", (err2) => {
-            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 (err2) {
-        if (err2.message.includes("Native tool")) {
-          await getAdapter().executeSql(sqlContent);
-        } else {
-          throw err2;
-        }
+      const importRes = await importDatabaseNative(
+        getAdapter(),
+        type,
+        url,
+        sqlContent
+      );
+      if (!importRes.success) {
+        return c.json({ success: false, error: importRes.error }, 500);
       }
       return c.json({
         success: true,
@@ -7034,8 +7530,7 @@ function registerApiRoutes(app, dbConfig) {
       const dialect = (dbType || "sqlite").toLowerCase();
       if (dialect === "sqlite") {
         const rawPath = body.url || body.sqlitePath || dbName || "drixio.sqlite";
-        const cleanPath = rawPath.replace(/^file:/, "").trim();
-        const fullPath = path18.isAbsolute(cleanPath) ? cleanPath : path18.resolve(process.cwd(), cleanPath);
+        const fullPath = resolveLocalDbPath(rawPath, process.cwd());
         if (mode === "create") {
           const dir = path18.dirname(fullPath);
           if (!fs18.existsSync(dir)) {
@@ -7095,12 +7590,7 @@ function registerApiRoutes(app, dbConfig) {
       }
       let targetUrl = "";
       if (mode === "create") {
-        const targetHost = host || "localhost";
-        const targetPort = port || (dialect === "postgres" ? "5432" : "3306");
-        const targetUser = user || (dialect === "postgres" ? "postgres" : "root");
-        const auth = password ? `${encodeURIComponent(targetUser)}:${encodeURIComponent(password)}` : encodeURIComponent(targetUser);
-        const defaultDb = dialect === "postgres" ? "postgres" : "";
-        targetUrl = `${dialect}://${auth}@${targetHost}:${targetPort}/${defaultDb}`;
+        targetUrl = assembleConnectionUrl(dialect, host, port, user, password, "");
       } else {
         const rawUrl = body.url;
         if (!rawUrl) {
@@ -7168,6 +7658,73 @@ function registerApiRoutes(app, dbConfig) {
       return c.json({ success: false, error: e.message }, 500);
     }
   });
+  api.get("/schemas", async (c) => {
+    try {
+      const adapter = currentAdapter;
+      const supported = !!adapter && typeof adapter.getSchemas === "function" && currentDbConfig.type === "postgres";
+      if (!supported || !adapter) {
+        return c.json({
+          success: true,
+          data: { supported: false, schemas: [], currentSchema: "public" }
+        });
+      }
+      const schemas = await adapter.getSchemas();
+      const currentSchema = adapter.getCurrentSchema ? adapter.getCurrentSchema() : "public";
+      return c.json({
+        success: true,
+        data: { supported: true, schemas, currentSchema }
+      });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
+  api.post("/schemas/switch", async (c) => {
+    try {
+      const { schema } = await c.req.json().catch(() => ({}));
+      if (!schema || typeof schema !== "string") {
+        return c.json(
+          { success: false, error: "Schema name is required" },
+          400
+        );
+      }
+      const adapter = currentAdapter;
+      if (!adapter || typeof adapter.setSchema !== "function" || currentDbConfig.type !== "postgres") {
+        return c.json(
+          {
+            success: false,
+            error: "Schema switching is only supported for PostgreSQL"
+          },
+          400
+        );
+      }
+      await adapter.setSchema(schema);
+      const tables = await adapter.getTables();
+      return c.json({
+        success: true,
+        data: {
+          schema,
+          tableCount: tables.length
+        }
+      });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
+  api.get("/database/enums", async (c) => {
+    try {
+      const adapter = currentAdapter;
+      if (!adapter) {
+        return c.json({ success: true, data: [] });
+      }
+      const result = await getDatabaseEnums(adapter);
+      if (!result.success) {
+        return c.json({ success: false, error: result.error }, 500);
+      }
+      return c.json({ success: true, data: result.data });
+    } catch (e) {
+      return c.json({ success: false, error: e.message }, 500);
+    }
+  });
   app.route("/api", api);
 }
 var init_api = __esm({
@@ -7785,23 +8342,7 @@ async function runRestoreCommand(dbConfig, args, options = {}) {
   const { input: input11, select: select16, confirm: confirm8 } = await import("@inquirer/prompts");
   if (!targetPath) {
     try {
-      const entries = await fs9.readdir(process.cwd(), {
-        withFileTypes: true
-      });
-      const candidates = [];
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name.startsWith("drixio_backup_")) {
-          candidates.push({
-            name: `\u{1F4C1} ${entry.name} (Backup Directory)`,
-            value: entry.name
-          });
-        } else if (entry.isFile() && (entry.name.endsWith(".sql") || entry.name.endsWith(".json"))) {
-          candidates.push({
-            name: `\u{1F4C4} ${entry.name} (${entry.name.endsWith(".sql") ? "SQL Script" : "JSON Dump"})`,
-            value: entry.name
-          });
-        }
-      }
+      const candidates = await getRestoreCandidates(process.cwd());
       if (candidates.length > 0) {
         candidates.push({
           name: "\u270F\uFE0F  Enter a custom path manually...",
@@ -8596,7 +9137,7 @@ Usage examples:`));
       }
     }
     let diffResult;
-    const isRemoteUrl = targetArg.startsWith("postgres://") || targetArg.startsWith("postgresql://") || targetArg.startsWith("mysql://") || targetArg.startsWith("file:");
+    const isRemoteUrl = isConnectionString(targetArg) || targetArg.startsWith("file:");
     if (isRemoteUrl) {
       console.log(
         pc17.cyan(