@bungres/kit 0.7.0 → 1.1.0

package/dist/index.js

@@ -55,12 +55,12 @@ var require_src = __commonJS((exports, module) => {
         ret += `${CSI2}${y}B`;
       return ret;
     },
-    up: (count2 = 1) => `${CSI2}${count2}A`,
-    down: (count2 = 1) => `${CSI2}${count2}B`,
-    forward: (count2 = 1) => `${CSI2}${count2}C`,
-    backward: (count2 = 1) => `${CSI2}${count2}D`,
-    nextLine: (count2 = 1) => `${CSI2}E`.repeat(count2),
-    prevLine: (count2 = 1) => `${CSI2}F`.repeat(count2),
+    up: (count = 1) => `${CSI2}${count}A`,
+    down: (count = 1) => `${CSI2}${count}B`,
+    forward: (count = 1) => `${CSI2}${count}C`,
+    backward: (count = 1) => `${CSI2}${count}D`,
+    nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+    prevLine: (count = 1) => `${CSI2}F`.repeat(count),
     left: `${CSI2}G`,
     hide: `${CSI2}?25l`,
     show: `${CSI2}?25h`,
@@ -68,21 +68,21 @@ var require_src = __commonJS((exports, module) => {
     restore: `${ESC2}8`
   };
   var scroll = {
-    up: (count2 = 1) => `${CSI2}S`.repeat(count2),
-    down: (count2 = 1) => `${CSI2}T`.repeat(count2)
+    up: (count = 1) => `${CSI2}S`.repeat(count),
+    down: (count = 1) => `${CSI2}T`.repeat(count)
   };
   var erase = {
     screen: `${CSI2}2J`,
-    up: (count2 = 1) => `${CSI2}1J`.repeat(count2),
-    down: (count2 = 1) => `${CSI2}J`.repeat(count2),
+    up: (count = 1) => `${CSI2}1J`.repeat(count),
+    down: (count = 1) => `${CSI2}J`.repeat(count),
     line: `${CSI2}2K`,
     lineEnd: `${CSI2}K`,
     lineStart: `${CSI2}1K`,
-    lines(count2) {
+    lines(count) {
       let clear = "";
-      for (let i = 0;i < count2; i++)
-        clear += this.line + (i < count2 - 1 ? cursor.up() : "");
-      if (count2)
+      for (let i = 0;i < count; i++)
+        clear += this.line + (i < count - 1 ? cursor.up() : "");
+      if (count)
         clear += cursor.left;
       return clear;
     }
@@ -97,16 +97,16 @@ var require_picocolors = __commonJS((exports, module) => {
   var env = p2.env || {};
   var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p2.platform === "win32" || (p2.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
   var formatter = (open, close, replace = open) => (input) => {
-    let string = "" + input, index2 = string.indexOf(close, open.length);
-    return ~index2 ? open + replaceClose(string, close, replace, index2) + close : open + string + close;
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
   };
-  var replaceClose = (string, close, replace, index2) => {
+  var replaceClose = (string, close, replace, index) => {
     let result = "", cursor3 = 0;
     do {
-      result += string.substring(cursor3, index2) + replace;
-      cursor3 = index2 + close.length;
-      index2 = string.indexOf(close, cursor3);
-    } while (~index2);
+      result += string.substring(cursor3, index) + replace;
+      cursor3 = index + close.length;
+      index = string.indexOf(close, cursor3);
+    } while (~index);
     return result + string.substring(cursor3);
   };
   var createColors = (enabled = isColorSupported) => {
@@ -202,7 +202,7 @@ async function loadConfig(cwd = process.cwd()) {
 // src/schema-loader.ts
 import { resolve as resolve2, join as join2 } from "path";
 
-// ../bungres-orm/src/schema/table.ts
+// ../bungres-orm/dist/index.js
 var TableConfigSymbol = Symbol.for("BungresTableConfig");
 function getTableConfig(table) {
   return table[TableConfigSymbol];
@@ -272,7 +272,6 @@ var table = createTableFactory("snake");
 var snakeCase = { table: createTableFactory("snake") };
 var camelCase = { table: createTableFactory("camel") };
 var noCasing = { table: createTableFactory("none") };
-// ../bungres-orm/src/schema/columns.ts
 function buildColumn(dataType, nameOrOpts, opts) {
   let name = "";
   let options = opts;
@@ -301,6 +300,13 @@ function buildColumn(dataType, nameOrOpts, opts) {
   return Object.assign(config, {
     as(alias) {
       return Object.assign({}, this, { alias });
+    },
+    array() {
+      return Object.assign({}, this, { dataType: `${this.dataType}[]` });
+    },
+    generatedAlwaysAs(expr) {
+      const sqlStr = typeof expr === "string" ? expr : expr.sql;
+      return Object.assign({}, this, { generatedAs: sqlStr });
     }
   });
 }
@@ -330,7 +336,6 @@ 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 = [];
@@ -373,7 +378,6 @@ function colName(c) {
     return c.sql;
   return c.tableName ? `${c.tableName}."${c.name}"` : `"${c.name}"`;
 }
-// ../bungres-orm/src/core/conditions.ts
 function isColumnConfig(val) {
   return val !== null && typeof val === "object" && "name" in val && "dataType" in val;
 }
@@ -527,14 +531,13 @@ function parseOrderByObject(tableConfig, orderByObj) {
   }
   return parts;
 }
-
-// ../bungres-orm/src/builders/delete.ts
 class DeleteBuilder {
   _table;
   _executor;
   _where = [];
   _returning;
   _comment;
+  _with = [];
   constructor(table2, executor) {
     this._table = table2;
     this._executor = executor;
@@ -553,6 +556,10 @@ class DeleteBuilder {
     }
     return this;
   }
+  with(...ctes) {
+    this._with.push(...ctes);
+    return this;
+  }
   returning(...columns) {
     this._returning = columns.length > 0 ? columns : ["*"];
     return this;
@@ -562,8 +569,20 @@ class DeleteBuilder {
     return this;
   }
   toSQL() {
-    let query = `DELETE FROM ${getTableConfig(this._table).qualifiedName}`;
+    const tConfig = getTableConfig(this._table);
     const params = [];
+    let prefix = "";
+    if (this._with.length > 0) {
+      const cteStrs = [];
+      for (const cte of this._with) {
+        const chunk = cte.query.toSQL();
+        const offset = params.length;
+        params.push(...chunk.params);
+        cteStrs.push(`"${cte.alias}" AS (${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)})`);
+      }
+      prefix = `WITH ${cteStrs.join(", ")} `;
+    }
+    let query = `DELETE FROM ${tConfig.qualifiedName}`;
     if (this._where.length > 0) {
       const combined = sqlJoin(this._where, " AND ");
       query += " WHERE " + combined.sql;
@@ -575,17 +594,19 @@ class DeleteBuilder {
     if (this._comment) {
       query += ` /* ${this._comment.replace(/\*\//g, "")} */`;
     }
-    return { sql: query, params };
+    return { sql: prefix + query, params };
   }
 }
-// ../bungres-orm/src/builders/insert.ts
+
 class InsertBuilder {
   _table;
   _executor;
   _values = [];
   _onConflict;
+  _onConflictUpdateConfig;
   _returning;
   _comment;
+  _with = [];
   constructor(table2, executor) {
     this._table = table2;
     this._executor = executor;
@@ -612,6 +633,14 @@ class InsertBuilder {
     this._onConflict = clause;
     return this;
   }
+  onConflictDoUpdate(config) {
+    this._onConflictUpdateConfig = config;
+    return this;
+  }
+  with(...ctes) {
+    this._with.push(...ctes);
+    return this;
+  }
   returning(...columns) {
     this._returning = columns.length > 0 ? columns : ["*"];
     return this;
@@ -637,6 +666,17 @@ class InsertBuilder {
     }
     const columnsStr = keys.map((k) => `"${tConfig.columns[k]?.name ?? k}"`).join(", ");
     const params = [];
+    let prefix = "";
+    if (this._with.length > 0) {
+      const cteStrs = [];
+      for (const cte of this._with) {
+        const chunk = cte.query.toSQL();
+        const offset = params.length;
+        params.push(...chunk.params);
+        cteStrs.push(`"${cte.alias}" AS (${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)})`);
+      }
+      prefix = `WITH ${cteStrs.join(", ")} `;
+    }
     const valuesStrs = this._values.map((v) => {
       const vals = keys.map((k) => {
         const val = v[k];
@@ -680,6 +720,52 @@ class InsertBuilder {
         query += " " + this._onConflict.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
         params.push(...this._onConflict.params);
       }
+    } else if (this._onConflictUpdateConfig) {
+      const config = this._onConflictUpdateConfig;
+      const targets = Array.isArray(config.target) ? config.target : [config.target];
+      const targetStrs = [];
+      for (const t of targets) {
+        if (typeof t === "string") {
+          targetStrs.push(`"${tConfig.columns[t]?.name ?? t}"`);
+        } else {
+          const offset = params.length;
+          targetStrs.push(t.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`));
+          params.push(...t.params);
+        }
+      }
+      const setEntries = Object.entries(config.set);
+      if (setEntries.length === 0)
+        throw new Error("InsertBuilder: onConflictDoUpdate requires 'set' fields");
+      const setClauses = setEntries.map(([key, value]) => {
+        const dbCol = tConfig.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 = tConfig.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}`;
+      });
+      query += ` ON CONFLICT (${targetStrs.join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
     }
     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(", "));
@@ -687,10 +773,10 @@ class InsertBuilder {
     if (this._comment) {
       query += ` /* ${this._comment.replace(/\*\//g, "")} */`;
     }
-    return { sql: query, params };
+    return { sql: prefix + query, params };
   }
 }
-// ../bungres-orm/src/builders/select.ts
+
 class SelectBuilder {
   _table;
   _executor;
@@ -703,6 +789,8 @@ class SelectBuilder {
   _select;
   _selection;
   _joins = [];
+  _with = [];
+  _setOperations = [];
   _comment;
   constructor(table2, executor, selection) {
     this._table = table2;
@@ -713,12 +801,35 @@ class SelectBuilder {
     return this._executor.execute(this).then(onfulfilled, onrejected);
   }
   async single() {
+    if (this._limit === undefined) {
+      this.limit(1);
+    }
     return this._executor.executeSingle(this);
   }
   select(...columns) {
     this._select = columns;
     return this;
   }
+  with(...ctes) {
+    this._with.push(...ctes);
+    return this;
+  }
+  union(other) {
+    this._setOperations.push({ type: "UNION", builder: other });
+    return this;
+  }
+  unionAll(other) {
+    this._setOperations.push({ type: "UNION ALL", builder: other });
+    return this;
+  }
+  intersect(other) {
+    this._setOperations.push({ type: "INTERSECT", builder: other });
+    return this;
+  }
+  except(other) {
+    this._setOperations.push({ type: "EXCEPT", builder: other });
+    return this;
+  }
   comment(tag) {
     this._comment = tag;
     return this;
@@ -821,7 +932,23 @@ class SelectBuilder {
       }).join(", ");
     } else {
       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(", ");
+      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 = "";
+    if (this._with.length > 0) {
+      const cteStrs = [];
+      for (const cte of this._with) {
+        const chunk = cte.query.toSQL();
+        const offset = params.length;
+        params.push(...chunk.params);
+        cteStrs.push(`"${cte.alias}" AS (${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)})`);
+      }
+      prefix = `WITH ${cteStrs.join(", ")} `;
     }
     let query = `SELECT ${cols} FROM ${getTableConfig(this._table).qualifiedName}`;
     if (this._joins.length > 0) {
@@ -881,10 +1008,18 @@ class SelectBuilder {
       params.push(this._offset);
       query += ` OFFSET $${params.length}`;
     }
+    if (this._setOperations.length > 0) {
+      for (const op of this._setOperations) {
+        const chunk = op.builder.toSQL();
+        const offset = params.length;
+        params.push(...chunk.params);
+        query += ` ${op.type} ${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)}`;
+      }
+    }
     if (this._comment) {
       query += ` /* ${this._comment.replace(/\*\//g, "")} */`;
     }
-    return { sql: query, params };
+    return { sql: prefix + query, params };
   }
 }
 
@@ -899,7 +1034,7 @@ class SelectBuilderIntermediate {
     return new SelectBuilder(table2, this._executor, this._selection);
   }
 }
-// ../bungres-orm/src/builders/update.ts
+
 class UpdateBuilder {
   _table;
   _executor;
@@ -907,6 +1042,7 @@ class UpdateBuilder {
   _where = [];
   _returning;
   _comment;
+  _with = [];
   constructor(table2, executor) {
     this._table = table2;
     this._executor = executor;
@@ -929,6 +1065,10 @@ class UpdateBuilder {
     }
     return this;
   }
+  with(...ctes) {
+    this._with.push(...ctes);
+    return this;
+  }
   returning(...columns) {
     this._returning = columns.length > 0 ? columns : ["*"];
     return this;
@@ -943,6 +1083,17 @@ class UpdateBuilder {
       throw new Error("UpdateBuilder: no fields to set");
     }
     const params = [];
+    let prefix = "";
+    if (this._with.length > 0) {
+      const cteStrs = [];
+      for (const cte of this._with) {
+        const chunk = cte.query.toSQL();
+        const offset = params.length;
+        params.push(...chunk.params);
+        cteStrs.push(`"${cte.alias}" AS (${chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`)})`);
+      }
+      prefix = `WITH ${cteStrs.join(", ")} `;
+    }
     const setClauses = entries.map(([key, value]) => {
       const dbCol = getTableConfig(this._table).columns[key]?.name ?? key;
       if (value && typeof value === "object" && "sql" in value && "params" in value) {
@@ -985,10 +1136,9 @@ class UpdateBuilder {
     if (this._comment) {
       query += ` /* ${this._comment.replace(/\*\//g, "")} */`;
     }
-    return { sql: query, params };
+    return { sql: prefix + query, params };
   }
 }
-// ../bungres-orm/src/builders/relational.ts
 function getPkColumn(tableConfig) {
   if (tableConfig.primaryKeys?.length > 0)
     return tableConfig.primaryKeys[0];
@@ -1246,8 +1396,6 @@ class RelationalQueryBuilder {
     return { sql: sql2, params };
   }
 }
-
-// ../bungres-orm/src/core/db.ts
 function parseDBName(url) {
   try {
     return new URL(url).pathname.slice(1);
@@ -1356,6 +1504,7 @@ class BungresDB {
 
 class BungresTransaction {
   _sql;
+  _savepointCounter = 0;
   constructor(sql2) {
     this._sql = sql2;
   }
@@ -1390,6 +1539,19 @@ class BungresTransaction {
     const result = await this._sql.unsafe(query, params);
     return Array.from(result);
   }
+  async transaction(fn) {
+    this._savepointCounter++;
+    const spName = `sp_${this._savepointCounter}`;
+    await this._sql.unsafe(`SAVEPOINT ${spName}`);
+    try {
+      const result = await fn(this);
+      await this._sql.unsafe(`RELEASE SAVEPOINT ${spName}`);
+      return result;
+    } catch (e) {
+      await this._sql.unsafe(`ROLLBACK TO SAVEPOINT ${spName}`);
+      throw e;
+    }
+  }
 }
 function bungres(config) {
   const db = new BungresDB(config);
@@ -1413,7 +1575,6 @@ function bungres(config) {
   }
   return db;
 }
-// ../bungres-orm/src/ddl.ts
 function generateCreateTable(config, ifNotExists = true) {
   const tableName = config.schema ? `"${config.schema}"."${config.name}"` : `"${config.name}"`;
   const exists = ifNotExists ? " IF NOT EXISTS" : "";
@@ -1423,8 +1584,8 @@ function generateCreateTable(config, ifNotExists = true) {
     columnDefs.push(`PRIMARY KEY (${pkCols})`);
   }
   if (config.checks) {
-    for (const check of config.checks) {
-      columnDefs.push(`CHECK (${check})`);
+    for (const check2 of config.checks) {
+      columnDefs.push(`CHECK (${check2})`);
     }
   }
   let sql2 = `CREATE TABLE${exists} ${tableName} (
@@ -1462,7 +1623,9 @@ function buildColumnDDL(key, col2, tableName) {
   if (col2.unique && !col2.primaryKey) {
     parts.push("UNIQUE");
   }
-  if (col2.defaultFn) {
+  if (col2.generatedAs) {
+    parts.push(`GENERATED ALWAYS AS (${col2.generatedAs}) STORED`);
+  } else if (col2.defaultFn) {
     parts.push(`DEFAULT ${col2.defaultFn}`);
   } else if (col2.defaultValue !== undefined) {
     parts.push(`DEFAULT ${formatDefaultValue(col2.defaultValue, col2.dataType)}`);
@@ -1483,6 +1646,13 @@ function buildColumnDDL(key, col2, tableName) {
   return parts.join(" ");
 }
 function buildType(col2) {
+  if (col2.enumConfig) {
+    return `"${col2.enumConfig.enumName}"`;
+  }
+  if (col2.dataType.endsWith("[]")) {
+    const baseType = buildType({ ...col2, dataType: col2.dataType.slice(0, -2) });
+    return `${baseType}[]`;
+  }
   switch (col2.dataType) {
     case "varchar":
       return col2.length ? `VARCHAR(${col2.length})` : "VARCHAR";
@@ -1517,12 +1687,12 @@ function formatDefaultValue(value, dataType) {
 }
 function buildIndex(table2, idx) {
   const tableName = table2.schema ? `"${table2.schema}"."${table2.name}"` : `"${table2.name}"`;
-  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}` : "";
   const idxName = idx.name ?? `idx_${table2.name}_${idx.columns.join("_")}`;
-  return `CREATE ${unique}INDEX IF NOT EXISTS "${idxName}" ON ${tableName}${using} (${cols})${where};`;
+  return `CREATE ${unique2}INDEX IF NOT EXISTS "${idxName}" ON ${tableName}${using} (${cols})${where};`;
 }
 function generateAddColumn(tableName, schema, key, col2) {
   const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
@@ -1532,6 +1702,38 @@ 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";
+  const inlineSql = inlineParams(view.query.toSQL());
+  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()) {
   const globs = Array.isArray(patterns) ? patterns : [patterns];
@@ -1544,11 +1746,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
+          });
         }
       }
     }
@@ -1558,17 +1776,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)) {
@@ -1577,7 +1845,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}`);
@@ -1587,8 +1855,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));
@@ -1643,11 +1911,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 unique2 = idx.unique ? "UNIQUE " : "";
+        const unique = 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 ${unique2}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`);
+        statements.push(`CREATE ${unique}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`);
         summary.push(`CREATE INDEX ${idxName} ON ${tableName}`);
       }
     }
@@ -1660,6 +1928,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) {
@@ -1687,7 +1968,14 @@ function topoSortConfigs(tables) {
 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;
@@ -1704,9 +1992,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}`);
@@ -1785,7 +2076,7 @@ var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {})
     [CJKT_WIDE_RE, WIDE_WIDTH]
   ];
   let indexPrev = 0;
-  let index2 = 0;
+  let index = 0;
   let length = input.length;
   let lengthExtra = 0;
   let truncationEnabled = false;
@@ -1797,8 +2088,8 @@ var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {})
   let widthExtra = 0;
   outer:
     while (true) {
-      if (unmatchedEnd > unmatchedStart || index2 >= length && index2 > indexPrev) {
-        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index2);
+      if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+        const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
         lengthExtra = 0;
         for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
           const codePoint = char.codePointAt(0) || 0;
@@ -1821,17 +2112,17 @@ var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {})
         }
         unmatchedStart = unmatchedEnd = 0;
       }
-      if (index2 >= length) {
+      if (index >= length) {
         break outer;
       }
       for (let i = 0, l = PARSE_BLOCKS.length;i < l; i++) {
         const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i];
-        BLOCK_RE.lastIndex = index2;
+        BLOCK_RE.lastIndex = index;
         if (BLOCK_RE.test(input)) {
-          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index2, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index2;
+          lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
           widthExtra = lengthExtra * BLOCK_WIDTH;
           if (width + widthExtra > truncationLimit) {
-            truncationIndex = Math.min(truncationIndex, index2 + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+            truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
           }
           if (width + widthExtra > LIMIT) {
             truncationEnabled = true;
@@ -1839,12 +2130,12 @@ var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {})
           }
           width += widthExtra;
           unmatchedStart = indexPrev;
-          unmatchedEnd = index2;
-          index2 = indexPrev = BLOCK_RE.lastIndex;
+          unmatchedEnd = index;
+          index = indexPrev = BLOCK_RE.lastIndex;
           continue outer;
         }
       }
-      index2 += 1;
+      index += 1;
     }
   return {
     width: truncationEnabled ? truncationLimit : width,
@@ -1903,7 +2194,7 @@ var getClosingCode = (openingCode) => {
 };
 var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
 var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
-var wrapWord = (rows, word, columns2) => {
+var wrapWord = (rows, word, columns) => {
   const characters = word[Symbol.iterator]();
   let isInsideEscape = false;
   let isInsideLinkEscape = false;
@@ -1915,7 +2206,7 @@ var wrapWord = (rows, word, columns2) => {
   while (!currentCharacter.done) {
     const character = currentCharacter.value;
     const characterLength = dist_default2(character);
-    if (visible + characterLength <= columns2) {
+    if (visible + characterLength <= columns) {
       rows[rows.length - 1] += character;
     } else {
       rows.push(character);
@@ -1936,7 +2227,7 @@ var wrapWord = (rows, word, columns2) => {
       }
     } else {
       visible += characterLength;
-      if (visible === columns2 && !nextCharacter.done) {
+      if (visible === columns && !nextCharacter.done) {
         rows.push("");
         visible = 0;
       }
@@ -1964,7 +2255,7 @@ var stringVisibleTrimSpacesRight = (string) => {
   }
   return words.slice(0, last).join(" ") + words.slice(last).join("");
 };
-var exec = (string, columns2, options = {}) => {
+var exec = (string, columns, options = {}) => {
   if (options.trim !== false && string.trim() === "") {
     return "";
   }
@@ -1974,8 +2265,8 @@ var exec = (string, columns2, options = {}) => {
   const words = string.split(" ");
   let rows = [""];
   let rowLength = 0;
-  for (let index2 = 0;index2 < words.length; index2++) {
-    const word = words[index2];
+  for (let index = 0;index < words.length; index++) {
+    const word = words[index];
     if (options.trim !== false) {
       const row = rows.at(-1) ?? "";
       const trimmed = row.trimStart();
@@ -1984,8 +2275,8 @@ var exec = (string, columns2, options = {}) => {
         rowLength = dist_default2(trimmed);
       }
     }
-    if (index2 !== 0) {
-      if (rowLength >= columns2 && (options.wordWrap === false || options.trim === false)) {
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
         rows.push("");
         rowLength = 0;
       }
@@ -1995,28 +2286,28 @@ var exec = (string, columns2, options = {}) => {
       }
     }
     const wordLength = dist_default2(word);
-    if (options.hard && wordLength > columns2) {
-      const remainingColumns = columns2 - rowLength;
-      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns2);
-      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns2);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
       if (breaksStartingNextLine < breaksStartingThisLine) {
         rows.push("");
       }
-      wrapWord(rows, word, columns2);
+      wrapWord(rows, word, columns);
       rowLength = dist_default2(rows.at(-1) ?? "");
       continue;
     }
-    if (rowLength + wordLength > columns2 && rowLength && wordLength) {
-      if (options.wordWrap === false && rowLength < columns2) {
-        wrapWord(rows, word, columns2);
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
         rowLength = dist_default2(rows.at(-1) ?? "");
         continue;
       }
       rows.push("");
       rowLength = 0;
     }
-    if (rowLength + wordLength > columns2 && options.wordWrap === false) {
-      wrapWord(rows, word, columns2);
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
       rowLength = dist_default2(rows.at(-1) ?? "");
       continue;
     }
@@ -2073,8 +2364,8 @@ var exec = (string, columns2, options = {}) => {
   return returnValue;
 };
 var CRLF_OR_LF = /\r?\n/;
-function wrapAnsi(string, columns2, options) {
-  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns2, options)).join(`
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join(`
 `);
 }
 
@@ -3117,11 +3408,29 @@ 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 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] = s2.config;
+      }
     }
-    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.");
@@ -3194,19 +3503,46 @@ 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] = s2.config;
+    }
+  }
+  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;
       }
     }
@@ -3226,17 +3562,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) {
@@ -3398,7 +3747,7 @@ ${upContent}
 // src/commands/pull.ts
 import { resolve as resolve5, join as join5 } from "path";
 async function introspectDb(sql2, dbSchema) {
-  const columns2 = await sql2.unsafe(`SELECT
+  const columns = await sql2.unsafe(`SELECT
       c.table_name,
       c.column_name,
       c.data_type,
@@ -3432,7 +3781,7 @@ async function introspectDb(sql2, dbSchema) {
   const indexes = await sql2.unsafe(`SELECT tablename, indexname, indexdef
      FROM pg_indexes
      WHERE schemaname = $1`, [dbSchema]);
-  return groupByTable(columns2, constraints, indexes);
+  return groupByTable(columns, constraints, indexes);
 }
 async function runPull(config) {
   console.log("@bungres/kit pull: introspecting database...");
@@ -3455,9 +3804,9 @@ async function runPull(config) {
     await sql2.end();
   }
 }
-function groupByTable(columns2, constraints, indexes) {
+function groupByTable(columns, constraints, indexes) {
   const map = new Map;
-  for (const col2 of columns2) {
+  for (const col2 of columns) {
     if (!map.has(col2.table_name)) {
       map.set(col2.table_name, {
         tableName: col2.table_name,
@@ -3493,19 +3842,18 @@ 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}", {`);
+    lines.push(`export const ${varName} = pgTable("${table2.tableName}", {`);
     for (const col2 of table2.columns) {
       const colExpr = buildColumnExpression(col2);
       lines.push(`  ${toCamelCase(col2.name)}: ${colExpr},`);
@@ -3586,11 +3934,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;
@@ -3636,14 +3986,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";
 }
@@ -3714,9 +4064,12 @@ async function runDrop(config, opts = {}) {
   const s = spinner();
   s.start("Loading schemas...");
   const schemas = await loadSchemas(config.schema);
-  if (schemas.length === 0) {
+  const tableSchemas = schemas.filter((s2) => s2.type === "table");
+  const enumSchemas = schemas.filter((s2) => s2.type === "enum");
+  const viewSchemas = schemas.filter((s2) => s2.type === "view");
+  if (tableSchemas.length === 0 && enumSchemas.length === 0 && viewSchemas.length === 0) {
     s.stop("No schemas found.");
-    log.warn(import_picocolors5.default.yellow("No table definitions found in schema files."));
+    log.warn(import_picocolors5.default.yellow("No definitions found in schema files."));
     outro("Failed.");
     return;
   }
@@ -3738,25 +4091,31 @@ 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 tablesToDrop = tableSchemas.filter((sch) => existingTableNames.has(sch.config.name));
+    if (tablesToDrop.length === 0 && enumSchemas.length === 0 && viewSchemas.length === 0 && !migrationTableExists && !pushTableExists) {
       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 (they either don't exist or were already dropped)."));
       outro("Done.");
       return;
     }
     ms.stop("Database check complete.");
-    const tableNamesToPrint = tablesToDrop.map((sch) => (sch.config.schema ? sch.config.schema + "." : "") + sch.config.name);
+    const namesToPrint = tablesToDrop.map((sch) => (sch.config.schema ? sch.config.schema + "." : "") + sch.config.name + " (table)");
+    for (const v of viewSchemas) {
+      namesToPrint.push(`${v.config.name} (view)`);
+    }
+    for (const e of enumSchemas) {
+      namesToPrint.push(`${e.enumName} (enum)`);
+    }
     if (migrationTableExists) {
-      tableNamesToPrint.push(`${config.migrationsSchema}.${config.migrationsTable}`);
+      namesToPrint.push(`${config.migrationsSchema}.${config.migrationsTable} (table)`);
     }
     if (pushTableExists) {
-      tableNamesToPrint.push(`${config.migrationsSchema}.__bungres_push`);
+      namesToPrint.push(`${config.migrationsSchema}.__bungres_push (table)`);
     }
     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.message(import_picocolors5.default.bold(import_picocolors5.default.red("This will drop the following items and ALL their data:")));
+      for (const name of namesToPrint) {
         log.info(import_picocolors5.default.yellow(`  - ${name}`));
       }
       const confirm2 = await confirm({
@@ -3770,11 +4129,22 @@ async function runDrop(config, opts = {}) {
     }
     const exSpinner = spinner();
     exSpinner.start("Dropping tables...");
+    for (const entry of viewSchemas) {
+      const isMat = entry.config.materialized ? "MATERIALIZED VIEW" : "VIEW";
+      const ddl = `DROP ${isMat} IF EXISTS "${entry.config.name}" CASCADE;`;
+      await sql2.unsafe(ddl);
+      log.step(import_picocolors5.default.gray(`Dropped ${entry.config.name}`));
+    }
     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}`));
     }
+    for (const entry of enumSchemas) {
+      const ddl = `DROP TYPE IF EXISTS "${entry.enumName}" CASCADE;`;
+      await sql2.unsafe(ddl);
+      log.step(import_picocolors5.default.gray(`Dropped ${entry.enumName}`));
+    }
     if (migrationTableExists) {
       const qualifiedMigTable = `"${config.migrationsSchema}"."${config.migrationsTable}"`;
       await sql2.unsafe(`DROP TABLE IF EXISTS ${qualifiedMigTable} CASCADE`);
@@ -3784,7 +4154,7 @@ async function runDrop(config, opts = {}) {
       await sql2.unsafe(`DROP TABLE IF EXISTS "${config.migrationsSchema}"."__bungres_push" CASCADE`);
       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) {
     log.error(import_picocolors5.default.red(`Drop failed: ${err.message}`));