@bungres/kit 0.3.0 → 0.5.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // @bun
 // src/config.ts
-import { resolve, join } from "path";
+import { join, resolve } from "path";
 var CONFIG_FILES = [
   "bungres.config.ts",
   "bungres.config.js",
@@ -17,7 +17,7 @@ async function loadConfig(cwd = process.cwd()) {
       break;
     }
   }
-  const dbUrl = userConfig.dbCredentials?.url ?? process.env["DATABASE_URL"] ?? process.env["POSTGRES_URL"] ?? "";
+  const dbUrl = userConfig.dbCredentials?.url ?? Bun.env.DATABASE_URL ?? Bun.env.POSTGRES_URL ?? "";
   if (!dbUrl) {
     console.error(`bungres: No database URL found.
   Add dbCredentials.url to bungres.config.ts  or set DATABASE_URL.`);
@@ -30,7 +30,10 @@ async function loadConfig(cwd = process.cwd()) {
     out,
     dbUrl,
     dbSchema: userConfig.dbSchema ?? "public",
-    migrationsDir: out,
+    migrationsTable: userConfig.migrations?.table ?? "__bungres_migrations",
+    migrationsSchema: userConfig.migrations?.schema ?? "bungres",
+    breakpoints: userConfig.breakpoints ?? true,
+    strict: userConfig.strict ?? false,
     outDir: "./src/db/generated",
     verbose: userConfig.verbose ?? false
   };
@@ -38,7 +41,7 @@ async function loadConfig(cwd = process.cwd()) {
 // src/schema-loader.ts
 import { resolve as resolve2, join as join2 } from "path";
 
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@bungres/orm/src/table.ts
+// ../bungres-orm/src/schema/table.ts
 var TableConfigSymbol = Symbol.for("BungresTableConfig");
 function getTableConfig(table) {
   return table[TableConfigSymbol];
@@ -48,8 +51,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, config]) => {
-      const c = { ...config };
+      const c = { ...config, tableName: qualifiedName };
       if (!c.name) {
         if (casing === "snake") {
           c.name = camelToSnakeCase(key);
@@ -59,26 +67,50 @@ 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 config = builder.build();
+          if (config.type === "index")
+            indexes.push(config);
+          else if (config.type === "check")
+            checks.push(config.condition);
+          else if (config.type === "primaryKey")
+            primaryKeys.push(...config.columns);
+          else if (config.type === "foreignKey")
+            foreignKeys.push(config);
+        }
+      } 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
       }
     };
     return Object.assign(tableObj, columnConfigs);
   };
 }
-var table = createTableFactory("none");
+var table = createTableFactory("snake");
 var snakeCase = { table: createTableFactory("snake") };
 var camelCase = { table: createTableFactory("camel") };
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@bungres/orm/src/column.ts
+// ../bungres-orm/src/schema/columns.ts
 function buildColumn(dataType, nameOrOpts, opts) {
   let name = "";
   let options = opts;
@@ -132,7 +164,33 @@ var interval = col("interval");
 var inet = col("inet");
 var cidr = col("cidr");
 var macaddr = col("macaddr");
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@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 = [];
@@ -143,12 +201,326 @@ function sqlJoin(chunks, separator = ", ") {
   }
   return { sql: parts.join(separator), params };
 }
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@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;
@@ -175,11 +547,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) {
@@ -194,35 +582,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) {
@@ -251,76 +722,7 @@ class SelectBuilderIntermediate {
     return new SelectBuilder(table2, this._executor, this._selection);
   }
 }
-
-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) {
-    const rows = Array.isArray(data) ? data : [data];
-    this._values.push(...rows);
-    return this;
-  }
-  onConflictDoNothing() {
-    this._onConflict = "do nothing";
-    return this;
-  }
-  onConflictDoUpdate(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 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}`);
-      }
-      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") {
-      const offset = params.length;
-      query += " ON CONFLICT " + 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(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/update.ts
 class UpdateBuilder {
   _table;
   _executor;
@@ -343,7 +745,11 @@ class UpdateBuilder {
     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;
   }
   returning(...columns) {
@@ -361,8 +767,32 @@ class UpdateBuilder {
     }
     const params = [];
     const setClauses = entries.map(([key, value]) => {
-      params.push(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}`)}`;
+      }
+      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(", ")}`;
@@ -378,50 +808,7 @@ class UpdateBuilder {
     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 };
-  }
-}
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@bungres/orm/src/relational.ts
+// ../bungres-orm/src/builders/relational.ts
 var _relationsCache = new WeakMap;
 
 class RelationalQueryBuilder {
@@ -505,7 +892,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;
@@ -514,7 +901,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;
@@ -553,10 +940,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}"`);
@@ -615,10 +1007,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") {
@@ -627,6 +1025,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) {
@@ -648,7 +1055,7 @@ class RelationalQueryBuilder {
   }
 }
 
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@bungres/orm/src/db.ts
+// ../bungres-orm/src/core/db.ts
 function parseDBName(url) {
   try {
     return new URL(url).pathname.slice(1);
@@ -792,7 +1199,7 @@ class BungresTransaction {
     return Array.from(result);
   }
 }
-function createDB(config) {
+function bungres(config) {
   const db = new BungresDB(config);
   if (typeof config === "object" && config.schema) {
     const schema = config.schema;
@@ -814,7 +1221,7 @@ function createDB(config) {
   }
   return db;
 }
-// ../../node_modules/.bun/@bungres+orm@0.2.0/node_modules/@bungres/orm/src/ddl.ts
+// ../bungres-orm/src/ddl.ts
 function generateCreateTable(config, ifNotExists = true) {
   const tableName = config.schema ? `"${config.schema}"."${config.name}"` : `"${config.name}"`;
   const exists = ifNotExists ? " IF NOT EXISTS" : "";
@@ -1047,11 +1454,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}`);
       }
     }
@@ -1215,7 +1622,7 @@ async function runGenerate(config, name) {
     console.warn(colorize("No table definitions found. Check your schema glob pattern.", "yellow"));
     return;
   }
-  const migrationsDir = resolve3(config.migrationsDir);
+  const migrationsDir = resolve3(config.out);
   await Bun.$`mkdir -p ${migrationsDir}`.quiet();
   const currentSnapshot = Object.fromEntries(schemas.map((s) => [s.config.name, s.config]));
   const snapshotPath = join3(migrationsDir, SNAPSHOT_FILE);
@@ -1308,19 +1715,22 @@ function topoSort(schemas) {
 }
 // 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}" (
+async function runMigrate(config) {
+  const migrationsDir = resolve4(config.out);
+  const sql2 = new Bun.SQL(config.dbUrl);
+  const table2 = config.migrationsTable;
+  const schema = config.migrationsSchema;
+  const qualifiedTable = `"${schema}"."${table2}"`;
+  const createSchema = `CREATE SCHEMA IF NOT EXISTS "${schema}";`;
+  const createMigrationsTable = `
+CREATE TABLE IF NOT EXISTS ${qualifiedTable} (
   id          SERIAL PRIMARY KEY,
   name        TEXT NOT NULL UNIQUE,
   applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-`.trim();
-async function runMigrate(config) {
-  const migrationsDir = resolve4(config.migrationsDir);
-  const sql2 = new Bun.SQL(config.dbUrl);
+);`.trim();
   try {
-    await sql2.unsafe(CREATE_MIGRATIONS_TABLE);
+    await sql2.unsafe(createSchema);
+    await sql2.unsafe(createMigrationsTable);
     const glob = new Bun.Glob("*.sql");
     const files = [];
     for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
@@ -1332,7 +1742,7 @@ async function runMigrate(config) {
       console.log(colorize("Run `bungres generate` first.", "yellow"));
       return;
     }
-    const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE}"`);
+    const applied = await sql2.unsafe(`SELECT name FROM ${qualifiedTable}`);
     const appliedSet = new Set(applied.map((r) => r.name));
     const pending = files.filter((f) => !appliedSet.has(f));
     if (pending.length === 0) {
@@ -1350,11 +1760,11 @@ ${content}
 `);
       }
       await sql2.transaction(async (txSql) => {
-        const statements = content.split(";").map((s) => s.trim()).filter(Boolean);
+        const statements = config.breakpoints ? content.split(/-->statement-breakpoint/g).flatMap((chunk) => chunk.split(";").map((s) => s.trim()).filter(Boolean)) : 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]);
+        await txSql.unsafe(`INSERT INTO ${qualifiedTable} (name) VALUES ($1)`, [file]);
       });
       console.log(colorize(`  \u2713  ${file}`, "green"));
     }
@@ -1367,7 +1777,7 @@ Done.`, "green"));
 // src/commands/pull.ts
 import { resolve as resolve5, 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,
@@ -1401,7 +1811,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(config) {
   console.log("@bungres/kit pull: introspecting database...");
@@ -1424,9 +1834,9 @@ async function runPull(config) {
     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,
@@ -1462,7 +1872,7 @@ function generateSchemaTS(tableMap, dbSchema) {
     `// Generated at: ${new Date().toISOString()}`,
     ``,
     `import {`,
-    `  snakeCase,`,
+    `  table,`,
     `  text, varchar, char, integer, bigint, smallint,`,
     `  serial, bigserial, boolean, real, doublePrecision,`,
     `  numeric, decimal, json, jsonb,`,
@@ -1474,7 +1884,7 @@ function generateSchemaTS(tableMap, dbSchema) {
   ];
   for (const [, table2] of tableMap) {
     const varName = toCamelCase(table2.tableName);
-    lines.push(`export const ${varName} = snakeCase.table("${table2.tableName}", {`);
+    lines.push(`export const ${varName} = table("${table2.tableName}", {`);
     for (const col2 of table2.columns) {
       const colExpr = buildColumnExpression(col2);
       lines.push(`  ${toCamelCase(col2.name)}: ${colExpr},`);
@@ -1621,15 +2031,17 @@ function toCamelCase(str) {
 }
 // src/commands/status.ts
 import { resolve as resolve6 } from "path";
-var MIGRATIONS_TABLE2 = "__bungres_migrations";
 async function runStatus(config) {
-  const migrationsDir = resolve6(config.migrationsDir);
+  const migrationsDir = resolve6(config.out);
   const sql2 = new Bun.SQL(config.dbUrl);
+  const table2 = config.migrationsTable;
+  const schema = config.migrationsSchema;
+  const qualifiedTable = `"${schema}"."${table2}"`;
   try {
     const tableCheck = await sql2.unsafe(`SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
-        WHERE table_name = $1
-      ) AS exists`, [MIGRATIONS_TABLE2]);
+        WHERE table_schema = $1 AND table_name = $2
+      ) AS exists`, [schema, table2]);
     const trackingExists = tableCheck[0]?.exists ?? false;
     const glob = new Bun.Glob("*.sql");
     const files = [];
@@ -1643,7 +2055,7 @@ async function runStatus(config) {
     }
     let appliedSet = new Set;
     if (trackingExists) {
-      const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE2}" ORDER BY applied_at`);
+      const applied = await sql2.unsafe(`SELECT name FROM ${qualifiedTable} ORDER BY applied_at`);
       appliedSet = new Set(applied.map((r) => r.name));
     }
     console.log(colorize(`
@@ -1673,14 +2085,19 @@ async function runDrop(config, opts = {}) {
   }
   const sql2 = new Bun.SQL(config.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 userSchema = config.dbSchema;
+    const existingUserTablesResult = await sql2.unsafe(`SELECT table_name FROM information_schema.tables WHERE table_schema = $1`, [userSchema]);
+    const existingTableNames = new Set(existingUserTablesResult.map((r) => r.table_name));
+    const migTableCheck = await sql2.unsafe(`SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_schema = $1 AND table_name = $2
+      ) AS exists`, [config.migrationsSchema, config.migrationsTable]);
+    const migrationTableExists = migTableCheck[0]?.exists ?? false;
+    const pushTableCheck = await sql2.unsafe(`SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_schema = $1 AND table_name = $2
+      ) AS exists`, [config.migrationsSchema, "__bungres_push"]);
+    const pushTableExists = pushTableCheck[0]?.exists ?? false;
     const tablesToDrop = schemas.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).");
@@ -1688,10 +2105,10 @@ async function runDrop(config, opts = {}) {
     }
     const tableNamesToPrint = tablesToDrop.map((s) => (s.config.schema ? s.config.schema + "." : "") + s.config.name);
     if (migrationTableExists) {
-      tableNamesToPrint.push("__bungres_migrations");
+      tableNamesToPrint.push(`${config.migrationsSchema}.${config.migrationsTable}`);
     }
     if (pushTableExists) {
-      tableNamesToPrint.push("__bungres_push");
+      tableNamesToPrint.push(`${config.migrationsSchema}.__bungres_push`);
     }
     if (!opts.force) {
       console.warn(colorize(`
@@ -1715,12 +2132,13 @@ Are you sure? Type YES to continue: `, "cyan"));
       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"));
+      const qualifiedMigTable = `"${config.migrationsSchema}"."${config.migrationsTable}"`;
+      await sql2.unsafe(`DROP TABLE IF EXISTS ${qualifiedMigTable} CASCADE`);
+      console.log(colorize(`  \u2713 dropped ${config.migrationsSchema}.${config.migrationsTable}`, "green"));
     }
     if (pushTableExists) {
-      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_push CASCADE");
-      console.log(colorize(`  \u2713 dropped __bungres_push`, "green"));
+      await sql2.unsafe(`DROP TABLE IF EXISTS "${config.migrationsSchema}"."__bungres_push" CASCADE`);
+      console.log(colorize(`  \u2713 dropped ${config.migrationsSchema}.__bungres_push`, "green"));
     }
     console.log(colorize(`
 Drop complete.`, "green"));