@bungres/kit 0.1.1 → 0.4.0

package/dist/cli.js

@@ -1,47 +1,10 @@
 #!/usr/bin/env bun
 // @bun
 
-// src/config.ts
+// src/schema-loader.ts
 import { resolve, join } from "path";
-var CONFIG_FILES = [
-  "bungres.config.ts",
-  "bungres.config.js",
-  "bungres.config.mts",
-  "bungres.config.mjs"
-];
-async function loadConfig(cwd = process.cwd()) {
-  let userConfig = {};
-  for (const file of CONFIG_FILES) {
-    const configPath = join(cwd, file);
-    if (await Bun.file(configPath).exists()) {
-      const mod = await import(resolve(configPath));
-      userConfig = mod.default ?? mod;
-      break;
-    }
-  }
-  const dbUrl = userConfig.dbCredentials?.url ?? process.env["DATABASE_URL"] ?? process.env["POSTGRES_URL"] ?? "";
-  if (!dbUrl) {
-    console.error(`bungres: No database URL found.
-  Add dbCredentials.url to bungres.config.ts  or set DATABASE_URL.`);
-    process.exit(1);
-  }
-  const out = userConfig.out ?? "./migrations";
-  return {
-    schema: userConfig.schema ?? "src/db/schema/**/*.ts",
-    seed: userConfig.seed ?? "src/db/seed.ts",
-    out,
-    dbUrl,
-    dbSchema: userConfig.dbSchema ?? "public",
-    migrationsDir: out,
-    outDir: "./src/db/generated",
-    verbose: userConfig.verbose ?? false
-  };
-}
-
-// src/commands/push.ts
-import * as fs from "fs";
 
-// ../bungres-orm/src/table.ts
+// ../bungres-orm/src/schema/table.ts
 var TableConfigSymbol = Symbol.for("BungresTableConfig");
 function getTableConfig(table) {
   return table[TableConfigSymbol];
@@ -51,8 +14,13 @@ function camelToSnakeCase(str) {
 }
 function createTableFactory(casing) {
   return function(name, columns, extra) {
+    let schema;
+    if (extra && typeof extra !== "function") {
+      schema = extra.schema;
+    }
+    const qualifiedName = schema ? `"${schema}"."${name}"` : `"${name}"`;
     const columnConfigs = Object.fromEntries(Object.entries(columns).map(([key, config2]) => {
-      const c = { ...config2 };
+      const c = { ...config2, tableName: qualifiedName };
       if (!c.name) {
         if (casing === "snake") {
           c.name = camelToSnakeCase(key);
@@ -62,16 +30,40 @@ function createTableFactory(casing) {
       }
       return [key, c];
     }));
-    const schema = extra?.schema;
-    const qualifiedName = schema ? `"${schema}"."${name}"` : `"${name}"`;
+    const indexes = [];
+    const checks = [];
+    const primaryKeys = [];
+    const foreignKeys = [];
+    if (extra) {
+      if (typeof extra === "function") {
+        const builders = extra(columnConfigs);
+        for (const builder of builders) {
+          const config2 = builder.build();
+          if (config2.type === "index")
+            indexes.push(config2);
+          else if (config2.type === "check")
+            checks.push(config2.condition);
+          else if (config2.type === "primaryKey")
+            primaryKeys.push(...config2.columns);
+          else if (config2.type === "foreignKey")
+            foreignKeys.push(config2);
+        }
+      } else {
+        if (extra.indexes)
+          indexes.push(...extra.indexes);
+        if (extra.checks)
+          checks.push(...extra.checks);
+      }
+    }
     const tableObj = {
       [TableConfigSymbol]: {
         name,
         schema,
         columns: columnConfigs,
-        indexes: extra?.indexes ?? [],
-        checks: extra?.checks ?? [],
-        primaryKeys: extra?.primaryKeys ?? [],
+        indexes,
+        checks,
+        primaryKeys,
+        foreignKeys,
         qualifiedName
       }
     };
@@ -81,7 +73,7 @@ function createTableFactory(casing) {
 var table = createTableFactory("none");
 var snakeCase = { table: createTableFactory("snake") };
 var camelCase = { table: createTableFactory("camel") };
-// ../bungres-orm/src/column.ts
+// ../bungres-orm/src/schema/columns.ts
 function buildColumn(dataType, nameOrOpts, opts) {
   let name = "";
   let options = opts;
@@ -135,7 +127,33 @@ var interval = col("interval");
 var inet = col("inet");
 var cidr = col("cidr");
 var macaddr = col("macaddr");
-// ../bungres-orm/src/sql.ts
+var textArray = col("text[]");
+var integerArray = col("integer[]");
+var varcharArray = col("varchar[]");
+var uuidArray = col("uuid[]");
+// ../bungres-orm/src/core/sql.ts
+function sql(strings, ...values) {
+  let query = "";
+  const params = [];
+  for (let i = 0;i < strings.length; i++) {
+    query += strings[i];
+    if (i < values.length) {
+      const val = values[i];
+      if (isSQLChunk(val)) {
+        const offset = params.length;
+        query += val.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+        params.push(...val.params);
+      } else {
+        params.push(val);
+        query += `$${params.length}`;
+      }
+    }
+  }
+  return { sql: query, params };
+}
+function isSQLChunk(value) {
+  return typeof value === "object" && value !== null && "sql" in value && "params" in value && typeof value.sql === "string" && Array.isArray(value.params);
+}
 function sqlJoin(chunks, separator = ", ") {
   const params = [];
   const parts = [];
@@ -146,12 +164,326 @@ function sqlJoin(chunks, separator = ", ") {
   }
   return { sql: parts.join(separator), params };
 }
-// ../bungres-orm/src/query.ts
+function rawSql(query) {
+  return { sql: query, params: [] };
+}
+// ../bungres-orm/src/core/conditions.ts
+var colName = (c) => {
+  if (typeof c === "string")
+    return `"${c}"`;
+  if (isSQLChunk(c))
+    return c.sql;
+  return c.tableName ? `${c.tableName}."${c.name}"` : `"${c.name}"`;
+};
+function isColumnConfig(val) {
+  return val !== null && typeof val === "object" && "name" in val && "dataType" in val;
+}
+var eq = (column, value) => {
+  if (isColumnConfig(value))
+    return sql`${rawSql(colName(column))} = ${rawSql(colName(value))}`;
+  if (isSQLChunk(value))
+    return sql`${rawSql(colName(column))} = ${value}`;
+  return sql`${rawSql(colName(column))} = ${value}`;
+};
+var ne = (column, value) => {
+  if (isColumnConfig(value))
+    return sql`${rawSql(colName(column))} != ${rawSql(colName(value))}`;
+  if (isSQLChunk(value))
+    return sql`${rawSql(colName(column))} != ${value}`;
+  return sql`${rawSql(colName(column))} != ${value}`;
+};
+var gt = (column, value) => {
+  if (isColumnConfig(value))
+    return sql`${rawSql(colName(column))} > ${rawSql(colName(value))}`;
+  if (isSQLChunk(value))
+    return sql`${rawSql(colName(column))} > ${value}`;
+  return sql`${rawSql(colName(column))} > ${value}`;
+};
+var gte = (column, value) => {
+  if (isColumnConfig(value))
+    return sql`${rawSql(colName(column))} >= ${rawSql(colName(value))}`;
+  if (isSQLChunk(value))
+    return sql`${rawSql(colName(column))} >= ${value}`;
+  return sql`${rawSql(colName(column))} >= ${value}`;
+};
+var lt = (column, value) => {
+  if (isColumnConfig(value))
+    return sql`${rawSql(colName(column))} < ${rawSql(colName(value))}`;
+  if (isSQLChunk(value))
+    return sql`${rawSql(colName(column))} < ${value}`;
+  return sql`${rawSql(colName(column))} < ${value}`;
+};
+var lte = (column, value) => {
+  if (isColumnConfig(value))
+    return sql`${rawSql(colName(column))} <= ${rawSql(colName(value))}`;
+  if (isSQLChunk(value))
+    return sql`${rawSql(colName(column))} <= ${value}`;
+  return sql`${rawSql(colName(column))} <= ${value}`;
+};
+var like = (column, pattern) => sql`${rawSql(colName(column))} LIKE ${pattern}`;
+var ilike = (column, pattern) => sql`${rawSql(colName(column))} ILIKE ${pattern}`;
+var isNull = (column) => rawSql(`${colName(column)} IS NULL`);
+var isNotNull = (column) => rawSql(`${colName(column)} IS NOT NULL`);
+var inArray = (column, values) => {
+  if (values.length === 0)
+    return rawSql("FALSE");
+  const params = values;
+  const placeholders = params.map((_, i) => `$${i + 1}`).join(", ");
+  return { sql: `${colName(column)} = ANY(ARRAY[${placeholders}])`, params };
+};
+var and = (...conditions) => sqlJoin(conditions, " AND ");
+var or = (...conditions) => {
+  const joined = sqlJoin(conditions, " OR ");
+  return { sql: `(${joined.sql})`, params: joined.params };
+};
+var not = (condition) => ({
+  sql: `NOT (${condition.sql})`,
+  params: condition.params
+});
+var asc = (column) => sql`${rawSql(colName(column))} ASC`;
+var desc = (column) => sql`${rawSql(colName(column))} DESC`;
+function parseWhereObject(tableConfig, whereObj) {
+  const conditions = [];
+  for (const [key, val] of Object.entries(whereObj)) {
+    if (val === undefined)
+      continue;
+    if (key === "OR") {
+      const orConditions = val.map((o) => parseWhereObject(tableConfig, o));
+      if (orConditions.length > 0)
+        conditions.push(or(...orConditions));
+      continue;
+    }
+    if (key === "AND") {
+      const andConditions = val.map((o) => parseWhereObject(tableConfig, o));
+      if (andConditions.length > 0)
+        conditions.push(and(...andConditions));
+      continue;
+    }
+    if (key === "NOT") {
+      conditions.push(not(parseWhereObject(tableConfig, val)));
+      continue;
+    }
+    const colConfig = tableConfig.columns[key];
+    const columnArg = colConfig ?? key;
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && !(val instanceof Date) && !(val instanceof Uint8Array)) {
+      const opVal = val;
+      if (opVal.eq !== undefined)
+        conditions.push(eq(columnArg, opVal.eq));
+      if (opVal.ne !== undefined)
+        conditions.push(ne(columnArg, opVal.ne));
+      if (opVal.gt !== undefined)
+        conditions.push(gt(columnArg, opVal.gt));
+      if (opVal.gte !== undefined)
+        conditions.push(gte(columnArg, opVal.gte));
+      if (opVal.lt !== undefined)
+        conditions.push(lt(columnArg, opVal.lt));
+      if (opVal.lte !== undefined)
+        conditions.push(lte(columnArg, opVal.lte));
+      if (opVal.in !== undefined)
+        conditions.push(inArray(columnArg, opVal.in));
+      if (opVal.like !== undefined)
+        conditions.push(like(columnArg, opVal.like));
+      if (opVal.ilike !== undefined)
+        conditions.push(ilike(columnArg, opVal.ilike));
+      if (opVal.isNull)
+        conditions.push(isNull(columnArg));
+      if (opVal.isNotNull)
+        conditions.push(isNotNull(columnArg));
+    } else {
+      if (val === null) {
+        conditions.push(isNull(columnArg));
+      } else {
+        conditions.push(eq(columnArg, val));
+      }
+    }
+  }
+  if (conditions.length === 0) {
+    return rawSql("TRUE");
+  }
+  return and(...conditions);
+}
+function parseOrderByObject(tableConfig, orderByObj) {
+  const parts = [];
+  for (const [key, dir] of Object.entries(orderByObj)) {
+    if (dir === undefined)
+      continue;
+    const colConfig = tableConfig.columns[key];
+    const columnArg = colConfig ?? key;
+    if (dir === "asc")
+      parts.push(asc(columnArg));
+    else if (dir === "desc")
+      parts.push(desc(columnArg));
+  }
+  return parts;
+}
+
+// ../bungres-orm/src/builders/delete.ts
+class DeleteBuilder {
+  _table;
+  _executor;
+  _where = [];
+  _returning;
+  _comment;
+  constructor(table2, executor) {
+    this._table = table2;
+    this._executor = executor;
+  }
+  then(onfulfilled, onrejected) {
+    return this._executor.execute(this).then(onfulfilled, onrejected);
+  }
+  async single() {
+    return this._executor.executeSingle(this);
+  }
+  where(condition) {
+    if (condition && typeof condition === "object" && !("sql" in condition)) {
+      this._where.push(parseWhereObject(getTableConfig(this._table), condition));
+    } else {
+      this._where.push(condition);
+    }
+    return this;
+  }
+  returning(...columns) {
+    this._returning = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  comment(tag) {
+    this._comment = tag;
+    return this;
+  }
+  toSQL() {
+    let query = `DELETE FROM ${getTableConfig(this._table).qualifiedName}`;
+    const params = [];
+    if (this._where.length > 0) {
+      const combined = sqlJoin(this._where, " AND ");
+      query += " WHERE " + combined.sql;
+      params.push(...combined.params);
+    }
+    if (this._returning) {
+      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
+    }
+    return { sql: query, params };
+  }
+}
+// ../bungres-orm/src/builders/insert.ts
+class InsertBuilder {
+  _table;
+  _executor;
+  _values = [];
+  _onConflict;
+  _returning;
+  _comment;
+  constructor(table2, executor) {
+    this._table = table2;
+    this._executor = executor;
+  }
+  then(onfulfilled, onrejected) {
+    return this._executor.execute(this).then(onfulfilled, onrejected);
+  }
+  async single() {
+    return this._executor.executeSingle(this);
+  }
+  values(data) {
+    if (Array.isArray(data)) {
+      this._values.push(...data);
+    } else {
+      this._values.push(data);
+    }
+    return this;
+  }
+  onConflictDoNothing() {
+    this._onConflict = "do nothing";
+    return this;
+  }
+  onConflict(clause) {
+    this._onConflict = clause;
+    return this;
+  }
+  returning(...columns) {
+    this._returning = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  comment(tag) {
+    this._comment = tag;
+    return this;
+  }
+  toSQL() {
+    if (this._values.length === 0) {
+      throw new Error("InsertBuilder: no values provided");
+    }
+    const tConfig = getTableConfig(this._table);
+    const keySet = new Set;
+    for (const v of this._values) {
+      for (const k of Object.keys(v)) {
+        keySet.add(k);
+      }
+    }
+    const keys = Array.from(keySet);
+    if (keys.length === 0) {
+      return { sql: `INSERT INTO ${tConfig.qualifiedName} DEFAULT VALUES`, params: [] };
+    }
+    const columnsStr = keys.map((k) => `"${tConfig.columns[k]?.name ?? k}"`).join(", ");
+    const params = [];
+    const valuesStrs = this._values.map((v) => {
+      const vals = keys.map((k) => {
+        const val = v[k];
+        if (val && typeof val === "object" && "sql" in val && "params" in val) {
+          const chunk = val;
+          const offset = params.length;
+          params.push(...chunk.params);
+          return chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+        }
+        if (val && typeof val === "object" && !(val instanceof Date)) {
+          const colType = tConfig.columns[k]?.dataType;
+          if (colType === "json" || colType === "jsonb") {
+            params.push(val);
+          } else if (Array.isArray(val)) {
+            const pgArray = "{" + val.map((item) => {
+              if (item === null || item === undefined)
+                return "NULL";
+              if (typeof item === "string")
+                return '"' + item.replace(/"/g, "\\\"") + '"';
+              return typeof item === "object" ? '"' + JSON.stringify(item).replace(/"/g, "\\\"") + '"' : String(item);
+            }).join(",") + "}";
+            params.push(pgArray);
+          } else {
+            params.push(JSON.stringify(val));
+          }
+          return `$${params.length}`;
+        }
+        if (val === undefined)
+          return "DEFAULT";
+        params.push(val);
+        return `$${params.length}`;
+      });
+      return `(${vals.join(", ")})`;
+    });
+    let query = `INSERT INTO ${tConfig.qualifiedName} (${columnsStr}) VALUES ${valuesStrs.join(", ")}`;
+    if (this._onConflict) {
+      if (this._onConflict === "do nothing") {
+        query += " ON CONFLICT DO NOTHING";
+      } else {
+        const offset = params.length;
+        query += " " + this._onConflict.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+        params.push(...this._onConflict.params);
+      }
+    }
+    if (this._returning) {
+      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(tConfig.columns).map((c) => `"${tConfig.columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${tConfig.columns[c]?.name ?? c}" AS "${c}"`).join(", "));
+    }
+    if (this._comment) {
+      query += ` /* ${this._comment} */`;
+    }
+    return { sql: query, params };
+  }
+}
+// ../bungres-orm/src/builders/select.ts
 class SelectBuilder {
   _table;
   _executor;
   _where = [];
   _orderBy = [];
+  _groupBy = [];
+  _having = [];
   _limit;
   _offset;
   _select;
@@ -178,11 +510,27 @@ class SelectBuilder {
     return this;
   }
   where(condition) {
-    this._where.push(condition);
+    if (condition && typeof condition === "object" && !("sql" in condition)) {
+      this._where.push(parseWhereObject(getTableConfig(this._table), condition));
+    } else {
+      this._where.push(condition);
+    }
     return this;
   }
   orderBy(column, dir = "asc") {
-    this._orderBy.push({ column: typeof column === "string" ? column : column.name, dir });
+    this._orderBy.push({ column, dir });
+    return this;
+  }
+  groupBy(...columns) {
+    this._groupBy.push(...columns);
+    return this;
+  }
+  having(condition) {
+    if (condition && typeof condition === "object" && !("sql" in condition)) {
+      this._having.push(parseWhereObject(getTableConfig(this._table), condition));
+    } else {
+      this._having.push(condition);
+    }
     return this;
   }
   limit(n) {
@@ -197,35 +545,118 @@ class SelectBuilder {
     this._joins.push(rawClause);
     return this;
   }
+  innerJoin(table2, condition) {
+    this._joins.push(sql`INNER JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+    return this;
+  }
+  leftJoin(table2, condition) {
+    this._joins.push(sql`LEFT JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+    return this;
+  }
+  rightJoin(table2, condition) {
+    this._joins.push(sql`RIGHT JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+    return this;
+  }
+  fullJoin(table2, condition) {
+    this._joins.push(sql`FULL JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+    return this;
+  }
+  _buildSelection(selection, params) {
+    const parts = [];
+    for (const [alias, col2] of Object.entries(selection)) {
+      if (typeof col2 === "object" && col2 !== null) {
+        if ("sql" in col2 && "params" in col2) {
+          const chunk = col2;
+          const offset = params.length;
+          params.push(...chunk.params);
+          parts.push(`'${alias}', ${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)}`);
+        } else if ("name" in col2 && "dataType" in col2) {
+          const c = col2;
+          parts.push(`'${alias}', ${c.tableName ? c.tableName + "." : ""}"${c.name}"`);
+        } else {
+          parts.push(`'${alias}', json_build_object(${this._buildSelection(col2, params)})`);
+        }
+      }
+    }
+    return parts.join(", ");
+  }
   toSQL() {
     let cols = "";
+    const params = [];
     if (this._selection) {
-      cols = Object.entries(this._selection).map(([alias, col2]) => `"${col2.name}" AS "${alias}"`).join(", ");
+      cols = Object.entries(this._selection).map(([alias, col2]) => {
+        if (typeof col2 === "object" && col2 !== null && "sql" in col2 && "params" in col2) {
+          const chunk = col2;
+          const offset = params.length;
+          params.push(...chunk.params);
+          return `${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)} AS "${alias}"`;
+        } else if (typeof col2 === "object" && col2 !== null && "name" in col2 && "dataType" in col2) {
+          const c = col2;
+          return `${c.tableName ? c.tableName + "." : ""}"${c.name}" AS "${alias}"`;
+        } else {
+          return `json_build_object(${this._buildSelection(col2, params)}) AS "${alias}"`;
+        }
+      }).join(", ");
     } else if (this._select && this._select.length > 0) {
+      const qName = getTableConfig(this._table).qualifiedName;
       cols = this._select.map((c) => {
         if (typeof c === "string") {
-          return `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`;
+          return `${qName}."${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`;
         }
-        return `"${c.name}" AS "${c.alias || c.name}"`;
+        return `${c.tableName ? c.tableName + "." : ""}"${c.name}" AS "${c.alias || c.name}"`;
       }).join(", ");
     } else {
-      cols = Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ");
+      const qName = getTableConfig(this._table).qualifiedName;
+      cols = Object.keys(getTableConfig(this._table).columns).map((c) => `${qName}."${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ");
     }
     let query = `SELECT ${cols} FROM ${getTableConfig(this._table).qualifiedName}`;
     if (this._joins.length > 0) {
-      query += " " + this._joins.join(" ");
+      const joinChunks = this._joins.map((j) => typeof j === "string" ? rawSql(j) : j);
+      const combinedJoins = sqlJoin(joinChunks, " ");
+      const offset = params.length;
+      query += " " + combinedJoins.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...combinedJoins.params);
     }
-    const params = [];
     if (this._where.length > 0) {
       const combined = sqlJoin(this._where, " AND ");
-      const offset = 0;
+      const offset = params.length;
       query += " WHERE " + combined.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
       params.push(...combined.params);
     }
+    if (this._groupBy.length > 0) {
+      const qName = getTableConfig(this._table).qualifiedName;
+      query += " GROUP BY " + this._groupBy.map((c) => {
+        if (typeof c === "string") {
+          const dbCol = getTableConfig(this._table).columns[c]?.name ?? c;
+          return `${qName}."${dbCol}"`;
+        } else if ("sql" in c && "params" in c) {
+          const offset = params.length;
+          params.push(...c.params);
+          return c.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+        } else {
+          return `${c.tableName ? c.tableName + "." : ""}"${c.name}"`;
+        }
+      }).join(", ");
+    }
+    if (this._having.length > 0) {
+      const combined = sqlJoin(this._having, " AND ");
+      const offset = params.length;
+      query += " HAVING " + combined.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...combined.params);
+    }
     if (this._orderBy.length > 0) {
+      const qName = getTableConfig(this._table).qualifiedName;
       query += " ORDER BY " + this._orderBy.map((o) => {
-        const dbCol = getTableConfig(this._table).columns[o.column]?.name ?? o.column;
-        return `"${dbCol}" ${o.dir.toUpperCase()}`;
+        if (typeof o.column === "string") {
+          const dbCol = getTableConfig(this._table).columns[o.column]?.name ?? o.column;
+          return `${qName}."${dbCol}" ${o.dir.toUpperCase()}`;
+        } else if ("sql" in o.column && "params" in o.column) {
+          const offset = params.length;
+          params.push(...o.column.params);
+          return `${o.column.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)} ${o.dir.toUpperCase()}`;
+        } else {
+          return `${o.column.tableName ? o.column.tableName + "." : ""}"${o.column.name}" ${o.dir.toUpperCase()}`;
+        }
       }).join(", ");
     }
     if (this._limit !== undefined) {
@@ -254,12 +685,12 @@ class SelectBuilderIntermediate {
     return new SelectBuilder(table2, this._executor, this._selection);
   }
 }
-
-class InsertBuilder {
+// ../bungres-orm/src/builders/update.ts
+class UpdateBuilder {
   _table;
   _executor;
-  _values = [];
-  _onConflict;
+  _set = {};
+  _where = [];
   _returning;
   _comment;
   constructor(table2, executor) {
@@ -272,17 +703,16 @@ class InsertBuilder {
   async single() {
     return this._executor.executeSingle(this);
   }
-  values(data) {
-    const rows = Array.isArray(data) ? data : [data];
-    this._values.push(...rows);
-    return this;
-  }
-  onConflictDoNothing() {
-    this._onConflict = "do nothing";
+  set(data) {
+    this._set = { ...this._set, ...data };
     return this;
   }
-  onConflictDoUpdate(clause) {
-    this._onConflict = clause;
+  where(condition) {
+    if (condition && typeof condition === "object" && !("sql" in condition)) {
+      this._where.push(parseWhereObject(getTableConfig(this._table), condition));
+    } else {
+      this._where.push(condition);
+    }
     return this;
   }
   returning(...columns) {
@@ -294,28 +724,46 @@ class InsertBuilder {
     return this;
   }
   toSQL() {
-    if (this._values.length === 0) {
-      throw new Error("InsertBuilder: no values provided");
+    const entries = Object.entries(this._set);
+    if (entries.length === 0) {
+      throw new Error("UpdateBuilder: no fields to set");
     }
-    const keys = Array.from(new Set(this._values.flatMap((v) => Object.keys(v))));
     const params = [];
-    const rowPlaceholders = [];
-    for (const row of this._values) {
-      const placeholders = [];
-      for (const key of keys) {
-        params.push(row[key] ?? null);
-        placeholders.push(`$${params.length}`);
+    const setClauses = entries.map(([key, value]) => {
+      const dbCol = getTableConfig(this._table).columns[key]?.name ?? key;
+      if (value && typeof value === "object" && "sql" in value && "params" in value) {
+        const chunk = value;
+        const offset = params.length;
+        params.push(...chunk.params);
+        return `"${dbCol}" = ${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)}`;
       }
-      rowPlaceholders.push(`(${placeholders.join(", ")})`);
-    }
-    const colList = keys.map((k) => `"${getTableConfig(this._table).columns[k]?.name ?? k}"`).join(", ");
-    let query = `INSERT INTO ${getTableConfig(this._table).qualifiedName} (${colList}) VALUES ${rowPlaceholders.join(", ")}`;
-    if (this._onConflict === "do nothing") {
-      query += " ON CONFLICT DO NOTHING";
-    } else if (this._onConflict && typeof this._onConflict === "object") {
+      if (value && typeof value === "object" && !(value instanceof Date)) {
+        const colType = getTableConfig(this._table).columns[key]?.dataType;
+        if (colType === "json" || colType === "jsonb") {
+          params.push(value);
+        } else if (Array.isArray(value)) {
+          const pgArray = "{" + value.map((item) => {
+            if (item === null || item === undefined)
+              return "NULL";
+            if (typeof item === "string")
+              return '"' + item.replace(/"/g, "\\\"") + '"';
+            return typeof item === "object" ? '"' + JSON.stringify(item).replace(/"/g, "\\\"") + '"' : String(item);
+          }).join(",") + "}";
+          params.push(pgArray);
+        } else {
+          params.push(JSON.stringify(value));
+        }
+        return `"${dbCol}" = $${params.length}`;
+      }
+      params.push(value);
+      return `"${dbCol}" = $${params.length}`;
+    });
+    let query = `UPDATE ${getTableConfig(this._table).qualifiedName} SET ${setClauses.join(", ")}`;
+    if (this._where.length > 0) {
+      const combined = sqlJoin(this._where, " AND ");
       const offset = params.length;
-      query += " ON CONFLICT " + this._onConflict.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
-      params.push(...this._onConflict.params);
+      query += " WHERE " + combined.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...combined.params);
     }
     if (this._returning) {
       query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
@@ -323,109 +771,8 @@ class InsertBuilder {
     return { sql: query, params };
   }
 }
-
-class UpdateBuilder {
-  _table;
-  _executor;
-  _set = {};
-  _where = [];
-  _returning;
-  _comment;
-  constructor(table2, executor) {
-    this._table = table2;
-    this._executor = executor;
-  }
-  then(onfulfilled, onrejected) {
-    return this._executor.execute(this).then(onfulfilled, onrejected);
-  }
-  async single() {
-    return this._executor.executeSingle(this);
-  }
-  set(data) {
-    this._set = { ...this._set, ...data };
-    return this;
-  }
-  where(condition) {
-    this._where.push(condition);
-    return this;
-  }
-  returning(...columns) {
-    this._returning = columns.length > 0 ? columns : ["*"];
-    return this;
-  }
-  comment(tag) {
-    this._comment = tag;
-    return this;
-  }
-  toSQL() {
-    const entries = Object.entries(this._set);
-    if (entries.length === 0) {
-      throw new Error("UpdateBuilder: no fields to set");
-    }
-    const params = [];
-    const setClauses = entries.map(([key, value]) => {
-      params.push(value);
-      const dbCol = getTableConfig(this._table).columns[key]?.name ?? key;
-      return `"${dbCol}" = $${params.length}`;
-    });
-    let query = `UPDATE ${getTableConfig(this._table).qualifiedName} SET ${setClauses.join(", ")}`;
-    if (this._where.length > 0) {
-      const combined = sqlJoin(this._where, " AND ");
-      const offset = params.length;
-      query += " WHERE " + combined.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
-      params.push(...combined.params);
-    }
-    if (this._returning) {
-      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
-    }
-    return { sql: query, params };
-  }
-}
-
-class DeleteBuilder {
-  _table;
-  _executor;
-  _where = [];
-  _returning;
-  _comment;
-  constructor(table2, executor) {
-    this._table = table2;
-    this._executor = executor;
-  }
-  then(onfulfilled, onrejected) {
-    return this._executor.execute(this).then(onfulfilled, onrejected);
-  }
-  async single() {
-    return this._executor.executeSingle(this);
-  }
-  where(condition) {
-    this._where.push(condition);
-    return this;
-  }
-  returning(...columns) {
-    this._returning = columns.length > 0 ? columns : ["*"];
-    return this;
-  }
-  comment(tag) {
-    this._comment = tag;
-    return this;
-  }
-  toSQL() {
-    let query = `DELETE FROM ${getTableConfig(this._table).qualifiedName}`;
-    const params = [];
-    if (this._where.length > 0) {
-      const combined = sqlJoin(this._where, " AND ");
-      query += " WHERE " + combined.sql;
-      params.push(...combined.params);
-    }
-    if (this._returning) {
-      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
-    }
-    return { sql: query, params };
-  }
-}
-// ../bungres-orm/src/relational.ts
-var _relationsCache = new WeakMap;
+// ../bungres-orm/src/builders/relational.ts
+var _relationsCache = new WeakMap;
 
 class RelationalQueryBuilder {
   _executor;
@@ -508,7 +855,7 @@ class RelationalQueryBuilder {
     const ones = {};
     const manys = {};
     const manyToManys = {};
-    for (const [colName, col2] of Object.entries(tConfig.columns)) {
+    for (const [colName2, col2] of Object.entries(tConfig.columns)) {
       if (col2.references) {
         const ref = col2.references;
         const relName = ref.relationName || ref.table;
@@ -517,7 +864,7 @@ class RelationalQueryBuilder {
     }
     for (const [otherName, otherTable] of Object.entries(this._schema)) {
       const otherConfig = otherTable[TableConfigSymbol];
-      for (const [colName, col2] of Object.entries(otherConfig.columns)) {
+      for (const [colName2, col2] of Object.entries(otherConfig.columns)) {
         if (col2.references && col2.references.table === tableName) {
           const ref = col2.references;
           const backRelName = ref.backRelationName || otherName;
@@ -556,10 +903,15 @@ class RelationalQueryBuilder {
     const jsonFields = [];
     const lateralJoins = [];
     const columnsConfig = args.columns;
+    const hasTrue = columnsConfig ? Object.values(columnsConfig).some((v) => v === true) : false;
     for (const [colKey, colConfig] of Object.entries(tableConfig.columns)) {
       if (columnsConfig) {
-        if (columnsConfig[colKey] !== true) {
-          continue;
+        if (hasTrue) {
+          if (columnsConfig[colKey] !== true)
+            continue;
+        } else {
+          if (columnsConfig[colKey] === false)
+            continue;
         }
       }
       jsonFields.push(`'${colKey}', "${alias}"."${colConfig.name}"`);
@@ -618,10 +970,16 @@ class RelationalQueryBuilder {
     if (joinCondition) {
       fromSql += ` WHERE ${joinCondition}`;
     }
-    if (args.where && args.where.sql) {
+    if (args.where) {
       const offset = params.length;
-      fromSql += (joinCondition ? " AND " : " WHERE ") + args.where.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
-      params.push(...args.where.params);
+      let whereChunk = args.where;
+      if (args.where && !args.where.sql) {
+        whereChunk = parseWhereObject(tableConfig, args.where);
+      }
+      if (whereChunk && whereChunk.sql) {
+        fromSql += (joinCondition ? " AND " : " WHERE ") + whereChunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+        params.push(...whereChunk.params);
+      }
     }
     if (args.orderBy) {
       if (typeof args.orderBy === "string") {
@@ -630,6 +988,15 @@ class RelationalQueryBuilder {
         const offset = params.length;
         fromSql += ` ORDER BY ` + args.orderBy.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
         params.push(...args.orderBy.params);
+      } else {
+        const chunks = parseOrderByObject(tableConfig, args.orderBy);
+        if (chunks.length > 0) {
+          fromSql += ` ORDER BY ` + chunks.map((c) => {
+            const offset = params.length;
+            params.push(...c.params);
+            return c.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+          }).join(", ");
+        }
       }
     }
     if (args.limit !== undefined) {
@@ -651,7 +1018,7 @@ class RelationalQueryBuilder {
   }
 }
 
-// ../bungres-orm/src/db.ts
+// ../bungres-orm/src/core/db.ts
 function parseDBName(url) {
   try {
     return new URL(url).pathname.slice(1);
@@ -936,6 +1303,177 @@ function generateDropColumn(tableName, schema, columnName) {
   const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
   return `ALTER TABLE ${tbl} DROP COLUMN IF EXISTS "${columnName}";`;
 }
+// src/schema-loader.ts
+async function loadSchemas(patterns, cwd = process.cwd()) {
+  const globs = Array.isArray(patterns) ? patterns : [patterns];
+  const entries = [];
+  for (const pattern of globs) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan({ cwd, absolute: false })) {
+      const absPath = resolve(join(cwd, file));
+      const mod = await import(absPath);
+      for (const [exportName, value] of Object.entries(mod)) {
+        if (isTable(value)) {
+          entries.push({
+            exportName,
+            config: value[TableConfigSymbol],
+            table: value,
+            filePath: absPath
+          });
+        }
+      }
+    }
+  }
+  return entries;
+}
+function isTable(value) {
+  return typeof value === "object" && value !== null && TableConfigSymbol in value;
+}
+
+// src/utils/colors.ts
+function colorize(text2, color) {
+  const code2 = Bun.color(color, "ansi");
+  return code2 ? `${code2}${text2}\x1B[0m` : text2;
+}
+
+// src/commands/drop.ts
+async function runDrop(config2, opts = {}) {
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    console.warn("No table definitions found in schema files.");
+    return;
+  }
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const existingTablesResult = await sql2`
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' OR table_schema = current_schema()
+    `;
+    const existingTableNames = new Set(existingTablesResult.map((row) => row.table_name));
+    const migrationTableExists = existingTableNames.has("__bungres_migrations");
+    const pushTableExists = existingTableNames.has("__bungres_push");
+    const tablesToDrop = schemas2.filter((s) => existingTableNames.has(s.config.name));
+    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
+      console.log("No tables to drop (they either don't exist or were already dropped).");
+      return;
+    }
+    const tableNamesToPrint = tablesToDrop.map((s) => (s.config.schema ? s.config.schema + "." : "") + s.config.name);
+    if (migrationTableExists) {
+      tableNamesToPrint.push("__bungres_migrations");
+    }
+    if (pushTableExists) {
+      tableNamesToPrint.push("__bungres_push");
+    }
+    if (!opts.force) {
+      console.warn(colorize(`
+\u26A0\uFE0F  WARNING: This will drop the following tables and ALL their data:
+`, "red"));
+      for (const name of tableNamesToPrint)
+        console.log(colorize(`  - ${name}`, "yellow"));
+      process.stdout.write(colorize(`
+Are you sure? Type YES to continue: `, "cyan"));
+      for await (const line2 of console) {
+        if (line2.trim().toLowerCase() !== "yes") {
+          console.log("Aborted.");
+          return;
+        }
+        break;
+      }
+    }
+    for (const entry of tablesToDrop) {
+      const ddl = `DROP TABLE IF EXISTS "${entry.config.name}" CASCADE;`;
+      await sql2.unsafe(ddl);
+      console.log(colorize(`  \u2713 dropped ${entry.config.name}`, "green"));
+    }
+    if (migrationTableExists) {
+      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_migrations CASCADE");
+      console.log(colorize(`  \u2713 dropped __bungres_migrations`, "green"));
+    }
+    if (pushTableExists) {
+      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_push CASCADE");
+      console.log(colorize(`  \u2713 dropped __bungres_push`, "green"));
+    }
+    console.log(colorize(`
+Drop complete.`, "green"));
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/migrate.ts
+import { join as join2, resolve as resolve2 } from "path";
+var MIGRATIONS_TABLE = "__bungres_migrations";
+var CREATE_MIGRATIONS_TABLE = `
+CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (
+  id          SERIAL PRIMARY KEY,
+  name        TEXT NOT NULL UNIQUE,
+  applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+`.trim();
+async function runMigrate(config2) {
+  const migrationsDir = resolve2(config2.migrationsDir);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    await sql2.unsafe(CREATE_MIGRATIONS_TABLE);
+    const glob = new Bun.Glob("*.sql");
+    const files = [];
+    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
+      files.push(file);
+    }
+    files.sort();
+    if (files.length === 0) {
+      console.log(colorize("No migration files found in " + migrationsDir, "yellow"));
+      console.log(colorize("Run `bungres generate` first.", "yellow"));
+      return;
+    }
+    const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE}"`);
+    const appliedSet = new Set(applied.map((r) => r.name));
+    const pending = files.filter((f) => !appliedSet.has(f));
+    if (pending.length === 0) {
+      console.log(colorize("Everything is up to date.", "green"));
+      return;
+    }
+    console.log(colorize(`
+Running ${pending.length} pending migration(s)...
+`, "cyan"));
+    for (const file of pending) {
+      const content = await Bun.file(join2(migrationsDir, file)).text();
+      if (config2.verbose) {
+        console.log(`-- ${file} --
+${content}
+`);
+      }
+      await sql2.transaction(async (txSql) => {
+        const statements = content.split(";").map((s) => s.trim()).filter(Boolean);
+        for (const stmt of statements) {
+          await txSql.unsafe(stmt + ";");
+        }
+        await txSql.unsafe(`INSERT INTO "${MIGRATIONS_TABLE}" (name) VALUES ($1)`, [file]);
+      });
+      console.log(colorize(`  \u2713  ${file}`, "green"));
+    }
+    console.log(colorize(`
+Done.`, "green"));
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/fresh.ts
+async function runFresh(config2) {
+  console.log("Dropping all tables...");
+  await runDrop(config2, { force: true });
+  console.log(`
+Re-running migrations...`);
+  await runMigrate(config2);
+  console.log(`
+Fresh complete.`);
+}
+
+// src/commands/generate.ts
+import { join as join3, resolve as resolve3 } from "path";
+
 // src/differ.ts
 function diffSchemas(prev, next) {
   const statements = [];
@@ -1021,11 +1559,11 @@ function diffSchemas(prev, next) {
       const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
       if (!prevIdxNames.has(idxName)) {
         const tbl = nextConfig.schema ? `"${nextConfig.schema}"."${tableName}"` : `"${tableName}"`;
-        const unique = idx.unique ? "UNIQUE " : "";
+        const unique2 = idx.unique ? "UNIQUE " : "";
         const using = idx.using ? ` USING ${idx.using.toUpperCase()}` : "";
         const cols = idx.columns.map((c) => `"${c}"`).join(", ");
         const where = idx.where ? ` WHERE ${idx.where}` : "";
-        statements.push(`CREATE ${unique}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`);
+        statements.push(`CREATE ${unique2}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`);
         summary.push(`CREATE INDEX ${idxName} ON ${tableName}`);
       }
     }
@@ -1080,133 +1618,25 @@ function diffColumn(prev, next) {
     if (nextDef !== undefined) {
       const val = next.defaultFn ?? formatDefault(next.defaultValue, next.dataType);
       changes.push(`ALTER COLUMN ${col2} SET DEFAULT ${val}`);
-    } else {
-      changes.push(`ALTER COLUMN ${col2} DROP DEFAULT`);
-    }
-  }
-  return changes;
-}
-function formatDefault(value, dataType) {
-  if (value === null || value === undefined)
-    return "NULL";
-  if (typeof value === "boolean")
-    return value ? "TRUE" : "FALSE";
-  if (typeof value === "number")
-    return String(value);
-  if (typeof value === "string") {
-    if (dataType === "boolean")
-      return value;
-    return `'${value.replace(/'/g, "''")}'`;
-  }
-  return `'${JSON.stringify(value)}'`;
-}
-
-// src/schema-loader.ts
-import { resolve as resolve2, join as join2 } from "path";
-async function loadSchemas(patterns, cwd = process.cwd()) {
-  const globs = Array.isArray(patterns) ? patterns : [patterns];
-  const entries = [];
-  for (const pattern of globs) {
-    const glob = new Bun.Glob(pattern);
-    for await (const file of glob.scan({ cwd, absolute: false })) {
-      const absPath = resolve2(join2(cwd, file));
-      const mod = await import(absPath);
-      for (const [exportName, value] of Object.entries(mod)) {
-        if (isTable(value)) {
-          entries.push({
-            exportName,
-            config: value[TableConfigSymbol],
-            table: value,
-            filePath: absPath
-          });
-        }
-      }
-    }
-  }
-  return entries;
-}
-function isTable(value) {
-  return typeof value === "object" && value !== null && TableConfigSymbol in value;
-}
-
-// src/commands/push.ts
-async function runPush(config2, opts = {}) {
-  console.log("@bungres/kit push: loading schemas...");
-  const schemas2 = await loadSchemas(config2.schema);
-  if (schemas2.length === 0) {
-    console.warn("No table definitions found. Check your schema glob pattern.");
-    return;
-  }
-  const sql2 = new Bun.SQL(config2.dbUrl);
-  try {
-    await sql2.unsafe(`
-      CREATE TABLE IF NOT EXISTS public.__bungres_push (
-        id SERIAL PRIMARY KEY,
-        snapshot JSONB NOT NULL
-      );
-    `);
-    const rows = await sql2.unsafe(`SELECT snapshot FROM public.__bungres_push ORDER BY id DESC LIMIT 1;`);
-    let prevSnapshot = {};
-    if (rows.length > 0) {
-      prevSnapshot = typeof rows[0].snapshot === "string" ? JSON.parse(rows[0].snapshot) : rows[0].snapshot;
-    }
-    const currentSnapshot = Object.fromEntries(schemas2.map((s) => [s.config.name, s.config]));
-    const diff = diffSchemas(prevSnapshot, currentSnapshot);
-    if (diff.statements.length === 0) {
-      console.log(`
-No schema changes detected. Database is up to date.`);
-      return;
-    }
-    console.log(`
-Changes to apply:`);
-    for (const s of diff.summary)
-      console.log(`  + ${s}`);
-    if (diff.warnings && diff.warnings.length > 0) {
-      console.warn(`
-  \u26A0\uFE0F  WARNING: Data Loss Detected!`);
-      for (const w of diff.warnings)
-        console.warn(`    ! ${w}`);
-      console.warn(`
-  These changes will be immediately executed against the database!`);
-    }
-    if (!opts.force) {
-      process.stdout.write(`
-Are you sure you want to push these changes? Type YES to continue: `);
-      const answer = await readLine();
-      if (answer.trim().toLowerCase() !== "yes") {
-        console.log("Aborted.");
-        return;
-      }
-    }
-    console.log(`
-Pushing changes...`);
-    await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "pgcrypto";`);
-    for (const stmt of diff.statements) {
-      if (config2.verbose) {
-        console.log(`-- ${stmt}`);
-      }
-      await sql2.unsafe(stmt);
-    }
-    await sql2.unsafe(`INSERT INTO public.__bungres_push (snapshot) VALUES ($1);`, [JSON.stringify(currentSnapshot)]);
-    console.log(`
-Push complete.`);
-  } finally {
-    await sql2.end();
-  }
-}
-async function readLine() {
-  const buf = Buffer.alloc(256);
-  const n = fs.readSync(0, buf, 0, 256, null);
-  return buf.subarray(0, n).toString().trim();
+    } else {
+      changes.push(`ALTER COLUMN ${col2} DROP DEFAULT`);
+    }
+  }
+  return changes;
 }
-
-// src/commands/generate.ts
-import { join as join3, resolve as resolve3 } from "path";
-
-// src/utils/colors.ts
-function colorize(text2, color) {
-  const code2 = Bun.color(color, "ansi");
-  return code2 ? `${code2}${text2}\x1B[0m` : text2;
+function formatDefault(value, dataType) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string") {
+    if (dataType === "boolean")
+      return value;
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return `'${JSON.stringify(value)}'`;
 }
 
 // src/commands/generate.ts
@@ -1310,69 +1740,93 @@ function topoSort(schemas2) {
   return result2;
 }
 
-// src/commands/migrate.ts
-import { join as join4, resolve as resolve4 } from "path";
-var MIGRATIONS_TABLE = "__bungres_migrations";
-var CREATE_MIGRATIONS_TABLE = `
-CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (
-  id          SERIAL PRIMARY KEY,
-  name        TEXT NOT NULL UNIQUE,
-  applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-`.trim();
-async function runMigrate(config2) {
-  const migrationsDir = resolve4(config2.migrationsDir);
-  const sql2 = new Bun.SQL(config2.dbUrl);
+// src/commands/init.ts
+import { existsSync } from "fs";
+import { mkdir } from "fs/promises";
+import { join as join4 } from "path";
+async function runInit(cwd = process.cwd()) {
+  const configPath = join4(cwd, "bungres.config.ts");
+  const dbDir = join4(cwd, "src", "db");
+  if (existsSync(configPath)) {
+    console.log("Config file already exists at bungres.config.ts");
+    return;
+  }
   try {
-    await sql2.unsafe(CREATE_MIGRATIONS_TABLE);
-    const glob = new Bun.Glob("*.sql");
-    const files = [];
-    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
-      files.push(file);
-    }
-    files.sort();
-    if (files.length === 0) {
-      console.log(colorize("No migration files found in " + migrationsDir, "yellow"));
-      console.log(colorize("Run `bungres generate` first.", "yellow"));
-      return;
-    }
-    const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE}"`);
-    const appliedSet = new Set(applied.map((r) => r.name));
-    const pending = files.filter((f) => !appliedSet.has(f));
-    if (pending.length === 0) {
-      console.log(colorize("Everything is up to date.", "green"));
-      return;
-    }
-    console.log(colorize(`
-Running ${pending.length} pending migration(s)...
-`, "cyan"));
-    for (const file of pending) {
-      const content = await Bun.file(join4(migrationsDir, file)).text();
-      if (config2.verbose) {
-        console.log(`-- ${file} --
-${content}
-`);
-      }
-      await sql2.transaction(async (txSql) => {
-        const statements = content.split(";").map((s) => s.trim()).filter(Boolean);
-        for (const stmt of statements) {
-          await txSql.unsafe(stmt + ";");
-        }
-        await txSql.unsafe(`INSERT INTO "${MIGRATIONS_TABLE}" (name) VALUES ($1)`, [file]);
-      });
-      console.log(colorize(`  \u2713  ${file}`, "green"));
-    }
-    console.log(colorize(`
-Done.`, "green"));
-  } finally {
-    await sql2.end();
+    await mkdir(dbDir, { recursive: true });
+    console.log("Created src/db directory");
+  } catch (e) {
+    console.error("Failed to create src/db directory:", e);
+    return;
+  }
+  const configContent = `import { defineConfig } from "@bungres/kit";
+
+export default defineConfig({
+  schema: "./src/db/schema.ts",
+  out: "./bungres",
+  dbCredentials: {
+    url: Bun.env.DATABASE_URL!,
+  },
+});
+`;
+  try {
+    await Bun.write(configPath, configContent);
+    console.log("Created bungres.config.ts");
+  } catch (e) {
+    console.error("Failed to create config file:", e);
+    return;
+  }
+  const schemaContent = `import {
+  uuid,
+  varchar,
+  timestamptz,
+  snakeCase,
+  unique,
+  index
+} from "@bungres/orm";
+
+export const users = snakeCase.table("users", {
+  id: uuid({ primaryKey: true }),
+  name: varchar({ length: 255, notNull: true }),
+  email: varchar({ length: 255, notNull: true }),
+  createdAt: timestamptz({ notNull: true, defaultRaw: "NOW()" }),
+}, (t) => [
+  unique().on(t.email),
+  index().on(t.email),
+]);
+`;
+  try {
+    await Bun.write(join4(dbDir, "schema.ts"), schemaContent);
+    console.log("Created src/db/schema.ts with example table");
+  } catch (e) {
+    console.error("Failed to create schema file:", e);
+  }
+  const clientContent = `import { createDB } from "@bungres/orm";
+import * as schema from "./schema";
+
+const url = Bun.env.DATABASE_URL || "postgres://postgres:postgres@localhost:5432/postgres";
+
+export const db = createDB({ url, schema });
+`;
+  try {
+    await Bun.write(join4(dbDir, "client.ts"), clientContent);
+    console.log("Created src/db/client.ts");
+  } catch (e) {
+    console.error("Failed to create client file:", e);
   }
+  console.log(`
+\u2728 Bungres project initialized!`);
+  console.log(`
+Next steps:`);
+  console.log("  1. Set DATABASE_URL in your .env file");
+  console.log("  2. Edit src/db/schema.ts to define your tables");
+  console.log("  3. Run 'bungres generate' to create migrations");
+  console.log("  4. Run 'bungres migrate' to apply migrations");
 }
 
 // src/commands/pull.ts
-import { resolve as resolve5, join as join5 } from "path";
+import { resolve as resolve4, join as join5 } from "path";
 async function introspectDb(sql2, dbSchema) {
-  const columns = await sql2.unsafe(`SELECT
+  const columns2 = await sql2.unsafe(`SELECT
       c.table_name,
       c.column_name,
       c.data_type,
@@ -1406,7 +1860,7 @@ async function introspectDb(sql2, dbSchema) {
   const indexes = await sql2.unsafe(`SELECT tablename, indexname, indexdef
      FROM pg_indexes
      WHERE schemaname = $1`, [dbSchema]);
-  return groupByTable(columns, constraints, indexes);
+  return groupByTable(columns2, constraints, indexes);
 }
 async function runPull(config2) {
   console.log("@bungres/kit pull: introspecting database...");
@@ -1418,7 +1872,7 @@ async function runPull(config2) {
       console.log("No tables found in schema:", dbSchema);
       return;
     }
-    const outDir = resolve5(config2.outDir);
+    const outDir = resolve4(config2.outDir);
     await Bun.$`mkdir -p ${outDir}`.quiet();
     const outPath = join5(outDir, "schema.ts");
     const code2 = generateSchemaTS(tableMap, dbSchema);
@@ -1429,9 +1883,9 @@ async function runPull(config2) {
     await sql2.end();
   }
 }
-function groupByTable(columns, constraints, indexes) {
+function groupByTable(columns2, constraints, indexes) {
   const map = new Map;
-  for (const col2 of columns) {
+  for (const col2 of columns2) {
     if (!map.has(col2.table_name)) {
       map.set(col2.table_name, {
         tableName: col2.table_name,
@@ -1467,21 +1921,22 @@ function generateSchemaTS(tableMap, dbSchema) {
     `// Generated at: ${new Date().toISOString()}`,
     ``,
     `import {`,
-    `  table,`,
+    `  snakeCase,`,
     `  text, varchar, char, integer, bigint, smallint,`,
     `  serial, bigserial, boolean, real, doublePrecision,`,
     `  numeric, decimal, json, jsonb,`,
     `  timestamp, timestamptz, date, time, uuid,`,
     `  bytea, inet,`,
+    `  textArray, integerArray, varcharArray, uuidArray,`,
     `} from "@bungres/orm";`,
     ``
   ];
   for (const [, table2] of tableMap) {
     const varName = toCamelCase(table2.tableName);
-    lines.push(`export const ${varName} = table("${table2.tableName}", {`);
+    lines.push(`export const ${varName} = snakeCase.table("${table2.tableName}", {`);
     for (const col2 of table2.columns) {
       const colExpr = buildColumnExpression(col2);
-      lines.push(`  ${col2.name}: ${colExpr},`);
+      lines.push(`  ${toCamelCase(col2.name)}: ${colExpr},`);
     }
     const options = [];
     if (dbSchema !== "public") {
@@ -1528,209 +1983,172 @@ function generateSchemaTS(tableMap, dbSchema) {
 `);
 }
 function buildColumnExpression(col2) {
-  let expr = pgTypeToBungresBuilder(col2);
+  const opts = [];
+  if (col2.dataType === "character varying" || col2.dataType === "character") {
+    if (col2.maxLength)
+      opts.push(`length: ${col2.maxLength}`);
+  }
   if (col2.isPrimary)
-    expr += `.primaryKey()`;
+    opts.push(`primaryKey: true`);
   else if (!col2.isNullable)
-    expr += `.notNull()`;
+    opts.push(`notNull: true`);
   if (col2.isUnique && !col2.isPrimary)
-    expr += `.unique()`;
+    opts.push(`unique: true`);
   if (col2.columnDefault !== null && !col2.isPrimary) {
     if (col2.columnDefault.includes("(")) {
-      expr += `.defaultRaw("${col2.columnDefault}")`;
-    } else if (col2.dataType === "boolean") {
-      expr += `.default(${col2.columnDefault})`;
-    } else if (col2.dataType.includes("int") || col2.dataType.includes("numeric") || col2.dataType.includes("real") || col2.dataType.includes("double")) {
-      expr += `.default(${col2.columnDefault})`;
+      opts.push(`defaultRaw: "${col2.columnDefault}"`);
+    } else if (col2.dataType === "boolean" || col2.dataType.includes("int") || col2.dataType.includes("numeric") || col2.dataType.includes("real") || col2.dataType.includes("double")) {
+      opts.push(`default: ${col2.columnDefault}`);
     } else {
       const cleaned = col2.columnDefault.replace(/^'(.*)'::.*$/, "$1");
-      expr += `.default("${cleaned}")`;
+      opts.push(`default: "${cleaned}"`);
     }
   }
   if (col2.foreignTable && col2.foreignColumn) {
     const deleteRule = col2.deleteRule?.toLowerCase().replace(" ", " ");
     const updateRule = col2.updateRule?.toLowerCase().replace(" ", " ");
-    let refOpts = "";
-    if (deleteRule && deleteRule !== "no action") {
-      refOpts += `onDelete: "${deleteRule}", `;
-    }
-    if (updateRule && updateRule !== "no action") {
-      refOpts += `onUpdate: "${updateRule}"`;
-    }
-    const opts = refOpts ? `, { ${refOpts.trim().replace(/,$/, "")} }` : "";
-    expr += `.references("${col2.foreignTable}", "${col2.foreignColumn}"${opts})`;
-  }
-  return expr;
+    let refOpts = `table: "${col2.foreignTable}", column: "${col2.foreignColumn}"`;
+    if (deleteRule && deleteRule !== "no action")
+      refOpts += `, onDelete: "${deleteRule}"`;
+    if (updateRule && updateRule !== "no action")
+      refOpts += `, onUpdate: "${updateRule}"`;
+    opts.push(`references: { ${refOpts} }`);
+  }
+  let builderName = pgTypeToBungresBuilderName(col2);
+  if (opts.length > 0) {
+    return `${builderName}({ ${opts.join(", ")} })`;
+  }
+  return `${builderName}()`;
 }
-function pgTypeToBungresBuilder(col2) {
+function pgTypeToBungresBuilderName(col2) {
   const dt = col2.dataType;
-  const name = col2.name;
   if (dt === "uuid")
-    return `uuid("${name}")`;
+    return "uuid";
   if (dt === "text")
-    return `text("${name}")`;
+    return "text";
   if (dt === "character varying")
-    return col2.maxLength ? `varchar("${name}", ${col2.maxLength})` : `varchar("${name}")`;
+    return "varchar";
   if (dt === "character")
-    return col2.maxLength ? `char("${name}", ${col2.maxLength})` : `char("${name}")`;
+    return "char";
   if (dt === "integer")
-    return `integer("${name}")`;
+    return "integer";
   if (dt === "bigint")
-    return `bigint("${name}")`;
+    return "bigint";
   if (dt === "smallint")
-    return `smallint("${name}")`;
+    return "smallint";
   if (dt === "boolean")
-    return `boolean("${name}")`;
+    return "boolean";
   if (dt === "real")
-    return `real("${name}")`;
+    return "real";
   if (dt === "double precision")
-    return `doublePrecision("${name}")`;
+    return "doublePrecision";
   if (dt === "numeric" || dt === "decimal")
-    return `numeric("${name}")`;
+    return "numeric";
   if (dt === "json")
-    return `json("${name}")`;
+    return "json";
   if (dt === "jsonb")
-    return `jsonb("${name}")`;
+    return "jsonb";
   if (dt === "timestamp without time zone")
-    return `timestamp("${name}")`;
+    return "timestamp";
   if (dt === "timestamp with time zone")
-    return `timestamptz("${name}")`;
+    return "timestamptz";
   if (dt === "date")
-    return `date("${name}")`;
+    return "date";
   if (dt === "time without time zone")
-    return `time("${name}")`;
+    return "time";
   if (dt === "bytea")
-    return `bytea("${name}")`;
+    return "bytea";
   if (dt === "inet")
-    return `inet("${name}")`;
+    return "inet";
   if (dt === "USER-DEFINED" && col2.udtName === "citext")
-    return `text("${name}")`;
-  return `text("${name}") /* original type: ${dt} */`;
+    return "text";
+  if (dt === "ARRAY") {
+    if (col2.udtName === "_text")
+      return "textArray";
+    if (col2.udtName === "_int4" || col2.udtName === "_int8")
+      return "integerArray";
+    if (col2.udtName === "_varchar")
+      return "varcharArray";
+    if (col2.udtName === "_uuid")
+      return "uuidArray";
+    return "textArray";
+  }
+  return "text";
 }
 function toCamelCase(str) {
   return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 }
 
-// src/commands/status.ts
-import { resolve as resolve6 } from "path";
-var MIGRATIONS_TABLE2 = "__bungres_migrations";
-async function runStatus(config2) {
-  const migrationsDir = resolve6(config2.migrationsDir);
-  const sql2 = new Bun.SQL(config2.dbUrl);
-  try {
-    const tableCheck = await sql2.unsafe(`SELECT EXISTS (
-        SELECT 1 FROM information_schema.tables
-        WHERE table_name = $1
-      ) AS exists`, [MIGRATIONS_TABLE2]);
-    const trackingExists = tableCheck[0]?.exists ?? false;
-    const glob = new Bun.Glob("*.sql");
-    const files = [];
-    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
-      files.push(file);
-    }
-    files.sort();
-    if (files.length === 0) {
-      console.log(colorize("No migration files found. Run `bungres generate` first.", "yellow"));
-      return;
-    }
-    let appliedSet = new Set;
-    if (trackingExists) {
-      const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE2}" ORDER BY applied_at`);
-      appliedSet = new Set(applied.map((r) => r.name));
-    }
-    console.log(colorize(`
-Migration status:
-`, "cyan"));
-    let pendingCount = 0;
-    for (const file of files) {
-      const isApplied = appliedSet.has(file);
-      const status = isApplied ? colorize("\u2713 applied ", "green") : colorize("\u2717 pending ", "yellow");
-      if (!isApplied)
-        pendingCount++;
-      console.log(`  ${status}  ${file}`);
-    }
-    console.log(`
-${colorize(appliedSet.size.toString(), "green")} applied, ${colorize(pendingCount.toString(), "yellow")} pending.
-`);
-  } finally {
-    await sql2.end();
-  }
-}
-
-// src/commands/drop.ts
-async function runDrop(config2, opts = {}) {
+// src/commands/push.ts
+import * as fs from "fs";
+async function runPush(config2, opts = {}) {
+  console.log("@bungres/kit push: loading schemas...");
   const schemas2 = await loadSchemas(config2.schema);
   if (schemas2.length === 0) {
-    console.warn("No table definitions found in schema files.");
+    console.warn("No table definitions found. Check your schema glob pattern.");
     return;
   }
   const sql2 = new Bun.SQL(config2.dbUrl);
   try {
-    const existingTablesResult = await sql2`
-      SELECT table_name 
-      FROM information_schema.tables 
-      WHERE table_schema = 'public' OR table_schema = current_schema()
-    `;
-    const existingTableNames = new Set(existingTablesResult.map((row) => row.table_name));
-    const migrationTableExists = existingTableNames.has("__bungres_migrations");
-    const pushTableExists = existingTableNames.has("__bungres_push");
-    const tablesToDrop = schemas2.filter((s) => existingTableNames.has(s.config.name));
-    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
-      console.log("No tables to drop (they either don't exist or were already dropped).");
-      return;
+    await sql2.unsafe(`
+      CREATE TABLE IF NOT EXISTS public.__bungres_push (
+        id SERIAL PRIMARY KEY,
+        snapshot JSONB NOT NULL
+      );
+    `);
+    const rows = await sql2.unsafe(`SELECT snapshot FROM public.__bungres_push ORDER BY id DESC LIMIT 1;`);
+    let prevSnapshot = {};
+    if (rows.length > 0) {
+      prevSnapshot = typeof rows[0].snapshot === "string" ? JSON.parse(rows[0].snapshot) : rows[0].snapshot;
     }
-    const tableNamesToPrint = tablesToDrop.map((s) => (s.config.schema ? s.config.schema + "." : "") + s.config.name);
-    if (migrationTableExists) {
-      tableNamesToPrint.push("__bungres_migrations");
+    const currentSnapshot = Object.fromEntries(schemas2.map((s) => [s.config.name, s.config]));
+    const diff = diffSchemas(prevSnapshot, currentSnapshot);
+    if (diff.statements.length === 0) {
+      console.log(`
+No schema changes detected. Database is up to date.`);
+      return;
     }
-    if (pushTableExists) {
-      tableNamesToPrint.push("__bungres_push");
+    console.log(`
+Changes to apply:`);
+    for (const s of diff.summary)
+      console.log(`  + ${s}`);
+    if (diff.warnings && diff.warnings.length > 0) {
+      console.warn(`
+  \u26A0\uFE0F  WARNING: Data Loss Detected!`);
+      for (const w of diff.warnings)
+        console.warn(`    ! ${w}`);
+      console.warn(`
+  These changes will be immediately executed against the database!`);
     }
     if (!opts.force) {
-      console.warn(colorize(`
-\u26A0\uFE0F  WARNING: This will drop the following tables and ALL their data:
-`, "red"));
-      for (const name of tableNamesToPrint)
-        console.log(colorize(`  - ${name}`, "yellow"));
-      process.stdout.write(colorize(`
-Are you sure? Type YES to continue: `, "cyan"));
-      for await (const line2 of console) {
-        if (line2.trim().toLowerCase() !== "yes") {
-          console.log("Aborted.");
-          return;
-        }
-        break;
+      process.stdout.write(`
+Are you sure you want to push these changes? Type YES to continue: `);
+      const answer = await readLine();
+      if (answer.trim().toLowerCase() !== "yes") {
+        console.log("Aborted.");
+        return;
       }
     }
-    for (const entry of tablesToDrop) {
-      const ddl = `DROP TABLE IF EXISTS "${entry.config.name}" CASCADE;`;
-      await sql2.unsafe(ddl);
-      console.log(colorize(`  \u2713 dropped ${entry.config.name}`, "green"));
-    }
-    if (migrationTableExists) {
-      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_migrations CASCADE");
-      console.log(colorize(`  \u2713 dropped __bungres_migrations`, "green"));
-    }
-    if (pushTableExists) {
-      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_push CASCADE");
-      console.log(colorize(`  \u2713 dropped __bungres_push`, "green"));
+    console.log(`
+Pushing changes...`);
+    await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "pgcrypto";`);
+    for (const stmt of diff.statements) {
+      if (config2.verbose) {
+        console.log(`-- ${stmt}`);
+      }
+      await sql2.unsafe(stmt);
     }
-    console.log(colorize(`
-Drop complete.`, "green"));
-  } finally {
-    await sql2.end();
-  }
-}
-
-// src/commands/fresh.ts
-async function runFresh(config2) {
-  console.log("Dropping all tables...");
-  await runDrop(config2, { force: true });
-  console.log(`
-Re-running migrations...`);
-  await runMigrate(config2);
-  console.log(`
-Fresh complete.`);
+    await sql2.unsafe(`INSERT INTO public.__bungres_push (snapshot) VALUES ($1);`, [JSON.stringify(currentSnapshot)]);
+    console.log(`
+Push complete.`);
+  } finally {
+    await sql2.end();
+  }
+}
+async function readLine() {
+  const buf = Buffer.alloc(256);
+  const n = fs.readSync(0, buf, 0, 256, null);
+  return buf.subarray(0, n).toString().trim();
 }
 
 // src/commands/refresh.ts
@@ -1757,13 +2175,13 @@ Refresh complete. All tables are now empty.`, "green"));
 }
 
 // src/commands/seed.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve5 } from "path";
 async function runSeed(config2) {
   if (!config2.seed) {
     console.log(colorize(`No seed file configured in bungres.config.ts`, "yellow"));
     return;
   }
-  const seedPath = resolve7(process.cwd(), config2.seed);
+  const seedPath = resolve5(process.cwd(), config2.seed);
   const file = Bun.file(seedPath);
   if (!await file.exists()) {
     console.error(colorize(`Seed file not found at ${seedPath}`, "red"));
@@ -1788,6 +2206,52 @@ Seed failed with exit code ${exitCode}.`);
   }
 }
 
+// src/commands/status.ts
+import { resolve as resolve6 } from "path";
+var MIGRATIONS_TABLE2 = "__bungres_migrations";
+async function runStatus(config2) {
+  const migrationsDir = resolve6(config2.migrationsDir);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const tableCheck = await sql2.unsafe(`SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_name = $1
+      ) AS exists`, [MIGRATIONS_TABLE2]);
+    const trackingExists = tableCheck[0]?.exists ?? false;
+    const glob = new Bun.Glob("*.sql");
+    const files = [];
+    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
+      files.push(file);
+    }
+    files.sort();
+    if (files.length === 0) {
+      console.log(colorize("No migration files found. Run `bungres generate` first.", "yellow"));
+      return;
+    }
+    let appliedSet = new Set;
+    if (trackingExists) {
+      const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE2}" ORDER BY applied_at`);
+      appliedSet = new Set(applied.map((r) => r.name));
+    }
+    console.log(colorize(`
+Migration status:
+`, "cyan"));
+    let pendingCount = 0;
+    for (const file of files) {
+      const isApplied = appliedSet.has(file);
+      const status = isApplied ? colorize("\u2713 applied ", "green") : colorize("\u2717 pending ", "yellow");
+      if (!isApplied)
+        pendingCount++;
+      console.log(`  ${status}  ${file}`);
+    }
+    console.log(`
+${colorize(appliedSet.size.toString(), "green")} applied, ${colorize(pendingCount.toString(), "yellow")} pending.
+`);
+  } finally {
+    await sql2.end();
+  }
+}
+
 // src/commands/studio.ts
 async function runStudio(config2) {
   const schemas2 = await loadSchemas(config2.schema);
@@ -1826,8 +2290,19 @@ async function runStudio(config2) {
           return new Response("Table not found", { status: 404 });
         }
         try {
-          const data = await db2.select().from(schema.table).limit(100);
-          return new Response(JSON.stringify(data), {
+          const page = parseInt(url.searchParams.get("page") || "1", 10);
+          const limit = parseInt(url.searchParams.get("limit") || "50", 10);
+          const offset = (page - 1) * limit;
+          const countResult = await db2.select({ count: schema.table }).from(schema.table);
+          const total = Array.isArray(countResult) ? countResult.length : 0;
+          const data = await db2.select().from(schema.table).limit(limit).offset(offset);
+          return new Response(JSON.stringify({
+            data,
+            total,
+            page,
+            limit,
+            totalPages: Math.ceil(total / limit)
+          }), {
             headers: { "Content-Type": "application/json" }
           });
         } catch (e) {
@@ -1877,18 +2352,26 @@ var htmlTemplate = `
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Bungres Studio</title>
-  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700&display=swap" rel="stylesheet">
   <style>
     :root {
-      --bg-color: #0d1117;
-      --panel-bg: #161b22;
-      --border-color: #30363d;
-      --text-main: #c9d1d9;
-      --text-muted: #8b949e;
-      --accent-color: #58a6ff;
-      --accent-hover: #1f6feb;
-      --header-bg: #161b22;
-      --row-hover: #1f2428;
+      --bg-color: #09090b;
+      --panel-bg: rgba(24, 24, 27, 0.7);
+      --border-color: #27272a;
+      --text-main: #f4f4f5;
+      --text-muted: #a1a1aa;
+      --accent-color: #8b5cf6;
+      --accent-hover: #7c3aed;
+      --header-bg: rgba(9, 9, 11, 0.85);
+      --row-hover: rgba(39, 39, 42, 0.8);
+      --glass-border: rgba(255, 255, 255, 0.08);
+      
+      --type-number: #f472b6;
+      --type-string: #60a5fa;
+      --type-boolean: #34d399;
+      --type-date: #c084fc;
+      --type-json: #fbbf24;
+      --type-null: #71717a;
     }
 
     * { box-sizing: border-box; }
@@ -1896,7 +2379,7 @@ var htmlTemplate = `
     body {
       margin: 0;
       padding: 0;
-      font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+      font-family: 'Outfit', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
       background-color: var(--bg-color);
       color: var(--text-main);
       display: flex;
@@ -1906,56 +2389,91 @@ var htmlTemplate = `
 
     /* Sidebar */
     .sidebar {
-      width: 250px;
+      width: 280px;
       background-color: var(--panel-bg);
+      backdrop-filter: blur(12px);
+      -webkit-backdrop-filter: blur(12px);
       border-right: 1px solid var(--border-color);
       display: flex;
       flex-direction: column;
+      box-shadow: 4px 0 24px rgba(0,0,0,0.2);
+      z-index: 20;
     }
 
     .sidebar-header {
-      padding: 20px;
-      border-bottom: 1px solid var(--border-color);
+      padding: 24px;
+      border-bottom: 1px solid var(--glass-border);
       display: flex;
       align-items: center;
-      gap: 10px;
+      gap: 12px;
+      background: linear-gradient(to bottom, rgba(255,255,255,0.03), transparent);
     }
 
     .sidebar-header h1 {
       margin: 0;
-      font-size: 16px;
+      font-size: 18px;
       font-weight: 600;
-      color: white;
+      background: linear-gradient(to right, #fff, #a1a1aa);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      letter-spacing: -0.5px;
+    }
+
+    .sidebar-header svg {
+      color: var(--accent-color);
+      filter: drop-shadow(0 0 8px rgba(139, 92, 246, 0.5));
     }
 
     .table-list {
       flex: 1;
       overflow-y: auto;
-      padding: 10px 0;
+      padding: 16px 12px;
       list-style: none;
       margin: 0;
     }
 
+    .table-list::-webkit-scrollbar {
+      width: 6px;
+    }
+    .table-list::-webkit-scrollbar-thumb {
+      background: #3f3f46;
+      border-radius: 4px;
+    }
+
     .table-item {
-      padding: 8px 20px;
+      padding: 12px 16px;
       cursor: pointer;
-      font-size: 14px;
+      font-size: 15px;
+      font-weight: 500;
       color: var(--text-muted);
-      transition: all 0.2s ease;
+      border-radius: 8px;
+      transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
       display: flex;
       align-items: center;
-      gap: 8px;
+      gap: 10px;
+      margin-bottom: 4px;
+      border: 1px solid transparent;
     }
 
     .table-item:hover {
-      background-color: var(--row-hover);
+      background-color: rgba(255, 255, 255, 0.05);
       color: var(--text-main);
+      transform: translateX(4px);
     }
 
     .table-item.active {
-      background-color: rgba(88, 166, 255, 0.1);
+      background-color: rgba(139, 92, 246, 0.15);
+      color: #fff;
+      border: 1px solid rgba(139, 92, 246, 0.3);
+      box-shadow: 0 4px 12px rgba(139, 92, 246, 0.1);
+    }
+
+    .table-item svg {
+      transition: transform 0.3s ease;
+    }
+    .table-item.active svg {
       color: var(--accent-color);
-      border-right: 3px solid var(--accent-color);
+      transform: scale(1.1);
     }
 
     /* Main Content */
@@ -1963,92 +2481,168 @@ var htmlTemplate = `
       flex: 1;
       display: flex;
       flex-direction: column;
-      background-color: var(--bg-color);
+      position: relative;
     }
 
     .main-header {
-      height: 60px;
-      padding: 0 20px;
+      height: 70px;
+      padding: 0 24px;
       border-bottom: 1px solid var(--border-color);
       display: flex;
       align-items: center;
       justify-content: space-between;
       background-color: var(--header-bg);
+      backdrop-filter: blur(12px);
+      -webkit-backdrop-filter: blur(12px);
+      z-index: 10;
     }
 
     .main-header h2 {
       margin: 0;
-      font-size: 16px;
-      font-weight: 500;
+      font-size: 20px;
+      font-weight: 600;
       color: white;
+      letter-spacing: -0.5px;
+      display: flex;
+      align-items: center;
+      gap: 10px;
     }
 
     .btn {
-      background-color: var(--accent-color);
-      color: white;
-      border: none;
+      background-color: rgba(255, 255, 255, 0.05);
+      border: 1px solid var(--border-color);
+      color: var(--text-main);
       padding: 6px 12px;
       border-radius: 6px;
-      font-size: 12px;
+      font-size: 13px;
       font-weight: 500;
+      font-family: 'Outfit', sans-serif;
       cursor: pointer;
-      transition: background-color 0.2s ease;
+      transition: all 0.2s ease;
       display: flex;
       align-items: center;
-      gap: 6px;
+      gap: 8px;
     }
 
-    .btn:hover {
-      background-color: var(--accent-hover);
+    .btn:hover:not(:disabled) {
+      background-color: rgba(255, 255, 255, 0.1);
+    }
+    
+    .btn:active:not(:disabled) {
+      transform: translateY(1px);
     }
 
     .btn:disabled {
-      opacity: 0.5;
+      opacity: 0.4;
       cursor: not-allowed;
     }
 
     .content-area {
       flex: 1;
       overflow: auto;
-      padding: 20px;
+      padding: 0;
+      position: relative;
+      z-index: 1;
+      text-align: left;
     }
 
     /* Data Table */
     .data-grid-container {
-      background-color: var(--panel-bg);
+      background-color: rgba(24, 24, 27, 0.5);
       border: 1px solid var(--border-color);
-      border-radius: 8px;
-      overflow: hidden;
+      border-radius: 0;
+      overflow: auto;
+      box-shadow: 0 8px 32px rgba(0,0,0,0.2);
+      backdrop-filter: blur(8px);
+      max-height: 100%;
+      width: 100%;
+    }
+    
+    .data-grid-container::-webkit-scrollbar {
+      width: 8px;
+      height: 8px;
+    }
+    .data-grid-container::-webkit-scrollbar-corner {
+      background: transparent;
+    }
+    .data-grid-container::-webkit-scrollbar-thumb {
+      background: #3f3f46;
+      border-radius: 4px;
     }
 
     table {
-      width: 100%;
-      border-collapse: collapse;
+      width: auto;
+      border-collapse: separate;
+      border-spacing: 0;
       text-align: left;
-      font-size: 13px;
+      font-size: 14px;
+      table-layout: auto;
     }
 
     th {
-      background-color: rgba(255,255,255,0.02);
-      color: var(--text-muted);
+      background-color: rgba(24, 24, 27, 0.95);
+      backdrop-filter: blur(4px);
+      color: var(--text-main);
       font-weight: 500;
-      padding: 10px 16px;
+      padding: 12px 20px;
       border-bottom: 1px solid var(--border-color);
+      border-right: 1px solid var(--border-color);
       white-space: nowrap;
       position: sticky;
       top: 0;
       z-index: 10;
     }
+    
+    
+    th::after {
+      content: '';
+      position: absolute;
+      bottom: -1px; left: 0; right: 0;
+      height: 1px;
+      background: var(--border-color);
+    }
+
+    .col-header {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+    
+    .col-name {
+      font-weight: 600;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .pk-badge {
+      font-size: 10px;
+      background: rgba(251, 191, 36, 0.2);
+      color: #fbbf24;
+      padding: 2px 6px;
+      border-radius: 4px;
+      font-weight: 600;
+      letter-spacing: 0.5px;
+    }
+    
+    .col-type {
+      font-size: 12px;
+      color: var(--text-muted);
+      font-family: monospace;
+    }
 
     td {
-      padding: 10px 16px;
+      padding: 12px 20px;
       border-bottom: 1px solid var(--border-color);
+      border-right: 1px solid var(--border-color);
       color: var(--text-main);
       max-width: 300px;
       overflow: hidden;
       text-overflow: ellipsis;
       white-space: nowrap;
+      transition: background-color 0.2s ease;
     }
+    
 
     tr:last-child td {
       border-bottom: none;
@@ -2058,11 +2652,17 @@ var htmlTemplate = `
       background-color: var(--row-hover);
     }
 
-    .type-number { color: #79c0ff; }
-    .type-string { color: #a5d6ff; }
-    .type-boolean { color: #ff7b72; }
-    .type-date { color: #d2a8ff; }
-    .type-null { color: var(--text-muted); font-style: italic; }
+    .type-number { color: var(--type-number); }
+    .type-string { color: var(--type-string); }
+    .type-boolean { color: var(--type-boolean); }
+    .type-date { color: var(--type-date); }
+    .type-json { color: var(--type-json); font-family: monospace; }
+    .type-null { color: var(--type-null); font-style: italic; }
+    
+    .cell-value {
+      font-family: 'JetBrains Mono', 'Fira Code', monospace;
+      font-size: 13px;
+    }
 
     .empty-state {
       display: flex;
@@ -2070,7 +2670,98 @@ var htmlTemplate = `
       align-items: center;
       justify-content: center;
       height: 100%;
+      width: 100%;
+      color: var(--text-muted);
+      animation: fadeIn 0.5s ease-out;
+    }
+    
+    .empty-state svg {
+      margin-bottom: 16px;
+      color: #3f3f46;
+      width: 64px;
+      height: 64px;
+    }
+    
+    .empty-state h3 {
+      color: var(--text-main);
+      margin: 0 0 8px 0;
+      font-size: 18px;
+    }
+    
+    @keyframes fadeIn {
+      from { opacity: 0; transform: translateY(10px); }
+      to { opacity: 1; transform: translateY(0); }
+    }
+    
+    @keyframes spin {
+      from { transform: rotate(0deg); }
+      to { transform: rotate(360deg); }
+    }
+    .spinning {
+      animation: spin 1s linear infinite;
+    }
+
+    /* Pagination */
+    .pagination {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 16px 24px;
+      background-color: rgba(24, 24, 27, 0.95);
+      border-top: 1px solid var(--border-color);
+      font-size: 14px;
       color: var(--text-muted);
+      position: sticky;
+      bottom: 0;
+      z-index: 5;
+    }
+
+    .pagination-info {
+      display: flex;
+      align-items: center;
+      gap: 16px;
+    }
+
+    .pagination-controls {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .pagination-btn {
+      background-color: rgba(255, 255, 255, 0.05);
+      border: 1px solid var(--border-color);
+      color: var(--text-main);
+      padding: 6px 12px;
+      border-radius: 6px;
+      cursor: pointer;
+      font-size: 13px;
+      transition: all 0.2s ease;
+    }
+
+    .pagination-btn:hover:not(:disabled) {
+      background-color: rgba(255, 255, 255, 0.1);
+    }
+
+    .pagination-btn:disabled {
+      opacity: 0.4;
+      cursor: not-allowed;
+    }
+
+    .pagination-btn.active {
+      background-color: var(--accent-color);
+      border-color: var(--accent-color);
+    }
+
+    .page-input {
+      background-color: rgba(255, 255, 255, 0.05);
+      border: 1px solid var(--border-color);
+      color: var(--text-main);
+      padding: 6px 8px;
+      border-radius: 6px;
+      width: 50px;
+      text-align: center;
+      font-size: 13px;
     }
   </style>
 </head>
@@ -2078,7 +2769,7 @@ var htmlTemplate = `
 
   <div class="sidebar">
     <div class="sidebar-header">
-      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+      <svg width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
         <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
         <path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path>
         <path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>
@@ -2092,19 +2783,31 @@ var htmlTemplate = `
 
   <div class="main">
     <div class="main-header">
-      <h2 id="current-table-name">Select a table</h2>
+      <h2 id="current-table-name">
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="color: var(--text-muted);">
+          <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
+          <line x1="3" y1="9" x2="21" y2="9"></line>
+          <line x1="9" y1="21" x2="9" y2="9"></line>
+        </svg>
+        Select a table
+      </h2>
       <button id="refresh-btn" class="btn" disabled>
-        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <svg id="refresh-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
           <polyline points="23 4 23 10 17 10"></polyline>
           <polyline points="1 20 1 14 7 14"></polyline>
           <path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path>
         </svg>
-        Refresh Data
+        Refresh
       </button>
     </div>
     <div class="content-area">
       <div id="data-container" class="empty-state">
-        <p>Select a table from the sidebar to view data</p>
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+          <path d="M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z"></path>
+          <polyline points="14 2 14 8 20 8"></polyline>
+        </svg>
+        <h3>No Table Selected</h3>
+        <p>Choose a table from the sidebar to view its data</p>
       </div>
     </div>
   </div>
@@ -2112,21 +2815,38 @@ var htmlTemplate = `
   <script>
     let currentTable = null;
     let tablesData = [];
+    let tableSchemas = {};
+    let currentPage = 1;
+    let totalPages = 1;
+    let totalRecords = 0;
+    let pageSize = 50;
 
     // Format values for the data grid
     function formatValue(val) {
-      if (val === null || val === undefined) return '<span class="type-null">null</span>';
-      if (typeof val === 'number') return \`<span class="type-number">\${val}</span>\`;
-      if (typeof val === 'boolean') return \`<span class="type-boolean">\${val}</span>\`;
-      if (val instanceof Date || (typeof val === 'string' && val.match(/^\\d{4}-\\d{2}-\\d{2}T/))) {
-        return \`<span class="type-date">\${new Date(val).toLocaleString()}</span>\`;
+      if (val === null || val === undefined) return 'null';
+      
+      if (typeof val === 'object') {
+        if (val instanceof Date) {
+          return val.toISOString();
+        }
+        // Handle JSON objects
+        const safeJson = JSON.stringify(val)
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;");
+        return safeJson;
       }
-      // Escape HTML to prevent XSS
-      const safeStr = String(val)
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-      return \`<span class="type-string">\${safeStr}</span>\`;
+      
+      if (typeof val === 'string') {
+        // Escape HTML to prevent XSS
+        const safeStr = String(val)
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;");
+        return safeStr;
+      }
+      
+      return String(val);
     }
 
     async function loadTables() {
@@ -2136,12 +2856,14 @@ var htmlTemplate = `
         
         const list = document.getElementById('table-list');
         list.innerHTML = '';
+        tableSchemas = {};
         
         tablesData.forEach(t => {
+          tableSchemas[t.name] = t;
           const li = document.createElement('li');
           li.className = 'table-item';
           li.innerHTML = \`
-            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
               <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
               <line x1="3" y1="9" x2="21" y2="9"></line>
               <line x1="9" y1="21" x2="9" y2="9"></line>
@@ -2156,8 +2878,9 @@ var htmlTemplate = `
       }
     }
 
-    async function selectTable(name) {
+    async function selectTable(name, page = 1) {
       currentTable = name;
+      currentPage = page;
       
       // Update UI active state
       document.querySelectorAll('.table-item').forEach(el => {
@@ -2165,60 +2888,169 @@ var htmlTemplate = `
         else el.classList.remove('active');
       });
       
-      document.getElementById('current-table-name').textContent = name;
+      document.getElementById('current-table-name').innerHTML = \`
+        <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="color: var(--accent-color);">
+          <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
+          <line x1="3" y1="9" x2="21" y2="9"></line>
+          <line x1="9" y1="21" x2="9" y2="9"></line>
+        </svg>
+        \${name}
+      \`;
       document.getElementById('refresh-btn').disabled = false;
       
       const container = document.getElementById('data-container');
-      container.innerHTML = '<div class="empty-state">Loading data...</div>';
-      container.className = '';
+      container.innerHTML = \`
+        <div class="empty-state">
+          <svg class="spinning" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <line x1="12" y1="2" x2="12" y2="6"></line>
+            <line x1="12" y1="18" x2="12" y2="22"></line>
+            <line x1="4.93" y1="4.93" x2="7.76" y2="7.76"></line>
+            <line x1="16.24" y1="16.24" x2="19.07" y2="19.07"></line>
+            <line x1="2" y1="12" x2="6" y2="12"></line>
+            <line x1="18" y1="12" x2="22" y2="12"></line>
+            <line x1="4.93" y1="19.07" x2="7.76" y2="16.24"></line>
+            <line x1="16.24" y1="7.76" x2="19.07" y2="4.93"></line>
+          </svg>
+          <p>Loading data...</p>
+        </div>
+      \`;
       
       try {
-        const res = await fetch(\`/api/tables/\${name}/data\`);
+        const res = await fetch(\`/api/tables/\${name}/data?page=\${page}&limit=\${pageSize}\`);
         if (!res.ok) throw new Error(await res.text());
-        const rows = await res.json();
+        const response = await res.json();
+        
+        const rows = response.data || response;
+        totalRecords = response.total || 0;
+        totalPages = response.totalPages || 1;
+        
+        const tableSchema = tableSchemas[name];
         
         if (rows.length === 0) {
-          container.innerHTML = '<div class="empty-state">No data in this table</div>';
+          container.innerHTML = \`
+            <div class="empty-state">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+                <circle cx="12" cy="12" r="10"></circle>
+                <line x1="12" y1="8" x2="12" y2="12"></line>
+                <line x1="12" y1="16" x2="12.01" y2="16"></line>
+              </svg>
+              <h3>Table is Empty</h3>
+              <p>No records found in "\${name}"</p>
+            </div>
+          \`;
           return;
         }
 
-        const columns = Object.keys(rows[0]);
+        // Use all columns from the actual data to ensure foreign keys and all data are shown
+        let columns = [];
+        const allKeys = new Set();
+        rows.forEach(row => {
+          Object.keys(row).forEach(key => allKeys.add(key));
+        });
+        
+        // Try to get type info from schema if available
+        const schemaColMap = {};
+        if (tableSchema && tableSchema.columns && tableSchema.columns.length > 0) {
+          tableSchema.columns.forEach(col => {
+            schemaColMap[col.name] = col;
+          });
+        }
+        
+        columns = Array.from(allKeys).map(key => ({
+          name: key,
+          type: schemaColMap[key] ? schemaColMap[key].type : typeof rows[0][key],
+          primaryKey: schemaColMap[key] ? schemaColMap[key].primaryKey : false
+        }));
         
         let html = '<div class="data-grid-container"><table><thead><tr>';
         columns.forEach(col => {
-          html += \`<th>\${col}</th>\`;
+          html += \`
+            <th>
+              <div class="col-header">
+                <div class="col-name">
+                  \${col.name}
+                  \${col.primaryKey ? '<span class="pk-badge">PK</span>' : ''}
+                </div>
+                <div class="col-type">\${col.type}</div>
+              </div>
+            </th>
+          \`;
         });
         html += '</tr></thead><tbody>';
         
         rows.forEach(row => {
           html += '<tr>';
           columns.forEach(col => {
-            html += \`<td>\${formatValue(row[col])}</td>\`;
+            html += \`<td>\${formatValue(row[col.name])}</td>\`;
           });
           html += '</tr>';
         });
         
-        html += '</tbody></table></div>';
+        html += '</tbody></table>';
+        
+        // Add pagination
+        html += renderPagination();
+        
+        html += '</div>';
         container.innerHTML = html;
         
       } catch (e) {
-        container.innerHTML = \`<div class="empty-state" style="color: #ff7b72;">Error: \${e.message}</div>\`;
+        container.innerHTML = \`
+          <div class="empty-state">
+            <svg viewBox="0 0 24 24" fill="none" stroke="#ef4444" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+              <circle cx="12" cy="12" r="10"></circle>
+              <line x1="12" y1="8" x2="12" y2="12"></line>
+              <line x1="12" y1="16" x2="12.01" y2="16"></line>
+            </svg>
+            <h3 style="color: #ef4444;">Error Loading Data</h3>
+            <p>\${e.message}</p>
+          </div>
+        \`;
       }
     }
 
+    function renderPagination() {
+      const startRecord = (currentPage - 1) * pageSize + 1;
+      const endRecord = Math.min(currentPage * pageSize, totalRecords);
+      
+      let html = '<div class="pagination">';
+      html += '<div class="pagination-info">';
+      html += \`<span>Total: \${totalRecords} records</span>\`;
+      html += \`<span>Page \${currentPage} of \${totalPages}</span>\`;
+      html += \`<span>Showing \${startRecord}-\${endRecord}</span>\`;
+      html += '</div>';
+      
+      html += '<div class="pagination-controls">';
+      
+      // Previous button
+      html += \`<button class="pagination-btn" onclick="changePage(\${currentPage - 1})" \${currentPage === 1 ? 'disabled' : ''}>Previous</button>\`;
+      
+      // Next button
+      html += \`<button class="pagination-btn" onclick="changePage(\${currentPage + 1})" \${currentPage === totalPages ? 'disabled' : ''}>Next</button>\`;
+      
+      html += '</div>';
+      html += '</div>';
+      
+      return html;
+    }
+
+    function changePage(page) {
+      if (page < 1 || page > totalPages) return;
+      selectTable(currentTable, page);
+    }
+
     document.getElementById('refresh-btn').addEventListener('click', async () => {
       if (!currentTable) return;
       
-      const btn = document.getElementById('refresh-btn');
-      const originalText = btn.innerHTML;
-      btn.innerHTML = 'Refreshing...';
+      const icon = document.getElementById('refresh-icon');
+      icon.classList.add('spinning');
       
       try {
         await selectTable(currentTable);
       } catch (e) {
         console.error("Failed to refresh data", e);
       } finally {
-        setTimeout(() => { btn.innerHTML = originalText; }, 300);
+        setTimeout(() => { icon.classList.remove('spinning'); }, 500);
       }
     });
 
@@ -2294,6 +3126,43 @@ Example query: await db.select().from(users)`);
   });
 }
 
+// src/config.ts
+import { resolve as resolve7, join as join6 } from "path";
+var CONFIG_FILES = [
+  "bungres.config.ts",
+  "bungres.config.js",
+  "bungres.config.mts",
+  "bungres.config.mjs"
+];
+async function loadConfig(cwd = process.cwd()) {
+  let userConfig = {};
+  for (const file of CONFIG_FILES) {
+    const configPath = join6(cwd, file);
+    if (await Bun.file(configPath).exists()) {
+      const mod = await import(resolve7(configPath));
+      userConfig = mod.default ?? mod;
+      break;
+    }
+  }
+  const dbUrl = userConfig.dbCredentials?.url ?? process.env["DATABASE_URL"] ?? process.env["POSTGRES_URL"] ?? "";
+  if (!dbUrl) {
+    console.error(`bungres: No database URL found.
+  Add dbCredentials.url to bungres.config.ts  or set DATABASE_URL.`);
+    process.exit(1);
+  }
+  const out = userConfig.out ?? "./migrations";
+  return {
+    schema: userConfig.schema ?? "src/db/schema/**/*.ts",
+    seed: userConfig.seed ?? "src/db/seed.ts",
+    out,
+    dbUrl,
+    dbSchema: userConfig.dbSchema ?? "public",
+    migrationsDir: out,
+    outDir: "./src/db/generated",
+    verbose: userConfig.verbose ?? false
+  };
+}
+
 // src/ensure-db.ts
 async function ensureDatabase2(dbUrl) {
   let sql2;
@@ -2333,6 +3202,7 @@ ${colorize("Usage:", "yellow")}
   bungres <command> [options]
 
 ${colorize("Commands:", "yellow")}
+  init          Initialize bungres project with config file and db folder structure
   generate      Generate SQL migration files from your schema definitions
   migrate       Run pending migration files against the database
   push          Apply schema directly to the DB (no migration files, dev mode)
@@ -2353,6 +3223,7 @@ ${colorize("Options:", "yellow")}
   --help        Show this help
 
 ${colorize("Examples:", "yellow")}
+  bungres init
   bungres generate
   bungres migrate
   bungres push
@@ -2377,6 +3248,10 @@ async function main() {
   }
   const command = args[0];
   const flags = parseFlags(args.slice(1));
+  if (command === "init") {
+    await runInit();
+    process.exit(0);
+  }
   const config2 = await loadConfig(process.cwd());
   if (flags.verbose)
     config2.verbose = true;