@bungres/kit 0.1.0

package/dist/index.js

@@ -0,0 +1,1720 @@
+// @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/schema-loader.ts
+import { resolve as resolve2, join as join2 } from "path";
+
+// ../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, config]) => {
+      const c = { ...config };
+      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 config = {
+    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(config, {
+    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 result = { ones, manys, manyToManys };
+    schemaCache.set(tableName, result);
+    return result;
+  }
+  _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(config) {
+    const url = typeof config === "string" ? config : config.url;
+    const opts = typeof config === "object" ? config : { 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 result = await this._sql.unsafe(chunk.sql, chunk.params);
+    return Array.from(result);
+  }
+  async executeSingle(builder) {
+    const rows = await this.execute(builder);
+    return rows[0] ?? null;
+  }
+  async raw(query, params = []) {
+    await this.ready();
+    const result = await this._sql.unsafe(query, params);
+    return Array.from(result);
+  }
+  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 result = await this._sql.unsafe(chunk.sql, chunk.params);
+    return Array.from(result);
+  }
+  async executeSingle(builder) {
+    const rows = await this.execute(builder);
+    return rows[0] ?? null;
+  }
+  async raw(query, params = []) {
+    const result = await this._sql.unsafe(query, params);
+    return Array.from(result);
+  }
+}
+function createDB(config) {
+  const db = new BungresDB(config);
+  if (typeof config === "object" && config.schema) {
+    const schema = config.schema;
+    return new Proxy(db, {
+      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 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" : "";
+  const columnDefs = Object.entries(config.columns).map(([key, col2]) => buildColumnDDL(key, col2, config.name));
+  if (config.primaryKeys && config.primaryKeys.length > 1) {
+    const pkCols = config.primaryKeys.map((c) => `"${c}"`).join(", ");
+    columnDefs.push(`PRIMARY KEY (${pkCols})`);
+  }
+  if (config.checks) {
+    for (const check of config.checks) {
+      columnDefs.push(`CHECK (${check})`);
+    }
+  }
+  let sql2 = `CREATE TABLE${exists} ${tableName} (
+  ${columnDefs.join(`,
+  `)}
+);`;
+  if (config.indexes && config.indexes.length > 0) {
+    sql2 += `
+
+` + config.indexes.map((idx) => buildIndex(config, 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/schema-loader.ts
+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
+import * as fs from "fs";
+
+// 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 config of topoSortConfigs(newTableConfigs)) {
+    statements.push(generateCreateTable(config, true));
+    summary.push(`CREATE TABLE ${config.name}`);
+  }
+  for (const tableName of prevTables) {
+    if (!nextTables.has(tableName)) {
+      const config = prev[tableName];
+      const tbl = config.schema ? `"${config.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 result = [];
+  function deps(config) {
+    return Object.values(config.columns).map((col2) => col2.references?.table).filter((t) => t !== undefined && byName.has(t) && t !== config.name);
+  }
+  function visit(name) {
+    if (visited.has(name))
+      return;
+    visited.add(name);
+    const config = byName.get(name);
+    if (!config)
+      return;
+    for (const dep of deps(config))
+      visit(dep);
+    result.push(config);
+  }
+  for (const table2 of tables)
+    visit(table2.name);
+  return result;
+}
+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/commands/push.ts
+async function runPush(config, opts = {}) {
+  console.log("@bungres/kit push: loading schemas...");
+  const schemas = await loadSchemas(config.schema);
+  if (schemas.length === 0) {
+    console.warn("No table definitions found. Check your schema glob pattern.");
+    return;
+  }
+  const sql2 = new Bun.SQL(config.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(schemas.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 (config.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 code = Bun.color(color, "ansi");
+  return code ? `${code}${text2}\x1B[0m` : text2;
+}
+
+// src/commands/generate.ts
+var SNAPSHOT_FILE = ".snapshot.json";
+async function runGenerate(config, name) {
+  console.log("@bungres/kit generate: loading schemas...");
+  const schemas = await loadSchemas(config.schema);
+  if (schemas.length === 0) {
+    console.warn(colorize("No table definitions found. Check your schema glob pattern.", "yellow"));
+    return;
+  }
+  const migrationsDir = resolve3(config.migrationsDir);
+  await Bun.$`mkdir -p ${migrationsDir}`.quiet();
+  const currentSnapshot = Object.fromEntries(schemas.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(schemas);
+    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(schemas) {
+  const byName = new Map(schemas.map((s) => [s.config.name, s]));
+  function deps(config) {
+    return Object.values(config.columns).map((col2) => col2.references?.table).filter((t) => t !== undefined && byName.has(t) && t !== config.name);
+  }
+  const visited = new Set;
+  const result = [];
+  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);
+    result.push(entry);
+  }
+  for (const schema of schemas)
+    visit(schema.config.name);
+  return result;
+}
+// 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(config) {
+  const migrationsDir = resolve4(config.migrationsDir);
+  const sql2 = new Bun.SQL(config.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 (config.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(config) {
+  console.log("@bungres/kit pull: introspecting database...");
+  const sql2 = new Bun.SQL(config.dbUrl);
+  try {
+    const dbSchema = config.dbSchema;
+    const tableMap = await introspectDb(sql2, dbSchema);
+    if (tableMap.size === 0) {
+      console.log("No tables found in schema:", dbSchema);
+      return;
+    }
+    const outDir = resolve5(config.outDir);
+    await Bun.$`mkdir -p ${outDir}`.quiet();
+    const outPath = join5(outDir, "schema.ts");
+    const code = generateSchemaTS(tableMap, dbSchema);
+    await Bun.write(outPath, code);
+    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(config) {
+  const migrationsDir = resolve6(config.migrationsDir);
+  const sql2 = new Bun.SQL(config.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(config, opts = {}) {
+  const schemas = await loadSchemas(config.schema);
+  if (schemas.length === 0) {
+    console.warn("No table definitions found in schema files.");
+    return;
+  }
+  const sql2 = new Bun.SQL(config.dbUrl);
+  try {
+    const existingTablesResult = await sql2`
+      SELECT table_name 
+      FROM information_schema.tables 
+      WHERE table_schema = 'public' OR table_schema = current_schema()
+    `;
+    const existingTableNames = new Set(existingTablesResult.map((row) => row.table_name));
+    const migrationTableExists = existingTableNames.has("__bungres_migrations");
+    const pushTableExists = existingTableNames.has("__bungres_push");
+    const tablesToDrop = schemas.filter((s) => existingTableNames.has(s.config.name));
+    if (tablesToDrop.length === 0 && !migrationTableExists && !pushTableExists) {
+      console.log("No tables to drop (they either don't exist or were already dropped).");
+      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 line of console) {
+        if (line.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/index.ts
+function defineConfig(config) {
+  return config;
+}
+export {
+  runStatus,
+  runPush,
+  runPull,
+  runMigrate,
+  runGenerate,
+  runDrop,
+  loadSchemas,
+  loadConfig,
+  defineConfig
+};