@bungres/kit 0.1.1 → 0.4.0

package/dist/index.js

@@ -38,7 +38,7 @@ async function loadConfig(cwd = process.cwd()) {
 // src/schema-loader.ts
 import { resolve as resolve2, join as join2 } from "path";
 
-// ../bungres-orm/src/table.ts
+// ../bungres-orm/src/schema/table.ts
 var TableConfigSymbol = Symbol.for("BungresTableConfig");
 function getTableConfig(table) {
   return table[TableConfigSymbol];
@@ -48,8 +48,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,16 +64,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 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
       }
     };
@@ -78,7 +107,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;
@@ -132,7 +161,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 = [];
@@ -143,12 +198,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;
@@ -175,11 +544,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 +579,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 +719,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 +742,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 +764,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 +805,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 };
-  }
-}
-// ../bungres-orm/src/relational.ts
+// ../bungres-orm/src/builders/relational.ts
 var _relationsCache = new WeakMap;
 
 class RelationalQueryBuilder {
@@ -505,7 +889,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 +898,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 +937,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 +1004,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 +1022,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 +1052,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);
@@ -1047,11 +1451,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}`);
       }
     }
@@ -1367,7 +1771,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 +1805,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 +1828,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,21 +1866,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") {
@@ -1523,84 +1928,97 @@ 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());