@bungres/kit 1.0.0 → 1.1.1

package/dist/index.js

@@ -168,14 +168,25 @@ var CONFIG_FILES = [
   "bungres.config.mts",
   "bungres.config.mjs"
 ];
-async function loadConfig(cwd = process.cwd()) {
+async function loadConfig(cwd = process.cwd(), explicitConfigPath) {
   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));
+  if (explicitConfigPath) {
+    const fullPath = resolve(cwd, explicitConfigPath);
+    if (await Bun.file(fullPath).exists()) {
+      const mod = await import(fullPath);
       userConfig = mod.default ?? mod;
-      break;
+    } else {
+      console.error(`bungres: Config file not found at ${fullPath}`);
+      process.exit(1);
+    }
+  } else {
+    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 ?? Bun.env.DATABASE_URL ?? Bun.env.POSTGRES_URL ?? "";
@@ -268,10 +279,10 @@ function createTableFactory(casing) {
     return Object.assign(tableObj, columnConfigs);
   };
 }
-var table = createTableFactory("snake");
-var snakeCase = { table: createTableFactory("snake") };
-var camelCase = { table: createTableFactory("camel") };
-var noCasing = { table: createTableFactory("none") };
+var pgTable = createTableFactory("snake");
+var snakeCase = { pgTable: createTableFactory("snake") };
+var camelCase = { pgTable: createTableFactory("camel") };
+var noCasing = { pgTable: createTableFactory("none") };
 function buildColumn(dataType, nameOrOpts, opts) {
   let name = "";
   let options = opts;
@@ -298,8 +309,8 @@ function buildColumn(dataType, nameOrOpts, opts) {
     ...options?.check !== undefined ? { check: options.check } : {}
   };
   return Object.assign(config, {
-    as(alias) {
-      return Object.assign({}, this, { alias });
+    as(alias2) {
+      return Object.assign({}, this, { alias: alias2 });
     },
     array() {
       return Object.assign({}, this, { dataType: `${this.dataType}[]` });
@@ -428,18 +439,26 @@ 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)
+  if (typeof values === "object" && values !== null && "toSQL" in values) {
+    return sql`${rawSql(colName(column))} IN (${values.toSQL()})`;
+  }
+  const arr = values;
+  if (arr.length === 0)
     return rawSql("FALSE");
-  const params = values;
-  const placeholders = params.map((_, i) => `$${i + 1}`).join(", ");
-  return { sql: `${colName(column)} = ANY(ARRAY[${placeholders}])`, params };
+  const params = arr;
+  const placeholders = arr.map((_, i) => `$${i + 1}`).join(", ");
+  return { sql: `${colName(column)} IN (${placeholders})`, params };
 };
 var notInArray = (column, values) => {
-  if (values.length === 0)
+  if (typeof values === "object" && values !== null && "toSQL" in values) {
+    return sql`${rawSql(colName(column))} NOT IN (${values.toSQL()})`;
+  }
+  const arr = values;
+  if (arr.length === 0)
     return rawSql("TRUE");
-  const params = values;
-  const placeholders = params.map((_, i) => `$${i + 1}`).join(", ");
-  return { sql: `${colName(column)} != ALL(ARRAY[${placeholders}])`, params };
+  const params = arr;
+  const placeholders = arr.map((_, i) => `$${i + 1}`).join(", ");
+  return { sql: `${colName(column)} NOT IN (${placeholders})`, params };
 };
 var between = (column, min, max) => sql`${rawSql(colName(column))} BETWEEN ${min} AND ${max}`;
 var and = (...conditions) => sqlJoin(conditions, " AND ");
@@ -538,8 +557,8 @@ class DeleteBuilder {
   _returning;
   _comment;
   _with = [];
-  constructor(table2, executor) {
-    this._table = table2;
+  constructor(table, executor) {
+    this._table = table;
     this._executor = executor;
   }
   then(onfulfilled, onrejected) {
@@ -607,8 +626,8 @@ class InsertBuilder {
   _returning;
   _comment;
   _with = [];
-  constructor(table2, executor) {
-    this._table = table2;
+  constructor(table, executor) {
+    this._table = table;
     this._executor = executor;
   }
   then(onfulfilled, onrejected) {
@@ -789,22 +808,29 @@ class SelectBuilder {
   _select;
   _selection;
   _joins = [];
+  _isNestedOutput = false;
   _with = [];
   _setOperations = [];
   _comment;
-  constructor(table2, executor, selection) {
-    this._table = table2;
+  constructor(table, executor, selection) {
+    this._table = table;
     this._executor = executor;
     this._selection = selection;
   }
   then(onfulfilled, onrejected) {
-    return this._executor.execute(this).then(onfulfilled, onrejected);
+    return this._executor.execute(this).then((rows) => {
+      if (this._isNestedOutput) {
+        rows = rows.map((r) => typeof r._nested_data === "string" ? JSON.parse(r._nested_data) : r._nested_data);
+      }
+      return onfulfilled ? onfulfilled(rows) : rows;
+    }, onrejected);
   }
   async single() {
     if (this._limit === undefined) {
       this.limit(1);
     }
-    return this._executor.executeSingle(this);
+    const rows = await this.then();
+    return rows[0] ?? null;
   }
   select(...columns) {
     this._select = columns;
@@ -866,40 +892,82 @@ class SelectBuilder {
     this._offset = n;
     return this;
   }
+  as(aliasName) {
+    const columns = {};
+    let fields = [];
+    if (this._selection) {
+      fields = Object.keys(this._selection);
+    } else if (this._select && this._select.length > 0) {
+      fields = this._select;
+    } else if (!(("alias" in this._table) && ("query" in this._table))) {
+      fields = Object.keys(getTableConfig(this._table).columns);
+    }
+    for (const f of fields) {
+      const key = typeof f === "string" ? f : f.name || f.alias;
+      const dataType = typeof f !== "string" && f.dataType ? f.dataType : "any";
+      if (key)
+        columns[key] = { name: key, tableName: aliasName, dataType };
+    }
+    const sqObj = { ...columns };
+    const TableConfigSymbol2 = Symbol.for("BungresTableConfig");
+    sqObj[TableConfigSymbol2] = {
+      name: aliasName,
+      qualifiedName: `"${aliasName}"`,
+      columns,
+      isSubquery: true,
+      builder: this
+    };
+    return sqObj;
+  }
   join(rawClause) {
-    this._joins.push(rawClause);
+    this._joins.push({ chunk: rawSql(rawClause) });
     return this;
   }
-  innerJoin(table2, condition) {
-    this._joins.push(sql`INNER JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+  _buildJoin(type, table, condition) {
+    const TableConfigSymbol2 = Symbol.for("BungresTableConfig");
+    const cfg = table[TableConfigSymbol2];
+    if (cfg && cfg.isSubquery) {
+      const sqChunk = cfg.builder.toSQL();
+      return {
+        table,
+        chunk: sql`${rawSql(type)} JOIN (${sqChunk}) AS "${rawSql(cfg.name)}" ON ${condition}`
+      };
+    }
+    return {
+      table,
+      chunk: sql`${rawSql(type)} JOIN ${rawSql(cfg.qualifiedName)} ON ${condition}`
+    };
+  }
+  innerJoin(table, condition) {
+    this._joins.push(this._buildJoin("INNER", table, condition));
     return this;
   }
-  leftJoin(table2, condition) {
-    this._joins.push(sql`LEFT JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+  leftJoin(table, condition) {
+    this._joins.push(this._buildJoin("LEFT", table, condition));
     return this;
   }
-  rightJoin(table2, condition) {
-    this._joins.push(sql`RIGHT JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+  rightJoin(table, condition) {
+    this._joins.push(this._buildJoin("RIGHT", table, condition));
     return this;
   }
-  fullJoin(table2, condition) {
-    this._joins.push(sql`FULL JOIN ${rawSql(getTableConfig(table2).qualifiedName)} ON ${condition}`);
+  fullJoin(table, condition) {
+    this._joins.push(this._buildJoin("FULL", table, condition));
     return this;
   }
   _buildSelection(selection, params) {
     const parts = [];
-    for (const [alias, col2] of Object.entries(selection)) {
+    for (const [alias2, 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}`)}`);
+          parts.push(`'${alias2}', ${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}"`);
+          parts.push(`'${alias2}', ${c.tableName ? c.tableName + "." : ""}"${c.name}"`);
         } else {
-          parts.push(`'${alias}', json_build_object(${this._buildSelection(col2, params)})`);
+          parts.push(`'${alias2}', json_build_object(${this._buildSelection(col2, params)})`);
         }
       }
     }
@@ -908,35 +976,59 @@ class SelectBuilder {
   toSQL() {
     let cols = "";
     const params = [];
+    const isCte = "alias" in this._table && "query" in this._table;
+    const qName = isCte ? `"${this._table.alias}"` : getTableConfig(this._table).qualifiedName;
     if (this._selection) {
-      cols = Object.entries(this._selection).map(([alias, col2]) => {
+      cols = Object.entries(this._selection).map(([alias2, 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}"`;
+          return `${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)} AS "${alias2}"`;
         } 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}"`;
+          return `${c.tableName ? c.tableName + "." : ""}"${c.name}" AS "${alias2}"`;
         } else {
-          return `json_build_object(${this._buildSelection(col2, params)}) AS "${alias}"`;
+          return `json_build_object(${this._buildSelection(col2, params)}) AS "${alias2}"`;
         }
       }).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 `${qName}."${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`;
+          const colName2 = isCte ? c : getTableConfig(this._table).columns[c]?.name ?? c;
+          return `${qName}."${colName2}" AS "${c}"`;
         }
         return `${c.tableName ? c.tableName + "." : ""}"${c.name}" AS "${c.alias || c.name}"`;
       }).join(", ");
     } else {
-      const qName = getTableConfig(this._table).qualifiedName;
-      const colsKeys = Object.keys(getTableConfig(this._table).columns);
-      if (colsKeys.length === 0) {
+      if (isCte) {
         cols = "*";
       } else {
-        cols = colsKeys.map((c) => `${qName}."${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ");
+        const hasJoinedTables = this._joins.some((j) => j.table);
+        if (hasJoinedTables) {
+          this._isNestedOutput = true;
+          const rootCfg = getTableConfig(this._table);
+          const tablesToSelect = [{ alias: rootCfg.name, config: rootCfg }];
+          for (const join2 of this._joins) {
+            if (join2.table) {
+              const cfg = getTableConfig(join2.table);
+              tablesToSelect.push({ alias: cfg.name, config: cfg });
+            }
+          }
+          cols = `json_build_object(${tablesToSelect.map((t) => {
+            const innerFields = Object.keys(t.config.columns).map((c) => {
+              return `'${c}', "${t.config.name}"."${t.config.columns[c].name}"`;
+            }).join(", ");
+            return `'${t.alias}', json_build_object(${innerFields})`;
+          }).join(", ")}) AS _nested_data`;
+        } else {
+          const colsKeys = Object.keys(getTableConfig(this._table).columns);
+          if (colsKeys.length === 0) {
+            cols = "*";
+          } else {
+            cols = colsKeys.map((c) => `${qName}."${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ");
+          }
+        }
       }
     }
     let prefix = "";
@@ -950,9 +1042,9 @@ class SelectBuilder {
       }
       prefix = `WITH ${cteStrs.join(", ")} `;
     }
-    let query = `SELECT ${cols} FROM ${getTableConfig(this._table).qualifiedName}`;
+    let query = `SELECT ${cols} FROM ${qName}`;
     if (this._joins.length > 0) {
-      const joinChunks = this._joins.map((j) => typeof j === "string" ? rawSql(j) : j);
+      const joinChunks = this._joins.map((j) => j.chunk);
       const combinedJoins = sqlJoin(joinChunks, " ");
       const offset = params.length;
       query += " " + combinedJoins.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
@@ -965,11 +1057,11 @@ class SelectBuilder {
       params.push(...combined.params);
     }
     if (this._groupBy.length > 0) {
-      const qName = getTableConfig(this._table).qualifiedName;
+      const qName2 = 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}"`;
+          const dbCol = isCte ? c : getTableConfig(this._table).columns[c]?.name ?? c;
+          return `${qName2}."${dbCol}"`;
         } else if ("sql" in c && "params" in c) {
           const offset = params.length;
           params.push(...c.params);
@@ -986,11 +1078,11 @@ class SelectBuilder {
       params.push(...combined.params);
     }
     if (this._orderBy.length > 0) {
-      const qName = getTableConfig(this._table).qualifiedName;
+      const qName2 = getTableConfig(this._table).qualifiedName;
       query += " ORDER BY " + this._orderBy.map((o) => {
         if (typeof o.column === "string") {
-          const dbCol = getTableConfig(this._table).columns[o.column]?.name ?? o.column;
-          return `${qName}."${dbCol}" ${o.dir.toUpperCase()}`;
+          const dbCol = isCte ? o.column : getTableConfig(this._table).columns[o.column]?.name ?? o.column;
+          return `${qName2}."${dbCol}" ${o.dir.toUpperCase()}`;
         } else if ("sql" in o.column && "params" in o.column) {
           const offset = params.length;
           params.push(...o.column.params);
@@ -1030,8 +1122,8 @@ class SelectBuilderIntermediate {
     this._executor = _executor;
     this._selection = _selection;
   }
-  from(table2) {
-    return new SelectBuilder(table2, this._executor, this._selection);
+  from(table) {
+    return new SelectBuilder(table, this._executor, this._selection);
   }
 }
 
@@ -1043,8 +1135,8 @@ class UpdateBuilder {
   _returning;
   _comment;
   _with = [];
-  constructor(table2, executor) {
-    this._table = table2;
+  constructor(table, executor) {
+    this._table = table;
     this._executor = executor;
   }
   then(onfulfilled, onrejected) {
@@ -1226,8 +1318,8 @@ class RelationalQueryBuilder {
     let cached = schemaCache.get(tableName);
     if (cached)
       return cached;
-    const table2 = this._schema[tableName];
-    const tConfig = table2[TableConfigSymbol];
+    const table = this._schema[tableName];
+    const tConfig = table[TableConfigSymbol];
     const ones = {};
     const manys = {};
     const manyToManys = {};
@@ -1240,6 +1332,8 @@ class RelationalQueryBuilder {
     }
     for (const [otherName, otherTable] of Object.entries(this._schema)) {
       const otherConfig = otherTable[TableConfigSymbol];
+      if (!otherConfig)
+        continue;
       for (const [colName2, col2] of Object.entries(otherConfig.columns)) {
         if (col2.references && col2.references.table === tableName) {
           const ref = col2.references;
@@ -1250,6 +1344,8 @@ class RelationalQueryBuilder {
     }
     for (const [junctionName, junctionTable] of Object.entries(this._schema)) {
       const junctionConfig = junctionTable[TableConfigSymbol];
+      if (!junctionConfig)
+        continue;
       const refs = Object.entries(junctionConfig.columns).filter(([_, c]) => c.references);
       const toThis = refs.find(([_, c]) => c.references.table === tableName);
       if (toThis) {
@@ -1272,7 +1368,7 @@ class RelationalQueryBuilder {
     schemaCache.set(tableName, result);
     return result;
   }
-  _buildSelectJson(tableName, args, alias, params, parentAlias, joinCondition, extraJoin) {
+  _buildSelectJson(tableName, args, alias2, params, parentAlias, joinCondition, extraJoin) {
     const tableConfig = this._schema[tableName][TableConfigSymbol];
     const relations = this._getRuntimeRelations(tableName);
     const withArgs = args.with || {};
@@ -1290,26 +1386,26 @@ class RelationalQueryBuilder {
             continue;
         }
       }
-      jsonFields.push(`'${colKey}', "${alias}"."${colConfig.name}"`);
+      jsonFields.push(`'${colKey}', "${alias2}"."${colConfig.name}"`);
     }
     for (const [relKey, relArgs] of Object.entries(withArgs)) {
       const isTrue = relArgs === true;
       const rArgs = isTrue ? {} : relArgs;
       if (relations.ones[relKey]) {
         const rel = relations.ones[relKey];
-        const subAlias = `${alias}_${relKey}`;
+        const subAlias = `${alias2}_${relKey}`;
         const targetConfig = this._schema[rel.targetTable][TableConfigSymbol];
         const targetPk = getPkColumn(targetConfig);
-        const joinCond = `"${subAlias}"."${targetPk}" = "${alias}"."${rel.sourceColumn}"`;
-        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias, joinCond);
+        const joinCond = `"${subAlias}"."${targetPk}" = "${alias2}"."${rel.sourceColumn}"`;
+        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias2, joinCond);
         const subSql = `SELECT ${subQuery.sql} ${subQuery.from}`;
         jsonFields.push(`'${relKey}', (${subSql})`);
       } else if (relations.manys[relKey]) {
         const rel = relations.manys[relKey];
-        const subAlias = `${alias}_${relKey}`;
+        const subAlias = `${alias2}_${relKey}`;
         const thisPk = getPkColumn(tableConfig);
-        const joinCond = `"${subAlias}"."${rel.targetColumn}" = "${alias}"."${thisPk}"`;
-        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias, joinCond);
+        const joinCond = `"${subAlias}"."${rel.targetColumn}" = "${alias2}"."${thisPk}"`;
+        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias2, joinCond);
         const aggAlias = `${subAlias}_agg`;
         const aggSql = `
           SELECT COALESCE(json_agg(_sub.obj), '[]'::json)
@@ -1321,16 +1417,16 @@ class RelationalQueryBuilder {
         jsonFields.push(`'${relKey}', (${aggSql})`);
       } else if (relations.manyToManys[relKey]) {
         const rel = relations.manyToManys[relKey];
-        const subAlias = `${alias}_${relKey}`;
-        const junctionAlias = `${alias}_j_${relKey}`;
+        const subAlias = `${alias2}_${relKey}`;
+        const junctionAlias = `${alias2}_j_${relKey}`;
         const targetTableConfig = this._schema[rel.targetTable][TableConfigSymbol];
         const junctionTableConfig = this._schema[rel.junctionTable][TableConfigSymbol];
         const fromExtra = `
           INNER JOIN ${junctionTableConfig.qualifiedName} AS "${junctionAlias}"
           ON "${junctionAlias}"."${rel.joinTargetColumn}" = "${subAlias}"."${getPkColumn(targetTableConfig)}"
         `;
-        const whereExtra = `"${junctionAlias}"."${rel.joinSourceColumn}" = "${alias}"."${getPkColumn(tableConfig)}"`;
-        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias, whereExtra, fromExtra);
+        const whereExtra = `"${junctionAlias}"."${rel.joinSourceColumn}" = "${alias2}"."${getPkColumn(tableConfig)}"`;
+        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias2, whereExtra, fromExtra);
         const aggSql = `
           SELECT COALESCE(json_agg(_sub.obj), '[]'::json)
           FROM (
@@ -1342,7 +1438,7 @@ class RelationalQueryBuilder {
       }
     }
     let selectSql = `json_build_object(${jsonFields.join(", ")})`;
-    let fromSql = `FROM ${tableConfig.qualifiedName} AS "${alias}"`;
+    let fromSql = `FROM ${tableConfig.qualifiedName} AS "${alias2}"`;
     if (extraJoin) {
       fromSql += ` ${extraJoin}`;
     }
@@ -1390,7 +1486,7 @@ class RelationalQueryBuilder {
   }
   buildSQL(args) {
     const params = [];
-    const rootAlias = "root";
+    const rootAlias = this._tableName;
     const subQuery = this._buildSelectJson(this._tableName, args, rootAlias, params);
     const sql2 = `SELECT ${subQuery.sql} AS _data ${subQuery.from}`;
     return { sql: sql2, params };
@@ -1466,14 +1562,14 @@ class BungresDB {
     }
     return new SelectBuilderIntermediate(this);
   }
-  insert(table2) {
-    return new InsertBuilder(table2, this);
+  insert(table) {
+    return new InsertBuilder(table, this);
   }
-  update(table2) {
-    return new UpdateBuilder(table2, this);
+  update(table) {
+    return new UpdateBuilder(table, this);
   }
-  delete(table2) {
-    return new DeleteBuilder(table2, this);
+  delete(table) {
+    return new DeleteBuilder(table, this);
   }
   async execute(builder) {
     await this.ready();
@@ -1517,14 +1613,14 @@ class BungresTransaction {
     }
     return new SelectBuilderIntermediate(this);
   }
-  insert(table2) {
-    return new InsertBuilder(table2, this);
+  insert(table) {
+    return new InsertBuilder(table, this);
   }
-  update(table2) {
-    return new UpdateBuilder(table2, this);
+  update(table) {
+    return new UpdateBuilder(table, this);
   }
-  delete(table2) {
-    return new DeleteBuilder(table2, this);
+  delete(table) {
+    return new DeleteBuilder(table, this);
   }
   async execute(builder) {
     const chunk = "toSQL" in builder ? builder.toSQL() : builder;
@@ -1685,13 +1781,13 @@ function formatDefaultValue(value, dataType) {
     return String(value);
   return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
 }
-function buildIndex(table2, idx) {
-  const tableName = table2.schema ? `"${table2.schema}"."${table2.name}"` : `"${table2.name}"`;
+function buildIndex(table, idx) {
+  const tableName = table.schema ? `"${table.schema}"."${table.name}"` : `"${table.name}"`;
   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}` : "";
-  const idxName = idx.name ?? `idx_${table2.name}_${idx.columns.join("_")}`;
+  const idxName = idx.name ?? `idx_${table.name}_${idx.columns.join("_")}`;
   return `CREATE ${unique2}INDEX IF NOT EXISTS "${idxName}" ON ${tableName}${using} (${cols})${where};`;
 }
 function generateAddColumn(tableName, schema, key, col2) {
@@ -1702,6 +1798,44 @@ function generateDropColumn(tableName, schema, columnName) {
   const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
   return `ALTER TABLE ${tbl} DROP COLUMN IF EXISTS "${columnName}";`;
 }
+function generateCreateEnum(name, values) {
+  const vals = values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
+  return `CREATE TYPE "${name}" AS ENUM (${vals});`;
+}
+function generateDropEnum(name, ifExists = true) {
+  return `DROP TYPE${ifExists ? " IF EXISTS" : ""} "${name}";`;
+}
+function inlineParams(chunk) {
+  let { sql: sql2, params } = chunk;
+  return sql2.replace(/\$(\d+)/g, (_, n) => {
+    const p = params[parseInt(n) - 1];
+    if (typeof p === "string")
+      return `'${p.replace(/'/g, "''")}'`;
+    if (typeof p === "number")
+      return String(p);
+    if (typeof p === "boolean")
+      return p ? "TRUE" : "FALSE";
+    if (p === null)
+      return "NULL";
+    return `'${String(p).replace(/'/g, "''")}'`;
+  });
+}
+function generateCreateView(view) {
+  const kind = view.materialized ? "MATERIALIZED VIEW" : "VIEW";
+  let inlineSql = "";
+  if (view.sql) {
+    inlineSql = view.sql;
+  } else if (view.query && typeof view.query.toSQL === "function") {
+    inlineSql = inlineParams(view.query.toSQL());
+  } else {
+    inlineSql = "SELECT * FROM (VALUES ('LEGACY_SNAPSHOT_MISSING_SQL')) AS t(c)";
+  }
+  return `CREATE ${kind} "${view.name}" AS ${inlineSql};`;
+}
+function generateDropView(view, ifExists = true) {
+  const kind = view.materialized ? "MATERIALIZED VIEW" : "VIEW";
+  return `DROP ${kind}${ifExists ? " IF EXISTS" : ""} "${view.name}";`;
+}
 
 // src/schema-loader.ts
 async function loadSchemas(patterns, cwd = process.cwd()) {
@@ -1715,11 +1849,27 @@ async function loadSchemas(patterns, cwd = process.cwd()) {
       for (const [exportName, value] of Object.entries(mod)) {
         if (isTable(value)) {
           entries.push({
+            type: "table",
             exportName,
             config: value[TableConfigSymbol],
             table: value,
             filePath: absPath
           });
+        } else if (isEnum(value)) {
+          entries.push({
+            type: "enum",
+            exportName,
+            enumName: value.enumName,
+            enumValues: value.enumValues,
+            filePath: absPath
+          });
+        } else if (isView(value)) {
+          entries.push({
+            type: "view",
+            exportName,
+            config: value,
+            filePath: absPath
+          });
         }
       }
     }
@@ -1729,17 +1879,67 @@ async function loadSchemas(patterns, cwd = process.cwd()) {
 function isTable(value) {
   return typeof value === "object" && value !== null && TableConfigSymbol in value;
 }
+function isEnum(value) {
+  return typeof value === "function" && "enumName" in value && "enumValues" in value && Array.isArray(value.enumValues);
+}
+function isView(value) {
+  return typeof value === "object" && value !== null && "name" in value && "query" in value && typeof value.query === "object" && typeof value.query.toSQL === "function";
+}
 // src/differ.ts
 function diffSchemas(prev, next) {
   const statements = [];
   const summary = [];
   const warnings = [];
-  const prevTables = new Set(Object.keys(prev));
-  const nextTables = new Set(Object.keys(next));
+  const prevEnums = prev.enums || {};
+  const nextEnums = next.enums || {};
+  const prevEnumNames = new Set(Object.keys(prevEnums));
+  const nextEnumNames = new Set(Object.keys(nextEnums));
+  for (const enumName of nextEnumNames) {
+    if (!prevEnumNames.has(enumName)) {
+      const e = nextEnums[enumName];
+      statements.push(generateCreateEnum(e.enumName, e.enumValues));
+      summary.push(`CREATE TYPE ${e.enumName}`);
+    }
+  }
+  for (const enumName of prevEnumNames) {
+    if (!nextEnumNames.has(enumName)) {
+      const e = prevEnums[enumName];
+      statements.push(generateDropEnum(e.enumName, true));
+      summary.push(`DROP TYPE ${e.enumName}`);
+    }
+  }
+  for (const enumName of nextEnumNames) {
+    if (prevEnumNames.has(enumName)) {
+      const p = prevEnums[enumName];
+      const n = nextEnums[enumName];
+      if (JSON.stringify(p.enumValues) !== JSON.stringify(n.enumValues)) {
+        warnings.push(`Enum '${n.enumName}' values have changed. Bungres Kit currently requires manual migration for ALTER TYPE ... ADD VALUE.`);
+      }
+    }
+  }
+  const prevViews = prev.views || {};
+  const nextViews = next.views || {};
+  const prevViewNames = new Set(Object.keys(prevViews));
+  const nextViewNames = new Set(Object.keys(nextViews));
+  for (const viewName of prevViewNames) {
+    if (!nextViewNames.has(viewName)) {
+      statements.push(generateDropView(prevViews[viewName]));
+      summary.push(`DROP VIEW ${viewName}`);
+    } else {
+      const pSql = generateCreateView(prevViews[viewName]);
+      const nSql = generateCreateView(nextViews[viewName]);
+      if (pSql !== nSql) {
+        statements.push(generateDropView(prevViews[viewName]));
+        summary.push(`DROP VIEW ${viewName} (for recreation)`);
+      }
+    }
+  }
+  const prevTables = new Set(Object.keys(prev.tables || {}));
+  const nextTables = new Set(Object.keys(next.tables || {}));
   const newTableConfigs = [];
   for (const tableName of nextTables) {
     if (!prevTables.has(tableName)) {
-      newTableConfigs.push(next[tableName]);
+      newTableConfigs.push(next.tables[tableName]);
     }
   }
   for (const config of topoSortConfigs(newTableConfigs)) {
@@ -1748,7 +1948,7 @@ function diffSchemas(prev, next) {
   }
   for (const tableName of prevTables) {
     if (!nextTables.has(tableName)) {
-      const config = prev[tableName];
+      const config = prev.tables[tableName];
       const tbl = config.schema ? `"${config.schema}"."${tableName}"` : `"${tableName}"`;
       statements.push(`DROP TABLE IF EXISTS ${tbl};`);
       summary.push(`DROP TABLE ${tableName}`);
@@ -1758,8 +1958,8 @@ function diffSchemas(prev, next) {
   for (const tableName of nextTables) {
     if (!prevTables.has(tableName))
       continue;
-    const prevConfig = prev[tableName];
-    const nextConfig = next[tableName];
+    const prevConfig = prev.tables[tableName];
+    const nextConfig = next.tables[tableName];
     const prevCols = prevConfig.columns;
     const nextCols = nextConfig.columns;
     const prevColNames = new Set(Object.keys(prevCols));
@@ -1831,6 +2031,19 @@ function diffSchemas(prev, next) {
       }
     }
   }
+  for (const viewName of nextViewNames) {
+    if (!prevViewNames.has(viewName)) {
+      statements.push(generateCreateView(nextViews[viewName]));
+      summary.push(`CREATE VIEW ${viewName}`);
+    } else {
+      const pSql = generateCreateView(prevViews[viewName]);
+      const nSql = generateCreateView(nextViews[viewName]);
+      if (pSql !== nSql) {
+        statements.push(generateCreateView(nextViews[viewName]));
+        summary.push(`CREATE VIEW ${viewName} (recreated)`);
+      }
+    }
+  }
   return { statements, summary, warnings };
 }
 function topoSortConfigs(tables) {
@@ -1851,14 +2064,21 @@ function topoSortConfigs(tables) {
       visit(dep);
     result.push(config);
   }
-  for (const table2 of tables)
-    visit(table2.name);
+  for (const table of tables)
+    visit(table.name);
   return result;
 }
 function diffColumn(prev, next) {
   const changes = [];
   const col2 = `"${next.name}"`;
+  const prevDef = prev.defaultFn ?? (prev.defaultValue !== undefined ? String(prev.defaultValue) : undefined);
+  const nextDef = next.defaultFn ?? (next.defaultValue !== undefined ? String(next.defaultValue) : undefined);
+  let typeChanged = false;
   if (prev.dataType !== next.dataType) {
+    typeChanged = true;
+    if (prevDef !== undefined) {
+      changes.push(`ALTER COLUMN ${col2} DROP DEFAULT`);
+    }
     changes.push(`ALTER COLUMN ${col2} TYPE ${next.dataType.toUpperCase()} USING ${col2}::${next.dataType}`);
   } else {
     const prevLen = prev.length;
@@ -1875,9 +2095,12 @@ function diffColumn(prev, next) {
   if (prev.notNull && !next.notNull) {
     changes.push(`ALTER COLUMN ${col2} DROP NOT NULL`);
   }
-  const prevDef = prev.defaultFn ?? (prev.defaultValue !== undefined ? String(prev.defaultValue) : undefined);
-  const nextDef = next.defaultFn ?? (next.defaultValue !== undefined ? String(next.defaultValue) : undefined);
-  if (prevDef !== nextDef) {
+  if (typeChanged) {
+    if (nextDef !== undefined) {
+      const val = next.defaultFn ?? formatDefault(next.defaultValue, next.dataType);
+      changes.push(`ALTER COLUMN ${col2} SET DEFAULT ${val}`);
+    }
+  } else if (prevDef !== nextDef) {
     if (nextDef !== undefined) {
       const val = next.defaultFn ?? formatDefault(next.defaultValue, next.dataType);
       changes.push(`ALTER COLUMN ${col2} SET DEFAULT ${val}`);
@@ -3000,6 +3223,30 @@ ${i}` : `${s}${styleText("inverse", r2)}${i}`;
     });
   }
 }
+class n extends V {
+  get userInputWithCursor() {
+    if (this.state === "submit")
+      return this.userInput;
+    const t2 = this.userInput;
+    if (this.cursor >= t2.length)
+      return `${this.userInput}\u2588`;
+    const r2 = t2.slice(0, this.cursor), s = t2.slice(this.cursor, this.cursor + 1), e = t2.slice(this.cursor + 1);
+    return `${r2}${styleText("inverse", s)}${e}`;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  constructor(t2) {
+    super({
+      ...t2,
+      initialUserInput: t2.initialUserInput ?? t2.initialValue
+    }), this.on("userInput", (r2) => {
+      this._setValue(r2);
+    }), this.on("finalize", () => {
+      this.value || (this.value = t2.defaultValue), this.value === undefined && (this.value = "");
+    });
+  }
+}
 
 // ../../node_modules/.bun/@clack+prompts@1.7.0/node_modules/@clack/prompts/dist/index.mjs
 import { styleText as styleText2, stripVTControlCharacters } from "util";
@@ -3260,24 +3507,62 @@ var SELECT_INSTRUCTIONS = [
   `${styleText2("dim", "Enter:")} confirm`
 ];
 var i = `${styleText2("gray", S_BAR)}  `;
+var text = (e) => new n({
+  validate: e.validate,
+  placeholder: e.placeholder,
+  defaultValue: e.defaultValue,
+  initialValue: e.initialValue,
+  output: e.output,
+  signal: e.signal,
+  input: e.input,
+  render() {
+    const i2 = e?.withGuide ?? settings.withGuide, s = `${`${i2 ? `${styleText2("gray", S_BAR)}
+` : ""}${symbol(this.state)}  `}${e.message}
+`, c2 = e.placeholder && e.placeholder.length > 0 ? styleText2("inverse", e.placeholder[0]) + styleText2("dim", e.placeholder.slice(1)) : styleText2(["inverse", "hidden"], "_"), o2 = this.userInput ? this.userInputWithCursor : c2, l2 = this.value ?? "";
+    switch (this.state) {
+      case "error": {
+        const n2 = this.error ? `  ${styleText2("yellow", this.error)}` : "", r2 = i2 ? `${styleText2("yellow", S_BAR)}  ` : "", d = i2 ? styleText2("yellow", S_BAR_END) : "";
+        return `${s.trim()}
+${r2}${o2}
+${d}${n2}
+`;
+      }
+      case "submit": {
+        const n2 = l2 ? `  ${styleText2("dim", l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n2}`;
+      }
+      case "cancel": {
+        const n2 = l2 ? `  ${styleText2(["strikethrough", "dim"], l2)}` : "", r2 = i2 ? styleText2("gray", S_BAR) : "";
+        return `${s}${r2}${n2}${l2.trim() ? `
+${r2}` : ""}`;
+      }
+      default: {
+        const n2 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", r2 = i2 ? styleText2("cyan", S_BAR_END) : "";
+        return `${s}${n2}${o2}
+${r2}
+`;
+      }
+    }
+  }
+}).prompt();
 
 // src/commands/push.ts
 var import_picocolors = __toESM(require_picocolors(), 1);
 async function runPush(config, opts = {}) {
   intro(import_picocolors.default.bgCyan(import_picocolors.default.black(" @bungres/kit push ")));
-  const s = spinner();
-  s.start("Loading schemas...");
+  let activeSpinner = spinner();
+  activeSpinner.start("Loading schemas...");
   const schemas = await loadSchemas(config.schema);
   if (schemas.length === 0) {
-    s.stop("No schemas found.");
+    activeSpinner.stop("No schemas found.");
     log.warn(import_picocolors.default.yellow("No table definitions found. Check your schema glob pattern."));
     outro("Failed.");
     return;
   }
-  s.stop(`Loaded ${schemas.length} schemas.`);
+  activeSpinner.stop(`Loaded ${schemas.length} schemas.`);
   const sql2 = new Bun.SQL(config.dbUrl);
-  const ms = spinner();
-  ms.start("Computing diff from database...");
+  activeSpinner = spinner();
+  activeSpinner.start("Computing diff from database...");
   try {
     await sql2.unsafe(`CREATE SCHEMA IF NOT EXISTS "${config.migrationsSchema}";`);
     const qualifiedPush = `"${config.migrationsSchema}"."__bungres_push"`;
@@ -3288,19 +3573,41 @@ async function runPush(config, opts = {}) {
       );
     `);
     const rows = await sql2.unsafe(`SELECT snapshot FROM ${qualifiedPush} ORDER BY id DESC LIMIT 1;`);
-    let prevSnapshot = {};
+    let prevSnapshot = { tables: {}, enums: {}, views: {} };
     if (rows.length > 0) {
-      prevSnapshot = typeof rows[0].snapshot === "string" ? JSON.parse(rows[0].snapshot) : rows[0].snapshot;
+      const parsed = typeof rows[0].snapshot === "string" ? JSON.parse(rows[0].snapshot) : rows[0].snapshot;
+      if (parsed.tables || parsed.enums || parsed.views) {
+        prevSnapshot = {
+          tables: parsed.tables || {},
+          enums: parsed.enums || {},
+          views: parsed.views || {}
+        };
+      } else {
+        prevSnapshot = { tables: parsed, enums: {}, views: {} };
+      }
+    }
+    const currentSnapshot = { tables: {}, enums: {}, views: {} };
+    for (const s of schemas) {
+      if (s.type === "table") {
+        currentSnapshot.tables[s.config.name] = s.config;
+      } else if (s.type === "enum") {
+        currentSnapshot.enums[s.enumName] = { enumName: s.enumName, enumValues: s.enumValues };
+      } else if (s.type === "view") {
+        currentSnapshot.views[s.config.name] = {
+          name: s.config.name,
+          materialized: s.config.materialized,
+          sql: typeof s.config.query?.toSQL === "function" ? inlineParams(s.config.query.toSQL()) : s.config.sql
+        };
+      }
     }
-    const currentSnapshot = Object.fromEntries(schemas.map((schemaEntry) => [schemaEntry.config.name, schemaEntry.config]));
     const diff = diffSchemas(prevSnapshot, currentSnapshot);
     if (diff.statements.length === 0) {
-      ms.stop("Up to date.");
+      activeSpinner.stop("Up to date.");
       log.success(import_picocolors.default.green("No schema changes detected. Database is up to date."));
       outro("Done.");
       return;
     }
-    ms.stop(`Computed ${diff.statements.length} statements.`);
+    activeSpinner.stop(`Computed ${diff.statements.length} statements.`);
     log.message(import_picocolors.default.bold("Changes to apply:"));
     for (const change of diff.summary) {
       if (change.startsWith("CREATE") || change.startsWith("ALTER TABLE") && change.includes("ADD")) {
@@ -3327,8 +3634,8 @@ async function runPush(config, opts = {}) {
         return;
       }
     }
-    const exSpinner = spinner();
-    exSpinner.start("Pushing changes...");
+    activeSpinner = spinner();
+    activeSpinner.start("Pushing changes...");
     for (const stmt of diff.statements) {
       if (config.verbose) {
         log.info(import_picocolors.default.gray(`-- ${stmt}`));
@@ -3336,9 +3643,10 @@ async function runPush(config, opts = {}) {
       await sql2.unsafe(stmt);
     }
     await sql2.unsafe(`INSERT INTO ${qualifiedPush} (snapshot) VALUES ($1);`, [JSON.stringify(currentSnapshot)]);
-    exSpinner.stop(import_picocolors.default.green("Changes applied successfully."));
+    activeSpinner.stop(import_picocolors.default.green("Changes applied successfully."));
     outro(import_picocolors.default.cyan("\u2728 Push complete."));
   } catch (err) {
+    activeSpinner.stop("Failed.");
     log.error(import_picocolors.default.red(`Push failed: ${err.message}`));
     outro("Failed.");
   } finally {
@@ -3365,19 +3673,50 @@ async function runGenerate(config, name) {
   const metaDir = join3(migrationsDir, "meta");
   await Bun.$`mkdir -p ${migrationsDir}`.quiet();
   await Bun.$`mkdir -p ${metaDir}`.quiet();
-  const currentSnapshot = Object.fromEntries(schemas.map((s2) => [s2.config.name, s2.config]));
-  let prevSnapshot = {};
+  const currentSnapshot = { tables: {}, enums: {}, views: {} };
+  for (const s2 of schemas) {
+    if (s2.type === "table") {
+      currentSnapshot.tables[s2.config.name] = s2.config;
+    } else if (s2.type === "enum") {
+      currentSnapshot.enums[s2.enumName] = { enumName: s2.enumName, enumValues: s2.enumValues };
+    } else if (s2.type === "view") {
+      currentSnapshot.views[s2.config.name] = {
+        name: s2.config.name,
+        materialized: s2.config.materialized,
+        sql: typeof s2.config.query?.toSQL === "function" ? inlineParams(s2.config.query.toSQL()) : s2.config.sql
+      };
+    }
+  }
+  let prevSnapshot = { tables: {}, enums: {}, views: {} };
   let isFirstMigration = true;
   try {
     const files = readdirSync(metaDir).filter((f2) => f2.endsWith("_snapshot.json")).sort();
     if (files.length > 0) {
       const latest = files[files.length - 1];
-      prevSnapshot = JSON.parse(await Bun.file(join3(metaDir, latest)).text());
+      const parsed = JSON.parse(await Bun.file(join3(metaDir, latest)).text());
+      if (parsed.tables || parsed.enums || parsed.views) {
+        prevSnapshot = {
+          tables: parsed.tables || {},
+          enums: parsed.enums || {},
+          views: parsed.views || {}
+        };
+      } else {
+        prevSnapshot = { tables: parsed, enums: {}, views: {} };
+      }
       isFirstMigration = false;
     } else {
       const legacyFile2 = Bun.file(join3(migrationsDir, ".snapshot.json"));
       if (await legacyFile2.exists()) {
-        prevSnapshot = JSON.parse(await legacyFile2.text());
+        const parsed = JSON.parse(await legacyFile2.text());
+        if (parsed.tables || parsed.enums || parsed.views) {
+          prevSnapshot = {
+            tables: parsed.tables || {},
+            enums: parsed.enums || {},
+            views: parsed.views || {}
+          };
+        } else {
+          prevSnapshot = { tables: parsed, enums: {}, views: {} };
+        }
         isFirstMigration = false;
       }
     }
@@ -3397,17 +3736,30 @@ async function runGenerate(config, name) {
   let summary;
   let warnings = [];
   if (isFirstMigration) {
-    const sorted = topoSort(schemas);
-    upStatements = sorted.flatMap((entry) => [
-      `-- ${entry.exportName}`,
-      generateCreateTable(entry.config, true),
-      ``
-    ]);
-    downStatements = [...sorted].reverse().flatMap((entry) => {
+    const tableSchemas = schemas.filter((s2) => s2.type === "table");
+    const enumSchemas = schemas.filter((s2) => s2.type === "enum");
+    const viewSchemas = schemas.filter((s2) => s2.type === "view");
+    const sorted = topoSort(tableSchemas);
+    upStatements = [];
+    downStatements = [];
+    summary = [];
+    for (const e of enumSchemas) {
+      upStatements.push(`-- ${e.exportName}`, `CREATE TYPE "${e.enumName}" AS ENUM (${e.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ")});`, ``);
+      downStatements.unshift(`DROP TYPE IF EXISTS "${e.enumName}";`);
+      summary.push(`CREATE TYPE ${e.enumName}`);
+    }
+    for (const entry of sorted) {
+      upStatements.push(`-- ${entry.exportName}`, generateCreateTable(entry.config, true), ``);
       const tbl = entry.config.schema ? `"${entry.config.schema}"."${entry.config.name}"` : `"${entry.config.name}"`;
-      return [`DROP TABLE IF EXISTS ${tbl};`];
-    });
-    summary = sorted.map((s2) => `CREATE TABLE ${s2.config.name}`);
+      downStatements.unshift(`DROP TABLE IF EXISTS ${tbl};`);
+      summary.push(`CREATE TABLE ${entry.config.name}`);
+    }
+    for (const v of viewSchemas) {
+      upStatements.push(`-- ${v.exportName}`, generateCreateView(v.config), ``);
+      const isMat = v.config.materialized ? "MATERIALIZED VIEW" : "VIEW";
+      downStatements.unshift(`DROP ${isMat} IF EXISTS "${v.config.name}";`);
+      summary.push(`CREATE ${isMat} ${v.config.name}`);
+    }
   } else {
     const upDiff = diffSchemas(prevSnapshot, currentSnapshot);
     if (upDiff.statements.length === 0) {
@@ -3497,9 +3849,9 @@ async function runMigrate(config) {
   intro(import_picocolors3.default.bgCyan(import_picocolors3.default.black(" @bungres/kit migrate ")));
   const migrationsDir = resolve4(config.out);
   const sql2 = new Bun.SQL(config.dbUrl);
-  const table2 = config.migrationsTable;
+  const table = config.migrationsTable;
   const schema = config.migrationsSchema;
-  const qualifiedTable = `"${schema}"."${table2}"`;
+  const qualifiedTable = `"${schema}"."${table}"`;
   const createSchema = `CREATE SCHEMA IF NOT EXISTS "${schema}";`;
   const createMigrationsTable = `
 CREATE TABLE IF NOT EXISTS ${qualifiedTable} (
@@ -3507,7 +3859,7 @@ CREATE TABLE IF NOT EXISTS ${qualifiedTable} (
   name        TEXT NOT NULL UNIQUE,
   applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
 );`.trim();
-  const s = spinner();
+  let s = spinner();
   s.start("Checking pending migrations...");
   try {
     await sql2.unsafe(createSchema);
@@ -3536,8 +3888,8 @@ CREATE TABLE IF NOT EXISTS ${qualifiedTable} (
     }
     s.stop(`Found ${pending.length} pending migration(s).`);
     for (const file of pending) {
-      const ms = spinner();
-      ms.start(`Applying ${file}...`);
+      s = spinner();
+      s.start(`Applying ${file}...`);
       const content = await Bun.file(join4(migrationsDir, file)).text();
       let upContent = content;
       const upMatch = content.match(/-- ==== UP ====([\s\S]*?)(?:-- ==== DOWN ====|$)/i);
@@ -3556,10 +3908,11 @@ ${upContent}
         }
         await txSql.unsafe(`INSERT INTO ${qualifiedTable} (name) VALUES ($1)`, [file]);
       });
-      ms.stop(import_picocolors3.default.green(`\u2713 Applied ${file}`));
+      s.stop(import_picocolors3.default.green(`\u2713 Applied ${file}`));
     }
     outro(import_picocolors3.default.cyan("\u2728 All migrations applied successfully."));
   } catch (err) {
+    s.stop("Failed.");
     log.error(import_picocolors3.default.red(`Migration failed: ${err.message}`));
     outro("Failed.");
   } finally {
@@ -3664,20 +4017,19 @@ function generateSchemaTS(tableMap, dbSchema) {
     `// Generated at: ${new Date().toISOString()}`,
     ``,
     `import {`,
-    `  table,`,
+    `  pgTable,`,
     `  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}", {`);
-    for (const col2 of table2.columns) {
+  for (const [, table] of tableMap) {
+    const varName = toCamelCase(table.tableName);
+    lines.push(`export const ${varName} = pgTable("${table.tableName}", {`);
+    for (const col2 of table.columns) {
       const colExpr = buildColumnExpression(col2);
       lines.push(`  ${toCamelCase(col2.name)}: ${colExpr},`);
     }
@@ -3685,9 +4037,9 @@ function generateSchemaTS(tableMap, dbSchema) {
     if (dbSchema !== "public") {
       options.push(`schema: "${dbSchema}"`);
     }
-    if (table2.indexes.length > 0) {
+    if (table.indexes.length > 0) {
       const idxLines = [];
-      for (const idx of table2.indexes) {
+      for (const idx of table.indexes) {
         const m2 = idx.indexdef.match(/CREATE (UNIQUE )?INDEX (.+) ON (.+) USING (\w+) \((.+)\)(?: WHERE (.+))?/i);
         if (m2) {
           const isUnique = !!m2[1];
@@ -3757,11 +4109,13 @@ function buildColumnExpression(col2) {
       refOpts += `, onUpdate: "${updateRule}"`;
     opts.push(`references: { ${refOpts} }`);
   }
-  let builderName = pgTypeToBungresBuilderName(col2);
-  if (opts.length > 0) {
-    return `${builderName}({ ${opts.join(", ")} })`;
-  }
-  return `${builderName}()`;
+  let builderResult = pgTypeToBungresBuilderName(col2);
+  let builderName = typeof builderResult === "string" ? builderResult : builderResult.base;
+  let isArray = typeof builderResult !== "string" && builderResult.isArray;
+  let expr = opts.length > 0 ? `${builderName}({ ${opts.join(", ")} })` : `${builderName}()`;
+  if (isArray)
+    expr += `.array()`;
+  return expr;
 }
 function pgTypeToBungresBuilderName(col2) {
   const dt = col2.dataType;
@@ -3807,14 +4161,14 @@ function pgTypeToBungresBuilderName(col2) {
     return "text";
   if (dt === "ARRAY") {
     if (col2.udtName === "_text")
-      return "textArray";
+      return { base: "text", isArray: true };
     if (col2.udtName === "_int4" || col2.udtName === "_int8")
-      return "integerArray";
+      return { base: "integer", isArray: true };
     if (col2.udtName === "_varchar")
-      return "varcharArray";
+      return { base: "varchar", isArray: true };
     if (col2.udtName === "_uuid")
-      return "uuidArray";
-    return "textArray";
+      return { base: "uuid", isArray: true };
+    return { base: "text", isArray: true };
   }
   return "text";
 }
@@ -3828,16 +4182,16 @@ async function runStatus(config) {
   intro(import_picocolors4.default.bgCyan(import_picocolors4.default.black(" @bungres/kit status ")));
   const migrationsDir = resolve6(config.out);
   const sql2 = new Bun.SQL(config.dbUrl);
-  const table2 = config.migrationsTable;
+  const table = config.migrationsTable;
   const schema = config.migrationsSchema;
-  const qualifiedTable = `"${schema}"."${table2}"`;
+  const qualifiedTable = `"${schema}"."${table}"`;
   const s = spinner();
   s.start("Checking migration status...");
   try {
     const tableCheck = await sql2.unsafe(`SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
         WHERE table_schema = $1 AND table_name = $2
-      ) AS exists`, [schema, table2]);
+      ) AS exists`, [schema, table]);
     const trackingExists = tableCheck[0]?.exists ?? false;
     const glob = new Bun.Glob("*.sql");
     const files = [];
@@ -3872,6 +4226,7 @@ async function runStatus(config) {
     log.info(`${import_picocolors4.default.green(appliedSet.size.toString())} applied, ${import_picocolors4.default.yellow(pendingCount.toString())} pending.`);
     outro("Done.");
   } catch (err) {
+    s.stop("Failed.");
     log.error(import_picocolors4.default.red(`Status check failed: ${err.message}`));
     outro("Failed.");
   } finally {
@@ -3882,23 +4237,14 @@ async function runStatus(config) {
 var import_picocolors5 = __toESM(require_picocolors(), 1);
 async function runDrop(config, opts = {}) {
   intro(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" @bungres/kit drop ")));
-  const s = spinner();
-  s.start("Loading schemas...");
-  const schemas = await loadSchemas(config.schema);
-  if (schemas.length === 0) {
-    s.stop("No schemas found.");
-    log.warn(import_picocolors5.default.yellow("No table definitions found in schema files."));
-    outro("Failed.");
-    return;
-  }
-  s.stop(`Loaded ${schemas.length} schemas.`);
   const ms = spinner();
-  ms.start("Checking database tables...");
+  ms.start("Scanning database for objects to drop...");
   const sql2 = new Bun.SQL(config.dbUrl);
   try {
-    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((r2) => r2.table_name));
+    const userSchema = config.dbSchema || "public";
+    const existingViews = await sql2.unsafe(`SELECT table_name FROM information_schema.views WHERE table_schema = $1`, [userSchema]);
+    const existingTables = await sql2.unsafe(`SELECT table_name FROM information_schema.tables WHERE table_schema = $1 AND table_type = 'BASE TABLE'`, [userSchema]);
+    const existingTypes = await sql2.unsafe(`SELECT t.typname FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = $1 AND t.typtype = 'e'`, [userSchema]);
     const migTableCheck = await sql2.unsafe(`SELECT EXISTS (
         SELECT 1 FROM information_schema.tables
         WHERE table_schema = $1 AND table_name = $2
@@ -3909,29 +4255,20 @@ async function runDrop(config, opts = {}) {
         WHERE table_schema = $1 AND table_name = $2
       ) AS exists`, [config.migrationsSchema, "__bungres_push"]);
     const pushTableExists = pushTableCheck[0]?.exists ?? false;
-    const tablesToDrop = schemas.filter((sch) => existingTableNames.has(sch.config.name));
-    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
+    const totalObjects = existingViews.length + existingTables.length + existingTypes.length + (migrationTableExists ? 1 : 0) + (pushTableExists ? 1 : 0);
+    if (totalObjects === 0) {
       ms.stop("Nothing to do.");
-      log.success(import_picocolors5.default.green("No tables to drop (they either don't exist or were already dropped)."));
+      log.success(import_picocolors5.default.green("No items to drop (schema is empty)."));
       outro("Done.");
       return;
     }
-    ms.stop("Database check complete.");
-    const tableNamesToPrint = tablesToDrop.map((sch) => (sch.config.schema ? sch.config.schema + "." : "") + sch.config.name);
-    if (migrationTableExists) {
-      tableNamesToPrint.push(`${config.migrationsSchema}.${config.migrationsTable}`);
-    }
-    if (pushTableExists) {
-      tableNamesToPrint.push(`${config.migrationsSchema}.__bungres_push`);
-    }
+    ms.stop("Database scan complete.");
     if (!opts.force) {
       log.warn(import_picocolors5.default.bgRed(import_picocolors5.default.white(" \u26A0\uFE0F WARNING ")));
-      log.message(import_picocolors5.default.bold(import_picocolors5.default.red("This will drop the following tables and ALL their data:")));
-      for (const name of tableNamesToPrint) {
-        log.info(import_picocolors5.default.yellow(`  - ${name}`));
-      }
+      log.message(import_picocolors5.default.bold(import_picocolors5.default.red("This will GLOBALLY drop all tables, views, and types in the database schema!")));
+      log.info(import_picocolors5.default.yellow(`Found ${existingViews.length} views, ${existingTables.length} tables, ${existingTypes.length} enums.`));
       const confirm2 = await confirm({
-        message: "Are you sure you want to proceed?",
+        message: "Are you absolutely sure you want to drop ALL data?",
         initialValue: false
       });
       if (isCancel(confirm2) || !confirm2) {
@@ -3940,24 +4277,36 @@ async function runDrop(config, opts = {}) {
       }
     }
     const exSpinner = spinner();
-    exSpinner.start("Dropping tables...");
-    for (const entry of tablesToDrop) {
-      const ddl = `DROP TABLE IF EXISTS "${entry.config.name}" CASCADE;`;
-      await sql2.unsafe(ddl);
-      log.step(import_picocolors5.default.gray(`Dropped ${entry.config.name}`));
+    exSpinner.start("Dropping objects...");
+    for (const v of existingViews) {
+      await sql2.unsafe(`DROP VIEW IF EXISTS "${userSchema}"."${v.table_name}" CASCADE;`);
+      if (opts.force !== true)
+        log.step(import_picocolors5.default.gray(`Dropped view ${v.table_name}`));
+    }
+    for (const t2 of existingTables) {
+      await sql2.unsafe(`DROP TABLE IF EXISTS "${userSchema}"."${t2.table_name}" CASCADE;`);
+      if (opts.force !== true)
+        log.step(import_picocolors5.default.gray(`Dropped table ${t2.table_name}`));
+    }
+    for (const type of existingTypes) {
+      await sql2.unsafe(`DROP TYPE IF EXISTS "${userSchema}"."${type.typname}" CASCADE;`);
+      if (opts.force !== true)
+        log.step(import_picocolors5.default.gray(`Dropped enum ${type.typname}`));
     }
     if (migrationTableExists) {
-      const qualifiedMigTable = `"${config.migrationsSchema}"."${config.migrationsTable}"`;
-      await sql2.unsafe(`DROP TABLE IF EXISTS ${qualifiedMigTable} CASCADE`);
-      log.step(import_picocolors5.default.gray(`Dropped ${config.migrationsSchema}.${config.migrationsTable}`));
+      await sql2.unsafe(`DROP TABLE IF EXISTS "${config.migrationsSchema}"."${config.migrationsTable}" CASCADE`);
+      if (opts.force !== true)
+        log.step(import_picocolors5.default.gray(`Dropped ${config.migrationsSchema}.${config.migrationsTable}`));
     }
     if (pushTableExists) {
       await sql2.unsafe(`DROP TABLE IF EXISTS "${config.migrationsSchema}"."__bungres_push" CASCADE`);
-      log.step(import_picocolors5.default.gray(`Dropped ${config.migrationsSchema}.__bungres_push`));
+      if (opts.force !== true)
+        log.step(import_picocolors5.default.gray(`Dropped ${config.migrationsSchema}.__bungres_push`));
     }
-    exSpinner.stop("Tables dropped.");
+    exSpinner.stop("Items dropped.");
     outro(import_picocolors5.default.cyan("\u2728 Drop complete."));
   } catch (err) {
+    ms.stop("Scan failed.");
     log.error(import_picocolors5.default.red(`Drop failed: ${err.message}`));
     outro("Failed.");
   } finally {