@bungres/kit 0.1.0

package/dist/cli.js

@@ -0,0 +1,2435 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/config.ts
+import { resolve, join } from "path";
+var CONFIG_FILES = [
+  "bungres.config.ts",
+  "bungres.config.js",
+  "bungres.config.mts",
+  "bungres.config.mjs"
+];
+async function loadConfig(cwd = process.cwd()) {
+  let userConfig = {};
+  for (const file of CONFIG_FILES) {
+    const configPath = join(cwd, file);
+    if (await Bun.file(configPath).exists()) {
+      const mod = await import(resolve(configPath));
+      userConfig = mod.default ?? mod;
+      break;
+    }
+  }
+  const dbUrl = userConfig.dbCredentials?.url ?? process.env["DATABASE_URL"] ?? process.env["POSTGRES_URL"] ?? "";
+  if (!dbUrl) {
+    console.error(`bungres: No database URL found.
+  Add dbCredentials.url to bungres.config.ts  or set DATABASE_URL.`);
+    process.exit(1);
+  }
+  const out = userConfig.out ?? "./migrations";
+  return {
+    schema: userConfig.schema ?? "src/db/schema/**/*.ts",
+    seed: userConfig.seed ?? "src/db/seed.ts",
+    out,
+    dbUrl,
+    dbSchema: userConfig.dbSchema ?? "public",
+    migrationsDir: out,
+    outDir: "./src/db/generated",
+    verbose: userConfig.verbose ?? false
+  };
+}
+
+// src/commands/push.ts
+import * as fs from "fs";
+
+// ../bungres-orm/src/table.ts
+var TableConfigSymbol = Symbol.for("BungresTableConfig");
+function getTableConfig(table) {
+  return table[TableConfigSymbol];
+}
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function createTableFactory(casing) {
+  return function(name, columns, extra) {
+    const columnConfigs = Object.fromEntries(Object.entries(columns).map(([key, config2]) => {
+      const c = { ...config2 };
+      if (!c.name) {
+        if (casing === "snake") {
+          c.name = camelToSnakeCase(key);
+        } else {
+          c.name = key;
+        }
+      }
+      return [key, c];
+    }));
+    const schema = extra?.schema;
+    const qualifiedName = schema ? `"${schema}"."${name}"` : `"${name}"`;
+    const tableObj = {
+      [TableConfigSymbol]: {
+        name,
+        schema,
+        columns: columnConfigs,
+        indexes: extra?.indexes ?? [],
+        checks: extra?.checks ?? [],
+        primaryKeys: extra?.primaryKeys ?? [],
+        qualifiedName
+      }
+    };
+    return Object.assign(tableObj, columnConfigs);
+  };
+}
+var table = createTableFactory("none");
+var snakeCase = { table: createTableFactory("snake") };
+var camelCase = { table: createTableFactory("camel") };
+// ../bungres-orm/src/column.ts
+function buildColumn(dataType, nameOrOpts, opts) {
+  let name = "";
+  let options = opts;
+  if (typeof nameOrOpts === "string") {
+    name = nameOrOpts;
+  } else if (nameOrOpts !== undefined) {
+    options = nameOrOpts;
+  }
+  const isPrimary = options?.primaryKey ?? false;
+  const isNotNull = isPrimary || (options?.notNull ?? false);
+  let defaultFn = options?.defaultRaw;
+  if (isPrimary && dataType === "uuid" && !defaultFn) {
+    defaultFn = "gen_random_uuid()";
+  }
+  const config2 = {
+    name,
+    dataType,
+    notNull: isNotNull,
+    primaryKey: isPrimary,
+    unique: options?.unique ?? false,
+    defaultValue: options?.default,
+    ...defaultFn !== undefined ? { defaultFn } : {},
+    ...options?.references !== undefined ? { references: options.references } : {},
+    ...options?.check !== undefined ? { check: options.check } : {}
+  };
+  return Object.assign(config2, {
+    as(alias) {
+      return Object.assign({}, this, { alias });
+    }
+  });
+}
+var col = (dataType) => (nameOrOpts, opts) => buildColumn(dataType, nameOrOpts, opts);
+var integer = col("integer");
+var bigint = col("bigint");
+var smallint = col("smallint");
+var boolean = col("boolean");
+var real = col("real");
+var doublePrecision = col("double precision");
+var numeric = col("numeric");
+var decimal = col("decimal");
+var json = col("json");
+var jsonb = col("jsonb");
+var timestamp = col("timestamp");
+var timestamptz = col("timestamptz");
+var date = col("date");
+var time = col("time");
+var timetz = col("timetz");
+var uuid = col("uuid");
+var bytea = col("bytea");
+var interval = col("interval");
+var inet = col("inet");
+var cidr = col("cidr");
+var macaddr = col("macaddr");
+// ../bungres-orm/src/sql.ts
+function sqlJoin(chunks, separator = ", ") {
+  const params = [];
+  const parts = [];
+  for (const chunk of chunks) {
+    const offset = params.length;
+    parts.push(chunk.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`));
+    params.push(...chunk.params);
+  }
+  return { sql: parts.join(separator), params };
+}
+// ../bungres-orm/src/query.ts
+class SelectBuilder {
+  _table;
+  _executor;
+  _where = [];
+  _orderBy = [];
+  _limit;
+  _offset;
+  _select;
+  _selection;
+  _joins = [];
+  _comment;
+  constructor(table2, executor, selection) {
+    this._table = table2;
+    this._executor = executor;
+    this._selection = selection;
+  }
+  then(onfulfilled, onrejected) {
+    return this._executor.execute(this).then(onfulfilled, onrejected);
+  }
+  select(...columns) {
+    this._select = columns;
+    return this;
+  }
+  comment(tag) {
+    this._comment = tag;
+    return this;
+  }
+  where(condition) {
+    this._where.push(condition);
+    return this;
+  }
+  orderBy(column, dir = "asc") {
+    this._orderBy.push({ column: typeof column === "string" ? column : column.name, dir });
+    return this;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  offset(n) {
+    this._offset = n;
+    return this;
+  }
+  join(rawClause) {
+    this._joins.push(rawClause);
+    return this;
+  }
+  toSQL() {
+    let cols = "";
+    if (this._selection) {
+      cols = Object.entries(this._selection).map(([alias, col2]) => `"${col2.name}" AS "${alias}"`).join(", ");
+    } else if (this._select && this._select.length > 0) {
+      cols = this._select.map((c) => {
+        if (typeof c === "string") {
+          return `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`;
+        }
+        return `"${c.name}" AS "${c.alias || c.name}"`;
+      }).join(", ");
+    } else {
+      cols = Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ");
+    }
+    let query = `SELECT ${cols} FROM ${getTableConfig(this._table).qualifiedName}`;
+    if (this._joins.length > 0) {
+      query += " " + this._joins.join(" ");
+    }
+    const params = [];
+    if (this._where.length > 0) {
+      const combined = sqlJoin(this._where, " AND ");
+      const offset = 0;
+      query += " WHERE " + combined.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...combined.params);
+    }
+    if (this._orderBy.length > 0) {
+      query += " ORDER BY " + this._orderBy.map((o) => {
+        const dbCol = getTableConfig(this._table).columns[o.column]?.name ?? o.column;
+        return `"${dbCol}" ${o.dir.toUpperCase()}`;
+      }).join(", ");
+    }
+    if (this._limit !== undefined) {
+      params.push(this._limit);
+      query += ` LIMIT $${params.length}`;
+    }
+    if (this._offset !== undefined) {
+      params.push(this._offset);
+      query += ` OFFSET $${params.length}`;
+    }
+    if (this._comment) {
+      query += ` /* ${this._comment} */`;
+    }
+    return { sql: query, params };
+  }
+}
+
+class SelectBuilderIntermediate {
+  _executor;
+  _selection;
+  constructor(_executor, _selection) {
+    this._executor = _executor;
+    this._selection = _selection;
+  }
+  from(table2) {
+    return new SelectBuilder(table2, this._executor, this._selection);
+  }
+}
+
+class InsertBuilder {
+  _table;
+  _executor;
+  _values = [];
+  _onConflict;
+  _returning;
+  _comment;
+  constructor(table2, executor) {
+    this._table = table2;
+    this._executor = executor;
+  }
+  then(onfulfilled, onrejected) {
+    return this._executor.execute(this).then(onfulfilled, onrejected);
+  }
+  values(data) {
+    const rows = Array.isArray(data) ? data : [data];
+    this._values.push(...rows);
+    return this;
+  }
+  onConflictDoNothing() {
+    this._onConflict = "do nothing";
+    return this;
+  }
+  onConflictDoUpdate(clause) {
+    this._onConflict = clause;
+    return this;
+  }
+  returning(...columns) {
+    this._returning = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  comment(tag) {
+    this._comment = tag;
+    return this;
+  }
+  toSQL() {
+    if (this._values.length === 0) {
+      throw new Error("InsertBuilder: no values provided");
+    }
+    const keys = Array.from(new Set(this._values.flatMap((v) => Object.keys(v))));
+    const params = [];
+    const rowPlaceholders = [];
+    for (const row of this._values) {
+      const placeholders = [];
+      for (const key of keys) {
+        params.push(row[key] ?? null);
+        placeholders.push(`$${params.length}`);
+      }
+      rowPlaceholders.push(`(${placeholders.join(", ")})`);
+    }
+    const colList = keys.map((k) => `"${getTableConfig(this._table).columns[k]?.name ?? k}"`).join(", ");
+    let query = `INSERT INTO ${getTableConfig(this._table).qualifiedName} (${colList}) VALUES ${rowPlaceholders.join(", ")}`;
+    if (this._onConflict === "do nothing") {
+      query += " ON CONFLICT DO NOTHING";
+    } else if (this._onConflict && typeof this._onConflict === "object") {
+      const offset = params.length;
+      query += " ON CONFLICT " + this._onConflict.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...this._onConflict.params);
+    }
+    if (this._returning) {
+      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
+    }
+    return { sql: query, params };
+  }
+}
+
+class UpdateBuilder {
+  _table;
+  _executor;
+  _set = {};
+  _where = [];
+  _returning;
+  _comment;
+  constructor(table2, executor) {
+    this._table = table2;
+    this._executor = executor;
+  }
+  then(onfulfilled, onrejected) {
+    return this._executor.execute(this).then(onfulfilled, onrejected);
+  }
+  set(data) {
+    this._set = { ...this._set, ...data };
+    return this;
+  }
+  where(condition) {
+    this._where.push(condition);
+    return this;
+  }
+  returning(...columns) {
+    this._returning = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  comment(tag) {
+    this._comment = tag;
+    return this;
+  }
+  toSQL() {
+    const entries = Object.entries(this._set);
+    if (entries.length === 0) {
+      throw new Error("UpdateBuilder: no fields to set");
+    }
+    const params = [];
+    const setClauses = entries.map(([key, value]) => {
+      params.push(value);
+      const dbCol = getTableConfig(this._table).columns[key]?.name ?? key;
+      return `"${dbCol}" = $${params.length}`;
+    });
+    let query = `UPDATE ${getTableConfig(this._table).qualifiedName} SET ${setClauses.join(", ")}`;
+    if (this._where.length > 0) {
+      const combined = sqlJoin(this._where, " AND ");
+      const offset = params.length;
+      query += " WHERE " + combined.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...combined.params);
+    }
+    if (this._returning) {
+      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
+    }
+    return { sql: query, params };
+  }
+}
+
+class DeleteBuilder {
+  _table;
+  _executor;
+  _where = [];
+  _returning;
+  _comment;
+  constructor(table2, executor) {
+    this._table = table2;
+    this._executor = executor;
+  }
+  then(onfulfilled, onrejected) {
+    return this._executor.execute(this).then(onfulfilled, onrejected);
+  }
+  where(condition) {
+    this._where.push(condition);
+    return this;
+  }
+  returning(...columns) {
+    this._returning = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  comment(tag) {
+    this._comment = tag;
+    return this;
+  }
+  toSQL() {
+    let query = `DELETE FROM ${getTableConfig(this._table).qualifiedName}`;
+    const params = [];
+    if (this._where.length > 0) {
+      const combined = sqlJoin(this._where, " AND ");
+      query += " WHERE " + combined.sql;
+      params.push(...combined.params);
+    }
+    if (this._returning) {
+      query += " RETURNING " + (this._returning[0] === "*" ? Object.keys(getTableConfig(this._table).columns).map((c) => `"${getTableConfig(this._table).columns[c].name}" AS "${c}"`).join(", ") : this._returning.map((c) => `"${getTableConfig(this._table).columns[c]?.name ?? c}" AS "${c}"`).join(", "));
+    }
+    return { sql: query, params };
+  }
+}
+// ../bungres-orm/src/relational.ts
+var _relationsCache = new WeakMap;
+
+class RelationalQueryBuilder {
+  _executor;
+  _schema;
+  _tableName;
+  _args;
+  constructor(_executor, _schema, _tableName, args) {
+    this._executor = _executor;
+    this._schema = _schema;
+    this._tableName = _tableName;
+    this._args = args ?? {};
+  }
+  where(condition) {
+    return new RelationalQueryBuilder(this._executor, this._schema, this._tableName, {
+      ...this._args,
+      where: condition
+    });
+  }
+  limit(n) {
+    return new RelationalQueryBuilder(this._executor, this._schema, this._tableName, {
+      ...this._args,
+      limit: n
+    });
+  }
+  offset(n) {
+    return new RelationalQueryBuilder(this._executor, this._schema, this._tableName, {
+      ...this._args,
+      offset: n
+    });
+  }
+  orderBy(order) {
+    return new RelationalQueryBuilder(this._executor, this._schema, this._tableName, {
+      ...this._args,
+      orderBy: order
+    });
+  }
+  select(...fields) {
+    const columnsConfig = Object.fromEntries(fields.map((f) => [f, true]));
+    return new RelationalQueryBuilder(this._executor, this._schema, this._tableName, {
+      ...this._args,
+      columns: {
+        ...this._args.columns || {},
+        ...columnsConfig
+      }
+    });
+  }
+  with(relation, callback) {
+    const relations = this._getRuntimeRelations(this._tableName);
+    const rel = relations.ones[relation] || relations.manys[relation] || relations.manyToManys[relation];
+    if (!rel)
+      throw new Error(`Relation ${String(relation)} not found on table ${String(this._tableName)}`);
+    const subQb = new RelationalQueryBuilder(this._executor, this._schema, rel.targetTable);
+    const configuredSubQb = callback ? callback(subQb) : subQb;
+    const newArgs = { ...this._args };
+    newArgs.with = { ...newArgs.with || {}, [relation]: callback ? configuredSubQb._args : true };
+    return new RelationalQueryBuilder(this._executor, this._schema, this._tableName, newArgs);
+  }
+  async findMany(args) {
+    const finalArgs = { ...this._args, ...args ?? {} };
+    const chunk = this.buildSQL(finalArgs);
+    const rows = await this._executor.execute(chunk);
+    return rows.map((r) => typeof r._data === "string" ? JSON.parse(r._data) : r._data);
+  }
+  async findFirst(args) {
+    const finalArgs = { ...this._args, ...args ?? {}, limit: 1 };
+    const res = await this.findMany(finalArgs);
+    return res[0] ?? null;
+  }
+  _getRuntimeRelations(tableName) {
+    let schemaCache = _relationsCache.get(this._schema);
+    if (!schemaCache) {
+      schemaCache = new Map;
+      _relationsCache.set(this._schema, schemaCache);
+    }
+    let cached = schemaCache.get(tableName);
+    if (cached)
+      return cached;
+    const table2 = this._schema[tableName];
+    const tConfig = table2[TableConfigSymbol];
+    const ones = {};
+    const manys = {};
+    const manyToManys = {};
+    for (const [colName, col2] of Object.entries(tConfig.columns)) {
+      if (col2.references) {
+        const ref = col2.references;
+        const relName = ref.relationName || ref.table;
+        ones[relName] = { targetTable: ref.table, sourceColumn: col2.name };
+      }
+    }
+    for (const [otherName, otherTable] of Object.entries(this._schema)) {
+      const otherConfig = otherTable[TableConfigSymbol];
+      for (const [colName, col2] of Object.entries(otherConfig.columns)) {
+        if (col2.references && col2.references.table === tableName) {
+          const ref = col2.references;
+          const backRelName = ref.backRelationName || otherName;
+          manys[backRelName] = { targetTable: otherName, targetColumn: col2.name };
+        }
+      }
+    }
+    for (const [junctionName, junctionTable] of Object.entries(this._schema)) {
+      const junctionConfig = junctionTable[TableConfigSymbol];
+      const refs = Object.entries(junctionConfig.columns).filter(([_, c]) => c.references);
+      const toThis = refs.find(([_, c]) => c.references.table === tableName);
+      if (toThis) {
+        for (const [otherColName, otherCol] of refs) {
+          if (otherCol === toThis[1])
+            continue;
+          const ref = otherCol.references;
+          const targetTableName = ref.table;
+          const relName = toThis[1].references.backRelationName || targetTableName;
+          manyToManys[relName] = {
+            junctionTable: junctionName,
+            targetTable: targetTableName,
+            joinSourceColumn: toThis[1].name,
+            joinTargetColumn: otherCol.name
+          };
+        }
+      }
+    }
+    const result2 = { ones, manys, manyToManys };
+    schemaCache.set(tableName, result2);
+    return result2;
+  }
+  _buildSelectJson(tableName, args, alias, params, parentAlias, joinCondition, extraJoin) {
+    const tableConfig = this._schema[tableName][TableConfigSymbol];
+    const relations = this._getRuntimeRelations(tableName);
+    const withArgs = args.with || {};
+    const jsonFields = [];
+    const lateralJoins = [];
+    const columnsConfig = args.columns;
+    for (const [colKey, colConfig] of Object.entries(tableConfig.columns)) {
+      if (columnsConfig) {
+        if (columnsConfig[colKey] !== true) {
+          continue;
+        }
+      }
+      jsonFields.push(`'${colKey}', "${alias}"."${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 joinCond = `"${subAlias}"."${this._schema[rel.targetTable][TableConfigSymbol].columns.id?.name ?? "id"}" = "${alias}"."${rel.sourceColumn}"`;
+        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias, 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 joinCond = `"${subAlias}"."${rel.targetColumn}" = "${alias}"."${tableConfig.columns.id?.name ?? "id"}"`;
+        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias, joinCond);
+        const aggAlias = `${subAlias}_agg`;
+        const aggSql = `
+          SELECT COALESCE(json_agg(_sub.obj), '[]'::json)
+          FROM (
+            SELECT ${subQuery.sql} AS obj
+            ${subQuery.from}
+          ) _sub
+        `;
+        jsonFields.push(`'${relKey}', (${aggSql})`);
+      } else if (relations.manyToManys[relKey]) {
+        const rel = relations.manyToManys[relKey];
+        const subAlias = `${alias}_${relKey}`;
+        const junctionAlias = `${alias}_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}"."${targetTableConfig.columns.id?.name ?? "id"}"
+        `;
+        const whereExtra = `"${junctionAlias}"."${rel.joinSourceColumn}" = "${alias}"."${tableConfig.columns.id?.name ?? "id"}"`;
+        const subQuery = this._buildSelectJson(rel.targetTable, rArgs, subAlias, params, alias, whereExtra, fromExtra);
+        const aggSql = `
+          SELECT COALESCE(json_agg(_sub.obj), '[]'::json)
+          FROM (
+            SELECT ${subQuery.sql} AS obj
+            ${subQuery.from}
+          ) _sub
+        `;
+        jsonFields.push(`'${relKey}', (${aggSql})`);
+      }
+    }
+    let selectSql = `json_build_object(${jsonFields.join(", ")})`;
+    let fromSql = `FROM ${tableConfig.qualifiedName} AS "${alias}"`;
+    if (extraJoin) {
+      fromSql += ` ${extraJoin}`;
+    }
+    if (joinCondition) {
+      fromSql += ` WHERE ${joinCondition}`;
+    }
+    if (args.where && args.where.sql) {
+      const offset = params.length;
+      fromSql += (joinCondition ? " AND " : " WHERE ") + args.where.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+      params.push(...args.where.params);
+    }
+    if (args.orderBy) {
+      if (typeof args.orderBy === "string") {
+        fromSql += ` ORDER BY ${args.orderBy}`;
+      } else if (args.orderBy.sql) {
+        const offset = params.length;
+        fromSql += ` ORDER BY ` + args.orderBy.sql.replace(/\$(\d+)/g, (_, n) => `$${parseInt(n) + offset}`);
+        params.push(...args.orderBy.params);
+      }
+    }
+    if (args.limit !== undefined) {
+      params.push(args.limit);
+      fromSql += ` LIMIT $${params.length}`;
+    }
+    if (args.offset !== undefined) {
+      params.push(args.offset);
+      fromSql += ` OFFSET $${params.length}`;
+    }
+    return { sql: selectSql, from: fromSql };
+  }
+  buildSQL(args) {
+    const params = [];
+    const rootAlias = "root";
+    const subQuery = this._buildSelectJson(this._tableName, args, rootAlias, params);
+    const sql2 = `SELECT ${subQuery.sql} AS _data ${subQuery.from}`;
+    return { sql: sql2, params };
+  }
+}
+
+// ../bungres-orm/src/db.ts
+function parseDBName(url) {
+  try {
+    return new URL(url).pathname.slice(1);
+  } catch {
+    return "";
+  }
+}
+function maintenanceUrl(url) {
+  try {
+    const u = new URL(url);
+    u.pathname = "/postgres";
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+async function ensureDatabase(url) {
+  const dbName = parseDBName(url);
+  if (!dbName || dbName === "postgres")
+    return;
+  const maintenance = new Bun.SQL(maintenanceUrl(url), { max: 1 });
+  try {
+    const rows = await maintenance.unsafe(`SELECT 1 FROM pg_database WHERE datname = $1`, [dbName]);
+    if (rows.length === 0) {
+      if (!/^[a-zA-Z_][a-zA-Z0-9_$]*$/.test(dbName)) {
+        throw new Error(`Invalid database name: "${dbName}"`);
+      }
+      await maintenance.unsafe(`CREATE DATABASE "${dbName}"`);
+      console.log(`bungres: created database "${dbName}"`);
+    }
+  } finally {
+    await maintenance.end();
+  }
+}
+
+class BungresDB {
+  _sql;
+  _config;
+  _ready = null;
+  constructor(config2) {
+    const url = typeof config2 === "string" ? config2 : config2.url;
+    const opts = typeof config2 === "object" ? config2 : { url };
+    this._config = { autoCreateDB: true, ...opts };
+    this._sql = new Bun.SQL(url, {
+      max: opts.max ?? 10,
+      idleTimeout: opts.idleTimeout ?? 1e4,
+      ...opts.maxLifetime !== undefined && { maxLifetime: opts.maxLifetime },
+      ...opts.tls !== undefined && { tls: opts.tls }
+    });
+    if (this._config.autoCreateDB !== false) {
+      this._ready = ensureDatabase(url).catch((err) => {
+        console.warn(`bungres: could not auto-create database: ${err.message}`);
+      });
+    }
+  }
+  async ready() {
+    if (this._ready) {
+      await this._ready;
+      this._ready = null;
+    }
+  }
+  select(tableOrFields) {
+    if (tableOrFields) {
+      if (TableConfigSymbol in tableOrFields) {
+        return new SelectBuilder(tableOrFields, this);
+      }
+      return new SelectBuilderIntermediate(this, tableOrFields);
+    }
+    return new SelectBuilderIntermediate(this);
+  }
+  insert(table2) {
+    return new InsertBuilder(table2, this);
+  }
+  update(table2) {
+    return new UpdateBuilder(table2, this);
+  }
+  delete(table2) {
+    return new DeleteBuilder(table2, this);
+  }
+  async execute(builder) {
+    await this.ready();
+    const chunk = "toSQL" in builder ? builder.toSQL() : builder;
+    const result2 = await this._sql.unsafe(chunk.sql, chunk.params);
+    return Array.from(result2);
+  }
+  async executeSingle(builder) {
+    const rows = await this.execute(builder);
+    return rows[0] ?? null;
+  }
+  async raw(query, params = []) {
+    await this.ready();
+    const result2 = await this._sql.unsafe(query, params);
+    return Array.from(result2);
+  }
+  async transaction(fn) {
+    await this.ready();
+    return this._sql.transaction(async (txSql) => {
+      const tx = new BungresTransaction(txSql);
+      return fn(tx);
+    });
+  }
+  async close() {
+    await this._sql.end();
+  }
+}
+
+class BungresTransaction {
+  _sql;
+  constructor(sql2) {
+    this._sql = sql2;
+  }
+  select(tableOrFields) {
+    if (tableOrFields) {
+      if (TableConfigSymbol in tableOrFields) {
+        return new SelectBuilder(tableOrFields, this);
+      }
+      return new SelectBuilderIntermediate(this, tableOrFields);
+    }
+    return new SelectBuilderIntermediate(this);
+  }
+  insert(table2) {
+    return new InsertBuilder(table2, this);
+  }
+  update(table2) {
+    return new UpdateBuilder(table2, this);
+  }
+  delete(table2) {
+    return new DeleteBuilder(table2, this);
+  }
+  async execute(builder) {
+    const chunk = "toSQL" in builder ? builder.toSQL() : builder;
+    const result2 = await this._sql.unsafe(chunk.sql, chunk.params);
+    return Array.from(result2);
+  }
+  async executeSingle(builder) {
+    const rows = await this.execute(builder);
+    return rows[0] ?? null;
+  }
+  async raw(query, params = []) {
+    const result2 = await this._sql.unsafe(query, params);
+    return Array.from(result2);
+  }
+}
+function createDB(config2) {
+  const db2 = new BungresDB(config2);
+  if (typeof config2 === "object" && config2.schema) {
+    const schema = config2.schema;
+    return new Proxy(db2, {
+      get(target, prop) {
+        if (prop in target) {
+          const value = target[prop];
+          if (typeof value === "function") {
+            return value.bind(target);
+          }
+          return value;
+        }
+        if (typeof prop === "string" && prop in schema) {
+          return new RelationalQueryBuilder(target, schema, prop);
+        }
+        return;
+      }
+    });
+  }
+  return db2;
+}
+// ../bungres-orm/src/ddl.ts
+function generateCreateTable(config2, ifNotExists = true) {
+  const tableName = config2.schema ? `"${config2.schema}"."${config2.name}"` : `"${config2.name}"`;
+  const exists = ifNotExists ? " IF NOT EXISTS" : "";
+  const columnDefs = Object.entries(config2.columns).map(([key, col2]) => buildColumnDDL(key, col2, config2.name));
+  if (config2.primaryKeys && config2.primaryKeys.length > 1) {
+    const pkCols = config2.primaryKeys.map((c) => `"${c}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkCols})`);
+  }
+  if (config2.checks) {
+    for (const check of config2.checks) {
+      columnDefs.push(`CHECK (${check})`);
+    }
+  }
+  let sql2 = `CREATE TABLE${exists} ${tableName} (
+  ${columnDefs.join(`,
+  `)}
+);`;
+  if (config2.indexes && config2.indexes.length > 0) {
+    sql2 += `
+
+` + config2.indexes.map((idx) => buildIndex(config2, idx)).join(`
+`);
+  }
+  return sql2;
+}
+function generateAddConstraint(tableName, schema, constraintName, constraintDef) {
+  const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+  return `ALTER TABLE ${tbl} ADD CONSTRAINT "${constraintName}" ${constraintDef};`;
+}
+function generateDropConstraint(tableName, schema, constraintName) {
+  const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+  return `ALTER TABLE ${tbl} DROP CONSTRAINT IF EXISTS "${constraintName}";`;
+}
+function buildColumnDDL(key, col2, tableName) {
+  const name = `"${col2.name || key}"`;
+  let type = buildType(col2);
+  const parts = [`${name} ${type}`];
+  if (col2.primaryKey && !["serial", "bigserial"].includes(col2.dataType)) {
+    parts.push("PRIMARY KEY");
+  } else if (col2.primaryKey) {
+    parts.push("PRIMARY KEY");
+  }
+  if (col2.notNull && !col2.primaryKey && !["serial", "bigserial"].includes(col2.dataType)) {
+    parts.push("NOT NULL");
+  }
+  if (col2.unique && !col2.primaryKey) {
+    parts.push("UNIQUE");
+  }
+  if (col2.defaultFn) {
+    parts.push(`DEFAULT ${col2.defaultFn}`);
+  } else if (col2.defaultValue !== undefined) {
+    parts.push(`DEFAULT ${formatDefaultValue(col2.defaultValue, col2.dataType)}`);
+  }
+  if (col2.references) {
+    const ref = col2.references;
+    const constraintName = `${tableName}_${col2.name || key}_fkey`;
+    let fk = `CONSTRAINT "${constraintName}" REFERENCES "${ref.table}"("${ref.column}")`;
+    if (ref.onDelete)
+      fk += ` ON DELETE ${ref.onDelete.toUpperCase()}`;
+    if (ref.onUpdate)
+      fk += ` ON UPDATE ${ref.onUpdate.toUpperCase()}`;
+    parts.push(fk);
+  }
+  if (col2.check) {
+    parts.push(`CHECK (${col2.check})`);
+  }
+  return parts.join(" ");
+}
+function buildType(col2) {
+  switch (col2.dataType) {
+    case "varchar":
+      return col2.length ? `VARCHAR(${col2.length})` : "VARCHAR";
+    case "char":
+      return col2.length ? `CHAR(${col2.length})` : "CHAR";
+    case "numeric":
+    case "decimal":
+      return col2.dataType.toUpperCase();
+    case "double precision":
+      return "DOUBLE PRECISION";
+    case "timestamptz":
+      return "TIMESTAMP WITH TIME ZONE";
+    case "timetz":
+      return "TIME WITH TIME ZONE";
+    default:
+      return col2.dataType.toUpperCase();
+  }
+}
+function formatDefaultValue(value, dataType) {
+  if (value === null)
+    return "NULL";
+  if (typeof value === "string") {
+    if (dataType === "boolean")
+      return value;
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "number")
+    return String(value);
+  return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+}
+function buildIndex(table2, idx) {
+  const tableName = table2.schema ? `"${table2.schema}"."${table2.name}"` : `"${table2.name}"`;
+  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}` : "";
+  const idxName = idx.name ?? `idx_${table2.name}_${idx.columns.join("_")}`;
+  return `CREATE ${unique}INDEX IF NOT EXISTS "${idxName}" ON ${tableName}${using} (${cols})${where};`;
+}
+function generateAddColumn(tableName, schema, key, col2) {
+  const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+  return `ALTER TABLE ${tbl} ADD COLUMN IF NOT EXISTS ${buildColumnDDL(key, col2, tableName)};`;
+}
+function generateDropColumn(tableName, schema, columnName) {
+  const tbl = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+  return `ALTER TABLE ${tbl} DROP COLUMN IF EXISTS "${columnName}";`;
+}
+// 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 newTableConfigs = [];
+  for (const tableName of nextTables) {
+    if (!prevTables.has(tableName)) {
+      newTableConfigs.push(next[tableName]);
+    }
+  }
+  for (const config2 of topoSortConfigs(newTableConfigs)) {
+    statements.push(generateCreateTable(config2, true));
+    summary.push(`CREATE TABLE ${config2.name}`);
+  }
+  for (const tableName of prevTables) {
+    if (!nextTables.has(tableName)) {
+      const config2 = prev[tableName];
+      const tbl = config2.schema ? `"${config2.schema}"."${tableName}"` : `"${tableName}"`;
+      statements.push(`DROP TABLE IF EXISTS ${tbl};`);
+      summary.push(`DROP TABLE ${tableName}`);
+      warnings.push(`Data loss warning: Table '${tableName}' will be permanently deleted.`);
+    }
+  }
+  for (const tableName of nextTables) {
+    if (!prevTables.has(tableName))
+      continue;
+    const prevConfig = prev[tableName];
+    const nextConfig = next[tableName];
+    const prevCols = prevConfig.columns;
+    const nextCols = nextConfig.columns;
+    const prevColNames = new Set(Object.keys(prevCols));
+    const nextColNames = new Set(Object.keys(nextCols));
+    for (const key of nextColNames) {
+      if (!prevColNames.has(key)) {
+        const col2 = nextCols[key];
+        statements.push(generateAddColumn(tableName, nextConfig.schema, key, col2));
+        summary.push(`ALTER TABLE ${tableName} ADD COLUMN ${col2.name}`);
+      }
+    }
+    for (const key of prevColNames) {
+      if (!nextColNames.has(key)) {
+        const col2 = prevCols[key];
+        statements.push(generateDropColumn(tableName, prevConfig.schema, col2.name));
+        summary.push(`ALTER TABLE ${tableName} DROP COLUMN ${col2.name}`);
+        warnings.push(`Data loss warning: Column '${col2.name}' in table '${tableName}' will be permanently deleted.`);
+      }
+    }
+    for (const key of nextColNames) {
+      if (!prevColNames.has(key))
+        continue;
+      const changes = diffColumn(prevCols[key], nextCols[key]);
+      if (changes.length > 0) {
+        const tbl = nextConfig.schema ? `"${nextConfig.schema}"."${tableName}"` : `"${tableName}"`;
+        for (const change of changes) {
+          statements.push(`ALTER TABLE ${tbl} ${change};`);
+          summary.push(`ALTER TABLE ${tableName} ALTER COLUMN ${nextCols[key].name} (${change})`);
+        }
+      }
+      const prevRef = prevCols[key].references;
+      const nextRef = nextCols[key].references;
+      if (JSON.stringify(prevRef) !== JSON.stringify(nextRef)) {
+        const constraintName = `${tableName}_${nextCols[key].name}_fkey`;
+        if (prevRef) {
+          statements.push(generateDropConstraint(tableName, nextConfig.schema, constraintName));
+          summary.push(`ALTER TABLE ${tableName} DROP CONSTRAINT ${constraintName}`);
+        }
+        if (nextRef) {
+          let fkDef = `FOREIGN KEY ("${nextCols[key].name}") REFERENCES "${nextRef.table}"("${nextRef.column}")`;
+          if (nextRef.onDelete)
+            fkDef += ` ON DELETE ${nextRef.onDelete.toUpperCase()}`;
+          if (nextRef.onUpdate)
+            fkDef += ` ON UPDATE ${nextRef.onUpdate.toUpperCase()}`;
+          statements.push(generateAddConstraint(tableName, nextConfig.schema, constraintName, fkDef));
+          summary.push(`ALTER TABLE ${tableName} ADD CONSTRAINT ${constraintName}`);
+        }
+      }
+    }
+    const prevIdxNames = new Set((prevConfig.indexes ?? []).map((i) => i.name ?? `idx_${tableName}_${i.columns.join("_")}`));
+    for (const idx of nextConfig.indexes ?? []) {
+      const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
+      if (!prevIdxNames.has(idxName)) {
+        const tbl = nextConfig.schema ? `"${nextConfig.schema}"."${tableName}"` : `"${tableName}"`;
+        const unique = idx.unique ? "UNIQUE " : "";
+        const using = idx.using ? ` USING ${idx.using.toUpperCase()}` : "";
+        const cols = idx.columns.map((c) => `"${c}"`).join(", ");
+        const where = idx.where ? ` WHERE ${idx.where}` : "";
+        statements.push(`CREATE ${unique}INDEX IF NOT EXISTS "${idxName}" ON ${tbl}${using} (${cols})${where};`);
+        summary.push(`CREATE INDEX ${idxName} ON ${tableName}`);
+      }
+    }
+    const nextIdxNames = new Set((nextConfig.indexes ?? []).map((i) => i.name ?? `idx_${tableName}_${i.columns.join("_")}`));
+    for (const idx of prevConfig.indexes ?? []) {
+      const idxName = idx.name ?? `idx_${tableName}_${idx.columns.join("_")}`;
+      if (!nextIdxNames.has(idxName)) {
+        statements.push(`DROP INDEX IF EXISTS "${idxName}";`);
+        summary.push(`DROP INDEX ${idxName}`);
+      }
+    }
+  }
+  return { statements, summary, warnings };
+}
+function topoSortConfigs(tables) {
+  const byName = new Map(tables.map((t) => [t.name, t]));
+  const visited = new Set;
+  const result2 = [];
+  function deps(config2) {
+    return Object.values(config2.columns).map((col2) => col2.references?.table).filter((t) => t !== undefined && byName.has(t) && t !== config2.name);
+  }
+  function visit(name) {
+    if (visited.has(name))
+      return;
+    visited.add(name);
+    const config2 = byName.get(name);
+    if (!config2)
+      return;
+    for (const dep of deps(config2))
+      visit(dep);
+    result2.push(config2);
+  }
+  for (const table2 of tables)
+    visit(table2.name);
+  return result2;
+}
+function diffColumn(prev, next) {
+  const changes = [];
+  const col2 = `"${next.name}"`;
+  if (prev.dataType !== next.dataType) {
+    changes.push(`ALTER COLUMN ${col2} TYPE ${next.dataType.toUpperCase()} USING ${col2}::${next.dataType}`);
+  }
+  if (!prev.notNull && next.notNull) {
+    changes.push(`ALTER COLUMN ${col2} SET NOT NULL`);
+  }
+  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 (nextDef !== undefined) {
+      const val = next.defaultFn ?? formatDefault(next.defaultValue, next.dataType);
+      changes.push(`ALTER COLUMN ${col2} SET DEFAULT ${val}`);
+    } else {
+      changes.push(`ALTER COLUMN ${col2} DROP DEFAULT`);
+    }
+  }
+  return changes;
+}
+function formatDefault(value, dataType) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "string") {
+    if (dataType === "boolean")
+      return value;
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  return `'${JSON.stringify(value)}'`;
+}
+
+// src/schema-loader.ts
+import { resolve as resolve2, join as join2 } from "path";
+async function loadSchemas(patterns, cwd = process.cwd()) {
+  const globs = Array.isArray(patterns) ? patterns : [patterns];
+  const entries = [];
+  for (const pattern of globs) {
+    const glob = new Bun.Glob(pattern);
+    for await (const file of glob.scan({ cwd, absolute: false })) {
+      const absPath = resolve2(join2(cwd, file));
+      const mod = await import(absPath);
+      for (const [exportName, value] of Object.entries(mod)) {
+        if (isTable(value)) {
+          entries.push({
+            exportName,
+            config: value[TableConfigSymbol],
+            table: value,
+            filePath: absPath
+          });
+        }
+      }
+    }
+  }
+  return entries;
+}
+function isTable(value) {
+  return typeof value === "object" && value !== null && TableConfigSymbol in value;
+}
+
+// src/commands/push.ts
+async function runPush(config2, opts = {}) {
+  console.log("@bungres/kit push: loading schemas...");
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    console.warn("No table definitions found. Check your schema glob pattern.");
+    return;
+  }
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    await sql2.unsafe(`
+      CREATE TABLE IF NOT EXISTS public.__bungres_push (
+        id SERIAL PRIMARY KEY,
+        snapshot JSONB NOT NULL
+      );
+    `);
+    const rows = await sql2.unsafe(`SELECT snapshot FROM public.__bungres_push ORDER BY id DESC LIMIT 1;`);
+    let prevSnapshot = {};
+    if (rows.length > 0) {
+      prevSnapshot = typeof rows[0].snapshot === "string" ? JSON.parse(rows[0].snapshot) : rows[0].snapshot;
+    }
+    const currentSnapshot = Object.fromEntries(schemas2.map((s) => [s.config.name, s.config]));
+    const diff = diffSchemas(prevSnapshot, currentSnapshot);
+    if (diff.statements.length === 0) {
+      console.log(`
+No schema changes detected. Database is up to date.`);
+      return;
+    }
+    console.log(`
+Changes to apply:`);
+    for (const s of diff.summary)
+      console.log(`  + ${s}`);
+    if (diff.warnings && diff.warnings.length > 0) {
+      console.warn(`
+  \u26A0\uFE0F  WARNING: Data Loss Detected!`);
+      for (const w of diff.warnings)
+        console.warn(`    ! ${w}`);
+      console.warn(`
+  These changes will be immediately executed against the database!`);
+    }
+    if (!opts.force) {
+      process.stdout.write(`
+Are you sure you want to push these changes? Type YES to continue: `);
+      const answer = await readLine();
+      if (answer.trim().toLowerCase() !== "yes") {
+        console.log("Aborted.");
+        return;
+      }
+    }
+    console.log(`
+Pushing changes...`);
+    await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "pgcrypto";`);
+    for (const stmt of diff.statements) {
+      if (config2.verbose) {
+        console.log(`-- ${stmt}`);
+      }
+      await sql2.unsafe(stmt);
+    }
+    await sql2.unsafe(`INSERT INTO public.__bungres_push (snapshot) VALUES ($1);`, [JSON.stringify(currentSnapshot)]);
+    console.log(`
+Push complete.`);
+  } finally {
+    await sql2.end();
+  }
+}
+async function readLine() {
+  const buf = Buffer.alloc(256);
+  const n = fs.readSync(0, buf, 0, 256, null);
+  return buf.subarray(0, n).toString().trim();
+}
+
+// src/commands/generate.ts
+import { join as join3, resolve as resolve3 } from "path";
+
+// src/utils/colors.ts
+function colorize(text2, color) {
+  const code2 = Bun.color(color, "ansi");
+  return code2 ? `${code2}${text2}\x1B[0m` : text2;
+}
+
+// src/commands/generate.ts
+var SNAPSHOT_FILE = ".snapshot.json";
+async function runGenerate(config2, name) {
+  console.log("@bungres/kit generate: loading schemas...");
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    console.warn(colorize("No table definitions found. Check your schema glob pattern.", "yellow"));
+    return;
+  }
+  const migrationsDir = resolve3(config2.migrationsDir);
+  await Bun.$`mkdir -p ${migrationsDir}`.quiet();
+  const currentSnapshot = Object.fromEntries(schemas2.map((s) => [s.config.name, s.config]));
+  const snapshotPath = join3(migrationsDir, SNAPSHOT_FILE);
+  const snapshotFile = Bun.file(snapshotPath);
+  const isFirstMigration = !await snapshotFile.exists();
+  const prevSnapshot = isFirstMigration ? {} : JSON.parse(await snapshotFile.text());
+  const now = new Date;
+  const yyyy = now.getUTCFullYear();
+  const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(now.getUTCDate()).padStart(2, "0");
+  const HH = String(now.getUTCHours()).padStart(2, "0");
+  const MM = String(now.getUTCMinutes()).padStart(2, "0");
+  const SS = String(now.getUTCSeconds()).padStart(2, "0");
+  const prefix = `${yyyy}_${mm}_${dd}_${HH}${MM}${SS}`;
+  const filename = name ? `${prefix}_${name}.sql` : `${prefix}.sql`;
+  const outPath = join3(migrationsDir, filename);
+  let statements;
+  let summary;
+  let warnings = [];
+  if (isFirstMigration) {
+    const sorted = topoSort(schemas2);
+    statements = [
+      `CREATE EXTENSION IF NOT EXISTS "pgcrypto";`,
+      ``,
+      ...sorted.flatMap((entry) => [
+        `-- ${entry.exportName}`,
+        generateCreateTable(entry.config, true),
+        ``
+      ])
+    ];
+    summary = sorted.map((s) => `CREATE TABLE ${s.config.name}`);
+  } else {
+    const diff = diffSchemas(prevSnapshot, currentSnapshot);
+    if (diff.statements.length === 0) {
+      console.log(colorize(`
+No schema changes detected. Nothing to generate.`, "yellow"));
+      return;
+    }
+    statements = diff.statements;
+    summary = diff.summary;
+    warnings = diff.warnings;
+  }
+  const lines = [
+    `-- Migration: ${filename}`,
+    `-- Generated by @bungres/kit at ${new Date().toISOString()}`,
+    `-- Changes: ${summary.join(", ")}`,
+    ``,
+    ...statements
+  ];
+  await Bun.write(outPath, lines.join(`
+`));
+  await Bun.write(snapshotPath, JSON.stringify(currentSnapshot, null, 2));
+  console.log(colorize(`
+Generated: ${outPath}`, "green"));
+  console.log(`  Changes:`);
+  for (const s of summary)
+    console.log(colorize(`    + ${s}`, "cyan"));
+  if (warnings.length > 0) {
+    console.warn(colorize(`
+  \u26A0\uFE0F  WARNING: Data Loss Detected!`, "red"));
+    for (const w of warnings)
+      console.warn(colorize(`    ! ${w}`, "red"));
+    console.warn(colorize(`  Please review the generated migration carefully before applying it.
+`, "yellow"));
+  }
+  console.log(colorize(`
+Run \`bungres migrate\` to apply it.`, "cyan"));
+}
+function topoSort(schemas2) {
+  const byName = new Map(schemas2.map((s) => [s.config.name, s]));
+  function deps(config2) {
+    return Object.values(config2.columns).map((col2) => col2.references?.table).filter((t) => t !== undefined && byName.has(t) && t !== config2.name);
+  }
+  const visited = new Set;
+  const result2 = [];
+  function visit(name) {
+    if (visited.has(name))
+      return;
+    visited.add(name);
+    const entry = byName.get(name);
+    if (!entry)
+      return;
+    for (const dep of deps(entry.config))
+      visit(dep);
+    result2.push(entry);
+  }
+  for (const schema of schemas2)
+    visit(schema.config.name);
+  return result2;
+}
+
+// src/commands/migrate.ts
+import { join as join4, resolve as resolve4 } from "path";
+var MIGRATIONS_TABLE = "__bungres_migrations";
+var CREATE_MIGRATIONS_TABLE = `
+CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (
+  id          SERIAL PRIMARY KEY,
+  name        TEXT NOT NULL UNIQUE,
+  applied_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+`.trim();
+async function runMigrate(config2) {
+  const migrationsDir = resolve4(config2.migrationsDir);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    await sql2.unsafe(CREATE_MIGRATIONS_TABLE);
+    const glob = new Bun.Glob("*.sql");
+    const files = [];
+    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
+      files.push(file);
+    }
+    files.sort();
+    if (files.length === 0) {
+      console.log(colorize("No migration files found in " + migrationsDir, "yellow"));
+      console.log(colorize("Run `bungres generate` first.", "yellow"));
+      return;
+    }
+    const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE}"`);
+    const appliedSet = new Set(applied.map((r) => r.name));
+    const pending = files.filter((f) => !appliedSet.has(f));
+    if (pending.length === 0) {
+      console.log(colorize("Everything is up to date.", "green"));
+      return;
+    }
+    console.log(colorize(`
+Running ${pending.length} pending migration(s)...
+`, "cyan"));
+    for (const file of pending) {
+      const content = await Bun.file(join4(migrationsDir, file)).text();
+      if (config2.verbose) {
+        console.log(`-- ${file} --
+${content}
+`);
+      }
+      await sql2.transaction(async (txSql) => {
+        const statements = content.split(";").map((s) => s.trim()).filter(Boolean);
+        for (const stmt of statements) {
+          await txSql.unsafe(stmt + ";");
+        }
+        await txSql.unsafe(`INSERT INTO "${MIGRATIONS_TABLE}" (name) VALUES ($1)`, [file]);
+      });
+      console.log(colorize(`  \u2713  ${file}`, "green"));
+    }
+    console.log(colorize(`
+Done.`, "green"));
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/pull.ts
+import { resolve as resolve5, join as join5 } from "path";
+async function introspectDb(sql2, dbSchema) {
+  const columns = await sql2.unsafe(`SELECT
+      c.table_name,
+      c.column_name,
+      c.data_type,
+      c.udt_name,
+      c.is_nullable,
+      c.column_default,
+      c.character_maximum_length
+    FROM information_schema.columns c
+    WHERE c.table_schema = $1
+      AND c.table_name NOT IN ('__bungres_migrations', '__bungres_push')
+    ORDER BY c.table_name, c.ordinal_position`, [dbSchema]);
+  const constraints = await sql2.unsafe(`SELECT
+      tc.table_name,
+      kcu.column_name,
+      tc.constraint_type,
+      ccu.table_name  AS foreign_table,
+      ccu.column_name AS foreign_column,
+      rc.delete_rule,
+      rc.update_rule
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+    LEFT JOIN information_schema.constraint_column_usage ccu
+      ON tc.constraint_name = ccu.constraint_name
+      AND tc.table_schema = ccu.table_schema
+    LEFT JOIN information_schema.referential_constraints rc
+      ON tc.constraint_name = rc.constraint_name
+      AND tc.table_schema = rc.constraint_schema
+    WHERE tc.table_schema = $1`, [dbSchema]);
+  const indexes = await sql2.unsafe(`SELECT tablename, indexname, indexdef
+     FROM pg_indexes
+     WHERE schemaname = $1`, [dbSchema]);
+  return groupByTable(columns, constraints, indexes);
+}
+async function runPull(config2) {
+  console.log("@bungres/kit pull: introspecting database...");
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const dbSchema = config2.dbSchema;
+    const tableMap = await introspectDb(sql2, dbSchema);
+    if (tableMap.size === 0) {
+      console.log("No tables found in schema:", dbSchema);
+      return;
+    }
+    const outDir = resolve5(config2.outDir);
+    await Bun.$`mkdir -p ${outDir}`.quiet();
+    const outPath = join5(outDir, "schema.ts");
+    const code2 = generateSchemaTS(tableMap, dbSchema);
+    await Bun.write(outPath, code2);
+    console.log(`Generated schema: ${outPath}`);
+    console.log(`  Tables: ${[...tableMap.keys()].join(", ")}`);
+  } finally {
+    await sql2.end();
+  }
+}
+function groupByTable(columns, constraints, indexes) {
+  const map = new Map;
+  for (const col2 of columns) {
+    if (!map.has(col2.table_name)) {
+      map.set(col2.table_name, {
+        tableName: col2.table_name,
+        columns: [],
+        indexes: indexes.filter((i) => i.tablename === col2.table_name)
+      });
+    }
+    const tableConstraints = constraints.filter((c) => c.table_name === col2.table_name && c.column_name === col2.column_name);
+    const pkConstraint = tableConstraints.find((c) => c.constraint_type === "PRIMARY KEY");
+    const uniqueConstraint = tableConstraints.find((c) => c.constraint_type === "UNIQUE");
+    const fkConstraint = tableConstraints.find((c) => c.constraint_type === "FOREIGN KEY");
+    map.get(col2.table_name).columns.push({
+      name: col2.column_name,
+      dataType: col2.data_type,
+      udtName: col2.udt_name,
+      isNullable: col2.is_nullable === "YES",
+      columnDefault: col2.column_default,
+      maxLength: col2.character_maximum_length,
+      isPrimary: !!pkConstraint,
+      isUnique: !!uniqueConstraint,
+      foreignTable: fkConstraint?.foreign_table ?? undefined,
+      foreignColumn: fkConstraint?.foreign_column ?? undefined,
+      deleteRule: fkConstraint?.delete_rule ?? undefined,
+      updateRule: fkConstraint?.update_rule ?? undefined
+    });
+  }
+  return map;
+}
+function generateSchemaTS(tableMap, dbSchema) {
+  const lines = [
+    `// Generated by @bungres/kit pull`,
+    `// Do not edit manually \u2014 re-run \`bungres pull\` to regenerate`,
+    `// Generated at: ${new Date().toISOString()}`,
+    ``,
+    `import {`,
+    `  table,`,
+    `  text, varchar, char, integer, bigint, smallint,`,
+    `  serial, bigserial, boolean, real, doublePrecision,`,
+    `  numeric, decimal, json, jsonb,`,
+    `  timestamp, timestamptz, date, time, uuid,`,
+    `  bytea, inet,`,
+    `} 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) {
+      const colExpr = buildColumnExpression(col2);
+      lines.push(`  ${col2.name}: ${colExpr},`);
+    }
+    const options = [];
+    if (dbSchema !== "public") {
+      options.push(`schema: "${dbSchema}"`);
+    }
+    if (table2.indexes.length > 0) {
+      const idxLines = [];
+      for (const idx of table2.indexes) {
+        const m = idx.indexdef.match(/CREATE (UNIQUE )?INDEX (.+) ON (.+) USING (\w+) \((.+)\)(?: WHERE (.+))?/i);
+        if (m) {
+          const isUnique = !!m[1];
+          const name = m[2].trim().replace(/^"|"$/g, "");
+          if (name.endsWith("_pkey") || name.endsWith("_key"))
+            continue;
+          const using = m[4].toLowerCase();
+          const cols = m[5].split(",").map((c) => `"${c.trim().replace(/^"|"$/g, "")}"`);
+          let idxStr = `{ name: "${name}", columns: [${cols.join(", ")}], using: "${using}"`;
+          if (isUnique)
+            idxStr += `, unique: true`;
+          if (m[6])
+            idxStr += `, where: \`${m[6].trim()}\``;
+          idxStr += ` }`;
+          idxLines.push(idxStr);
+        }
+      }
+      if (idxLines.length > 0) {
+        options.push(`indexes: [
+    ${idxLines.join(`,
+    `)}
+  ]`);
+      }
+    }
+    if (options.length > 0) {
+      lines.push(`}, {`);
+      lines.push(`  ${options.join(`,
+  `)}`);
+      lines.push(`});`);
+    } else {
+      lines.push(`});`);
+    }
+    lines.push(``);
+  }
+  return lines.join(`
+`);
+}
+function buildColumnExpression(col2) {
+  let expr = pgTypeToBungresBuilder(col2);
+  if (col2.isPrimary)
+    expr += `.primaryKey()`;
+  else if (!col2.isNullable)
+    expr += `.notNull()`;
+  if (col2.isUnique && !col2.isPrimary)
+    expr += `.unique()`;
+  if (col2.columnDefault !== null && !col2.isPrimary) {
+    if (col2.columnDefault.includes("(")) {
+      expr += `.defaultRaw("${col2.columnDefault}")`;
+    } else if (col2.dataType === "boolean") {
+      expr += `.default(${col2.columnDefault})`;
+    } else if (col2.dataType.includes("int") || col2.dataType.includes("numeric") || col2.dataType.includes("real") || col2.dataType.includes("double")) {
+      expr += `.default(${col2.columnDefault})`;
+    } else {
+      const cleaned = col2.columnDefault.replace(/^'(.*)'::.*$/, "$1");
+      expr += `.default("${cleaned}")`;
+    }
+  }
+  if (col2.foreignTable && col2.foreignColumn) {
+    const deleteRule = col2.deleteRule?.toLowerCase().replace(" ", " ");
+    const updateRule = col2.updateRule?.toLowerCase().replace(" ", " ");
+    let refOpts = "";
+    if (deleteRule && deleteRule !== "no action") {
+      refOpts += `onDelete: "${deleteRule}", `;
+    }
+    if (updateRule && updateRule !== "no action") {
+      refOpts += `onUpdate: "${updateRule}"`;
+    }
+    const opts = refOpts ? `, { ${refOpts.trim().replace(/,$/, "")} }` : "";
+    expr += `.references("${col2.foreignTable}", "${col2.foreignColumn}"${opts})`;
+  }
+  return expr;
+}
+function pgTypeToBungresBuilder(col2) {
+  const dt = col2.dataType;
+  const name = col2.name;
+  if (dt === "uuid")
+    return `uuid("${name}")`;
+  if (dt === "text")
+    return `text("${name}")`;
+  if (dt === "character varying")
+    return col2.maxLength ? `varchar("${name}", ${col2.maxLength})` : `varchar("${name}")`;
+  if (dt === "character")
+    return col2.maxLength ? `char("${name}", ${col2.maxLength})` : `char("${name}")`;
+  if (dt === "integer")
+    return `integer("${name}")`;
+  if (dt === "bigint")
+    return `bigint("${name}")`;
+  if (dt === "smallint")
+    return `smallint("${name}")`;
+  if (dt === "boolean")
+    return `boolean("${name}")`;
+  if (dt === "real")
+    return `real("${name}")`;
+  if (dt === "double precision")
+    return `doublePrecision("${name}")`;
+  if (dt === "numeric" || dt === "decimal")
+    return `numeric("${name}")`;
+  if (dt === "json")
+    return `json("${name}")`;
+  if (dt === "jsonb")
+    return `jsonb("${name}")`;
+  if (dt === "timestamp without time zone")
+    return `timestamp("${name}")`;
+  if (dt === "timestamp with time zone")
+    return `timestamptz("${name}")`;
+  if (dt === "date")
+    return `date("${name}")`;
+  if (dt === "time without time zone")
+    return `time("${name}")`;
+  if (dt === "bytea")
+    return `bytea("${name}")`;
+  if (dt === "inet")
+    return `inet("${name}")`;
+  if (dt === "USER-DEFINED" && col2.udtName === "citext")
+    return `text("${name}")`;
+  return `text("${name}") /* original type: ${dt} */`;
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+// src/commands/status.ts
+import { resolve as resolve6 } from "path";
+var MIGRATIONS_TABLE2 = "__bungres_migrations";
+async function runStatus(config2) {
+  const migrationsDir = resolve6(config2.migrationsDir);
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const tableCheck = await sql2.unsafe(`SELECT EXISTS (
+        SELECT 1 FROM information_schema.tables
+        WHERE table_name = $1
+      ) AS exists`, [MIGRATIONS_TABLE2]);
+    const trackingExists = tableCheck[0]?.exists ?? false;
+    const glob = new Bun.Glob("*.sql");
+    const files = [];
+    for await (const file of glob.scan({ cwd: migrationsDir, absolute: false })) {
+      files.push(file);
+    }
+    files.sort();
+    if (files.length === 0) {
+      console.log(colorize("No migration files found. Run `bungres generate` first.", "yellow"));
+      return;
+    }
+    let appliedSet = new Set;
+    if (trackingExists) {
+      const applied = await sql2.unsafe(`SELECT name FROM "${MIGRATIONS_TABLE2}" ORDER BY applied_at`);
+      appliedSet = new Set(applied.map((r) => r.name));
+    }
+    console.log(colorize(`
+Migration status:
+`, "cyan"));
+    let pendingCount = 0;
+    for (const file of files) {
+      const isApplied = appliedSet.has(file);
+      const status = isApplied ? colorize("\u2713 applied ", "green") : colorize("\u2717 pending ", "yellow");
+      if (!isApplied)
+        pendingCount++;
+      console.log(`  ${status}  ${file}`);
+    }
+    console.log(`
+${colorize(appliedSet.size.toString(), "green")} applied, ${colorize(pendingCount.toString(), "yellow")} pending.
+`);
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/drop.ts
+async function runDrop(config2, opts = {}) {
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    console.warn("No table definitions found in schema files.");
+    return;
+  }
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const existingTablesResult = await sql2`
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' OR table_schema = current_schema()
+    `;
+    const existingTableNames = new Set(existingTablesResult.map((row) => row.table_name));
+    const migrationTableExists = existingTableNames.has("__bungres_migrations");
+    const pushTableExists = existingTableNames.has("__bungres_push");
+    const tablesToDrop = schemas2.filter((s) => existingTableNames.has(s.config.name));
+    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
+      console.log("No tables to drop (they either don't exist or were already dropped).");
+      return;
+    }
+    const tableNamesToPrint = tablesToDrop.map((s) => (s.config.schema ? s.config.schema + "." : "") + s.config.name);
+    if (migrationTableExists) {
+      tableNamesToPrint.push("__bungres_migrations");
+    }
+    if (pushTableExists) {
+      tableNamesToPrint.push("__bungres_push");
+    }
+    if (!opts.force) {
+      console.warn(colorize(`
+\u26A0\uFE0F  WARNING: This will drop the following tables and ALL their data:
+`, "red"));
+      for (const name of tableNamesToPrint)
+        console.log(colorize(`  - ${name}`, "yellow"));
+      process.stdout.write(colorize(`
+Are you sure? Type YES to continue: `, "cyan"));
+      for await (const line2 of console) {
+        if (line2.trim().toLowerCase() !== "yes") {
+          console.log("Aborted.");
+          return;
+        }
+        break;
+      }
+    }
+    for (const entry of tablesToDrop) {
+      const ddl = `DROP TABLE IF EXISTS "${entry.config.name}" CASCADE;`;
+      await sql2.unsafe(ddl);
+      console.log(colorize(`  \u2713 dropped ${entry.config.name}`, "green"));
+    }
+    if (migrationTableExists) {
+      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_migrations CASCADE");
+      console.log(colorize(`  \u2713 dropped __bungres_migrations`, "green"));
+    }
+    if (pushTableExists) {
+      await sql2.unsafe("DROP TABLE IF EXISTS public.__bungres_push CASCADE");
+      console.log(colorize(`  \u2713 dropped __bungres_push`, "green"));
+    }
+    console.log(colorize(`
+Drop complete.`, "green"));
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/fresh.ts
+async function runFresh(config2) {
+  console.log("Dropping all tables...");
+  await runDrop(config2, { force: true });
+  console.log(`
+Re-running migrations...`);
+  await runMigrate(config2);
+  console.log(`
+Fresh complete.`);
+}
+
+// src/commands/refresh.ts
+async function runRefresh(config2) {
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    console.warn("No table definitions found in schema files.");
+    return;
+  }
+  const sql2 = new Bun.SQL(config2.dbUrl);
+  try {
+    const tableNames = schemas2.map((s) => `"${s.config.schema ? s.config.schema + '"."' : ""}${s.config.name}"`);
+    console.log(`Truncating ${tableNames.length} tables...`);
+    for (const entry of schemas2) {
+      const ddl = `TRUNCATE TABLE "${entry.config.name}" CASCADE;`;
+      await sql2.unsafe(ddl);
+      console.log(colorize(`  \u2713 truncated ${entry.config.name}`, "green"));
+    }
+    console.log(colorize(`
+Refresh complete. All tables are now empty.`, "green"));
+  } finally {
+    await sql2.end();
+  }
+}
+
+// src/commands/seed.ts
+import { resolve as resolve7 } from "path";
+async function runSeed(config2) {
+  if (!config2.seed) {
+    console.log(colorize(`No seed file configured in bungres.config.ts`, "yellow"));
+    return;
+  }
+  const seedPath = resolve7(process.cwd(), config2.seed);
+  const file = Bun.file(seedPath);
+  if (!await file.exists()) {
+    console.error(colorize(`Seed file not found at ${seedPath}`, "red"));
+    process.exit(1);
+  }
+  console.log(colorize(`
+Running seeder: ${config2.seed}...`, "cyan"));
+  const proc = Bun.spawn(["bun", "run", seedPath], {
+    cwd: process.cwd(),
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, DATABASE_URL: config2.dbUrl }
+  });
+  const exitCode = await proc.exited;
+  if (exitCode === 0) {
+    console.log(`
+Seed complete.`);
+  } else {
+    console.error(`
+Seed failed with exit code ${exitCode}.`);
+    process.exit(exitCode);
+  }
+}
+
+// src/commands/studio.ts
+async function runStudio(config2) {
+  const schemas2 = await loadSchemas(config2.schema);
+  if (schemas2.length === 0) {
+    console.warn("No table definitions found in schema files.");
+    return;
+  }
+  const schemaObj2 = {};
+  for (const s of schemas2) {
+    schemaObj2[s.exportName] = s.table;
+  }
+  const db2 = createDB({ url: config2.dbUrl, schema: schemaObj2 });
+  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 5555;
+  const server = Bun.serve({
+    port,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (req.method === "GET" && url.pathname === "/api/tables") {
+        const tables = schemas2.map((s) => ({
+          name: s.config.name,
+          exportName: s.exportName,
+          columns: Object.entries(s.config.columns).map(([key, col2]) => ({
+            name: col2.name,
+            type: col2.dataType,
+            primaryKey: col2.primaryKey
+          }))
+        }));
+        return new Response(JSON.stringify(tables), {
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      if (req.method === "GET" && url.pathname.startsWith("/api/tables/") && url.pathname.endsWith("/data")) {
+        const tableName = url.pathname.split("/")[3];
+        const schema = schemas2.find((s) => s.config.name === tableName);
+        if (!schema) {
+          return new Response("Table not found", { status: 404 });
+        }
+        try {
+          const data = await db2.select().from(schema.table).limit(100);
+          return new Response(JSON.stringify(data), {
+            headers: { "Content-Type": "application/json" }
+          });
+        } catch (e) {
+          return new Response(JSON.stringify({ error: e.message }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      }
+      if (req.method === "POST" && url.pathname === "/api/editor/open") {
+        try {
+          const body = await req.json();
+          const tableName = body.tableName;
+          const schema = schemas2.find((s) => s.config.name === tableName);
+          if (schema && schema.filePath) {
+            console.log(`Attempting to open ${schema.filePath} in editor...`);
+            Bun.openInEditor(schema.filePath, { editor: "vscode" });
+            return new Response(JSON.stringify({
+              success: true,
+              filePath: schema.filePath
+            }), {
+              headers: { "Content-Type": "application/json" }
+            });
+          }
+          return new Response("Schema not found", { status: 404 });
+        } catch (e) {
+          return new Response("Invalid request", { status: 400 });
+        }
+      }
+      if (req.method === "GET" && url.pathname === "/") {
+        return new Response(htmlTemplate, {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+      return new Response("Not found", { status: 404 });
+    }
+  });
+  console.log(colorize("=========================================", "cyan"));
+  console.log(colorize(`\uD83D\uDC18 Bungres Studio is running!`, "cyan"));
+  console.log(colorize(`   Local: http://localhost:${server.port}`, "green"));
+  console.log(colorize("=========================================", "cyan"));
+}
+var htmlTemplate = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bungres Studio</title>
+  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+  <style>
+    :root {
+      --bg-color: #0d1117;
+      --panel-bg: #161b22;
+      --border-color: #30363d;
+      --text-main: #c9d1d9;
+      --text-muted: #8b949e;
+      --accent-color: #58a6ff;
+      --accent-hover: #1f6feb;
+      --header-bg: #161b22;
+      --row-hover: #1f2428;
+    }
+
+    * { box-sizing: border-box; }
+    
+    body {
+      margin: 0;
+      padding: 0;
+      font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+      background-color: var(--bg-color);
+      color: var(--text-main);
+      display: flex;
+      height: 100vh;
+      overflow: hidden;
+    }
+
+    /* Sidebar */
+    .sidebar {
+      width: 250px;
+      background-color: var(--panel-bg);
+      border-right: 1px solid var(--border-color);
+      display: flex;
+      flex-direction: column;
+    }
+
+    .sidebar-header {
+      padding: 20px;
+      border-bottom: 1px solid var(--border-color);
+      display: flex;
+      align-items: center;
+      gap: 10px;
+    }
+
+    .sidebar-header h1 {
+      margin: 0;
+      font-size: 16px;
+      font-weight: 600;
+      color: white;
+    }
+
+    .table-list {
+      flex: 1;
+      overflow-y: auto;
+      padding: 10px 0;
+      list-style: none;
+      margin: 0;
+    }
+
+    .table-item {
+      padding: 8px 20px;
+      cursor: pointer;
+      font-size: 14px;
+      color: var(--text-muted);
+      transition: all 0.2s ease;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .table-item:hover {
+      background-color: var(--row-hover);
+      color: var(--text-main);
+    }
+
+    .table-item.active {
+      background-color: rgba(88, 166, 255, 0.1);
+      color: var(--accent-color);
+      border-right: 3px solid var(--accent-color);
+    }
+
+    /* Main Content */
+    .main {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      background-color: var(--bg-color);
+    }
+
+    .main-header {
+      height: 60px;
+      padding: 0 20px;
+      border-bottom: 1px solid var(--border-color);
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      background-color: var(--header-bg);
+    }
+
+    .main-header h2 {
+      margin: 0;
+      font-size: 16px;
+      font-weight: 500;
+      color: white;
+    }
+
+    .btn {
+      background-color: var(--accent-color);
+      color: white;
+      border: none;
+      padding: 6px 12px;
+      border-radius: 6px;
+      font-size: 12px;
+      font-weight: 500;
+      cursor: pointer;
+      transition: background-color 0.2s ease;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .btn:hover {
+      background-color: var(--accent-hover);
+    }
+
+    .btn:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+
+    .content-area {
+      flex: 1;
+      overflow: auto;
+      padding: 20px;
+    }
+
+    /* Data Table */
+    .data-grid-container {
+      background-color: var(--panel-bg);
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      overflow: hidden;
+    }
+
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      text-align: left;
+      font-size: 13px;
+    }
+
+    th {
+      background-color: rgba(255,255,255,0.02);
+      color: var(--text-muted);
+      font-weight: 500;
+      padding: 10px 16px;
+      border-bottom: 1px solid var(--border-color);
+      white-space: nowrap;
+      position: sticky;
+      top: 0;
+      z-index: 10;
+    }
+
+    td {
+      padding: 10px 16px;
+      border-bottom: 1px solid var(--border-color);
+      color: var(--text-main);
+      max-width: 300px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    tr:last-child td {
+      border-bottom: none;
+    }
+
+    tr:hover td {
+      background-color: var(--row-hover);
+    }
+
+    .type-number { color: #79c0ff; }
+    .type-string { color: #a5d6ff; }
+    .type-boolean { color: #ff7b72; }
+    .type-date { color: #d2a8ff; }
+    .type-null { color: var(--text-muted); font-style: italic; }
+
+    .empty-state {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      height: 100%;
+      color: var(--text-muted);
+    }
+  </style>
+</head>
+<body>
+
+  <div class="sidebar">
+    <div class="sidebar-header">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <ellipse cx="12" cy="5" rx="9" ry="3"></ellipse>
+        <path d="M21 12c0 1.66-4 3-9 3s-9-1.34-9-3"></path>
+        <path d="M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5"></path>
+      </svg>
+      <h1>Bungres Studio</h1>
+    </div>
+    <ul class="table-list" id="table-list">
+      <!-- Populated by JS -->
+    </ul>
+  </div>
+
+  <div class="main">
+    <div class="main-header">
+      <h2 id="current-table-name">Select a table</h2>
+      <button id="refresh-btn" class="btn" disabled>
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+          <polyline points="23 4 23 10 17 10"></polyline>
+          <polyline points="1 20 1 14 7 14"></polyline>
+          <path d="M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15"></path>
+        </svg>
+        Refresh Data
+      </button>
+    </div>
+    <div class="content-area">
+      <div id="data-container" class="empty-state">
+        <p>Select a table from the sidebar to view data</p>
+      </div>
+    </div>
+  </div>
+
+  <script>
+    let currentTable = null;
+    let tablesData = [];
+
+    // Format values for the data grid
+    function formatValue(val) {
+      if (val === null || val === undefined) return '<span class="type-null">null</span>';
+      if (typeof val === 'number') return \`<span class="type-number">\${val}</span>\`;
+      if (typeof val === 'boolean') return \`<span class="type-boolean">\${val}</span>\`;
+      if (val instanceof Date || (typeof val === 'string' && val.match(/^\\d{4}-\\d{2}-\\d{2}T/))) {
+        return \`<span class="type-date">\${new Date(val).toLocaleString()}</span>\`;
+      }
+      // Escape HTML to prevent XSS
+      const safeStr = String(val)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+      return \`<span class="type-string">\${safeStr}</span>\`;
+    }
+
+    async function loadTables() {
+      try {
+        const res = await fetch('/api/tables');
+        tablesData = await res.json();
+        
+        const list = document.getElementById('table-list');
+        list.innerHTML = '';
+        
+        tablesData.forEach(t => {
+          const li = document.createElement('li');
+          li.className = 'table-item';
+          li.innerHTML = \`
+            <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+              <rect x="3" y="3" width="18" height="18" rx="2" ry="2"></rect>
+              <line x1="3" y1="9" x2="21" y2="9"></line>
+              <line x1="9" y1="21" x2="9" y2="9"></line>
+            </svg>
+            \${t.name}
+          \`;
+          li.onclick = () => selectTable(t.name);
+          list.appendChild(li);
+        });
+      } catch (e) {
+        console.error("Failed to load tables", e);
+      }
+    }
+
+    async function selectTable(name) {
+      currentTable = name;
+      
+      // Update UI active state
+      document.querySelectorAll('.table-item').forEach(el => {
+        if (el.textContent.trim() === name) el.classList.add('active');
+        else el.classList.remove('active');
+      });
+      
+      document.getElementById('current-table-name').textContent = name;
+      document.getElementById('refresh-btn').disabled = false;
+      
+      const container = document.getElementById('data-container');
+      container.innerHTML = '<div class="empty-state">Loading data...</div>';
+      container.className = '';
+      
+      try {
+        const res = await fetch(\`/api/tables/\${name}/data\`);
+        if (!res.ok) throw new Error(await res.text());
+        const rows = await res.json();
+        
+        if (rows.length === 0) {
+          container.innerHTML = '<div class="empty-state">No data in this table</div>';
+          return;
+        }
+
+        const columns = Object.keys(rows[0]);
+        
+        let html = '<div class="data-grid-container"><table><thead><tr>';
+        columns.forEach(col => {
+          html += \`<th>\${col}</th>\`;
+        });
+        html += '</tr></thead><tbody>';
+        
+        rows.forEach(row => {
+          html += '<tr>';
+          columns.forEach(col => {
+            html += \`<td>\${formatValue(row[col])}</td>\`;
+          });
+          html += '</tr>';
+        });
+        
+        html += '</tbody></table></div>';
+        container.innerHTML = html;
+        
+      } catch (e) {
+        container.innerHTML = \`<div class="empty-state" style="color: #ff7b72;">Error: \${e.message}</div>\`;
+      }
+    }
+
+    document.getElementById('refresh-btn').addEventListener('click', async () => {
+      if (!currentTable) return;
+      
+      const btn = document.getElementById('refresh-btn');
+      const originalText = btn.innerHTML;
+      btn.innerHTML = 'Refreshing...';
+      
+      try {
+        await selectTable(currentTable);
+      } catch (e) {
+        console.error("Failed to refresh data", e);
+      } finally {
+        setTimeout(() => { btn.innerHTML = originalText; }, 300);
+      }
+    });
+
+    // Init
+    loadTables();
+  </script>
+</body>
+</html>
+`;
+
+// src/commands/tusky.ts
+import * as readline from "readline";
+async function runTusky(config) {
+  const schemas = await loadSchemas(config.schema);
+  const schemaObj = {};
+  for (const s of schemas) {
+    schemaObj[s.exportName] = s.table;
+  }
+  const db = createDB({ url: config.dbUrl, schema: schemaObj });
+  console.log("=========================================");
+  console.log("\uD83D\uDC18 Welcome to Bungres REPL (Tusky)");
+  console.log("=========================================");
+  console.log(`
+Database connection established.`);
+  console.log(`
+Pre-loaded Context:`);
+  console.log("  - db      (Bungres Database Client)");
+  for (const s of schemas) {
+    console.log(`  - ${s.exportName} (Table)`);
+  }
+  console.log(`
+Example query: await db.select().from(users)`);
+  console.log(`Type .exit to quit.
+`);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: "bungres> "
+  });
+  globalThis.db = db;
+  for (const s of schemas) {
+    globalThis[s.exportName] = s.table;
+  }
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (input === ".exit") {
+      rl.close();
+      return;
+    }
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    try {
+      let code = input;
+      const isRawSql = /^(select|insert|update|delete|create|drop|alter|truncate|with)\b/i.test(input);
+      if (isRawSql) {
+        console.log(`(Running as raw SQL: await db.raw(\`${input}\`))`);
+        code = `(async () => { return await db.raw(\`${input}\`); })()`;
+      } else if (input.includes("await ")) {
+        code = `(async () => { return ${input}; })()`;
+      }
+      const result = await eval(code);
+      console.log(result);
+    } catch (err) {
+      console.error(err.message || err);
+    }
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+
+// src/ensure-db.ts
+async function ensureDatabase2(dbUrl) {
+  let sql2;
+  try {
+    sql2 = new Bun.SQL(dbUrl);
+    await sql2.unsafe("SELECT 1");
+    return;
+  } catch (err) {
+    if (err.message && err.message.includes("does not exist")) {
+      try {
+        const parsed = new URL(dbUrl);
+        const dbName = parsed.pathname.slice(1);
+        parsed.pathname = "/postgres";
+        const fallbackUrl = parsed.toString();
+        const fallback = new Bun.SQL(fallbackUrl);
+        try {
+          await fallback.unsafe(`CREATE DATABASE "${dbName}"`);
+          console.log(`Created database "${dbName}" automatically.`);
+        } finally {
+          await fallback.end();
+        }
+      } catch (e) {}
+    }
+  } finally {
+    if (sql2) {
+      await sql2.end();
+    }
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.0.1";
+var HELP = `
+${colorize("\uD83D\uDC18 Bungres ORM CLI", "cyan")} v${VERSION}
+
+${colorize("Usage:", "yellow")}
+  bungres <command> [options]
+
+${colorize("Commands:", "yellow")}
+  generate      Generate SQL migration files from your schema definitions
+  migrate       Run pending migration files against the database
+  push          Apply schema directly to the DB (no migration files, dev mode)
+  pull          Introspect the database and generate TypeScript schema
+  status        Show applied vs. pending migrations
+  fresh         Drop all tables and re-run all migrations from scratch
+  refresh       Truncate all tables to quickly reset data without dropping schema
+  seed          Execute the seed script to populate the database
+  studio        Start a local web interface to browse database data
+  tusky         Boot up a Node REPL connected to the database with schema loaded
+  drop          Drop all tables defined in the schema (dev only)
+
+${colorize("Options:", "yellow")}
+  --config      Path to config file (default: bungres.config.ts)
+  --verbose     Enable verbose SQL logging
+  --force       Skip confirmation prompts (use with drop)
+  --version     Show version
+  --help        Show this help
+
+${colorize("Examples:", "yellow")}
+  bungres generate
+  bungres migrate
+  bungres push
+  bungres pull
+  bungres status
+  bungres fresh
+  bungres refresh
+  bungres seed
+  bungres studio
+  bungres tusky
+  bungres drop --force
+`.trim();
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(`@bungres/kit v${VERSION}`);
+    process.exit(0);
+  }
+  const command = args[0];
+  const flags = parseFlags(args.slice(1));
+  const config2 = await loadConfig(process.cwd());
+  if (flags.verbose)
+    config2.verbose = true;
+  if (command && ["migrate", "push", "drop", "status", "fresh", "refresh"].includes(command)) {
+    await ensureDatabase2(config2.dbUrl);
+  }
+  switch (command) {
+    case "generate":
+      await runGenerate(config2, flags.name);
+      break;
+    case "migrate":
+      await runMigrate(config2);
+      break;
+    case "push":
+      await runPush(config2, { force: !!flags.force });
+      break;
+    case "pull":
+      await runPull(config2);
+      break;
+    case "status":
+      await runStatus(config2);
+      break;
+    case "drop":
+      await runDrop(config2, { force: !!flags.force });
+      break;
+    case "fresh":
+      await runFresh(config2);
+      break;
+    case "refresh":
+      await runRefresh(config2);
+      break;
+    case "seed":
+      await runSeed(config2);
+      break;
+    case "studio":
+      await runStudio(config2);
+      break;
+    case "tusky":
+      await runTusky(config2);
+      break;
+    default:
+      console.error(`Unknown command: ${command}
+`);
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+function parseFlags(args) {
+  const flags = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg?.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    }
+  }
+  return flags;
+}
+main().catch((err) => {
+  console.error("@bungres/kit error:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});