@buenojs/bueno 0.8.3 → 0.8.5

package/dist/orm/index.js

@@ -0,0 +1,1356 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/database/orm/compiler.ts
+class QueryCompiler {
+  dialect;
+  paramIndex = 0;
+  params = [];
+  constructor(dialect) {
+    this.dialect = dialect;
+  }
+  reset() {
+    this.paramIndex = 0;
+    this.params = [];
+  }
+  addParam(value) {
+    this.params.push(value);
+    if (this.dialect === "postgresql") {
+      return `$${++this.paramIndex}`;
+    }
+    this.paramIndex++;
+    return "?";
+  }
+  compileSelect(state) {
+    this.reset();
+    const parts = [];
+    const cols = state.selects.length > 0 ? state.selects.join(", ") : "*";
+    const distinct = state.distinct ? "DISTINCT " : "";
+    parts.push(`SELECT ${distinct}${cols}`);
+    const alias = state.alias ? ` AS ${state.alias}` : "";
+    parts.push(`FROM ${state.table}${alias}`);
+    for (const j of state.joins) {
+      parts.push(`${j.type} JOIN ${j.table} ON ${j.on}`);
+    }
+    if (state.wheres.length > 0) {
+      parts.push(`WHERE ${this.compileWheres(state.wheres)}`);
+    }
+    if (state.groupBys.length > 0) {
+      parts.push(`GROUP BY ${state.groupBys.join(", ")}`);
+    }
+    if (state.havings.length > 0) {
+      parts.push(`HAVING ${state.havings.join(" AND ")}`);
+    }
+    if (state.orders.length > 0) {
+      const orderStr = state.orders.map((o) => `${o.column} ${o.direction}`).join(", ");
+      parts.push(`ORDER BY ${orderStr}`);
+    }
+    if (state.limitVal !== undefined) {
+      parts.push(`LIMIT ${this.addParam(state.limitVal)}`);
+    }
+    if (state.offsetVal !== undefined) {
+      parts.push(`OFFSET ${this.addParam(state.offsetVal)}`);
+    }
+    if (state.lockMode === "update")
+      parts.push("FOR UPDATE");
+    if (state.lockMode === "share")
+      parts.push("FOR SHARE");
+    return { sql: parts.join(" "), params: [...this.params] };
+  }
+  compileWheres(wheres) {
+    return wheres.map((w, i) => {
+      const prefix = i === 0 ? "" : `${w.type.toUpperCase()} `;
+      if (w.raw !== undefined) {
+        if (w.rawParams) {
+          for (const p of w.rawParams) {
+            this.params.push(p);
+          }
+        }
+        return `${prefix}(${w.raw})`;
+      }
+      if (w.nested) {
+        return `${prefix}(${this.compileWheres(w.nested)})`;
+      }
+      if (w.operator === "IN" && Array.isArray(w.value)) {
+        const placeholders = w.value.map((v) => this.addParam(v)).join(", ");
+        return `${prefix}${w.column} IN (${placeholders})`;
+      }
+      if (w.operator === "NOT IN" && Array.isArray(w.value)) {
+        const placeholders = w.value.map((v) => this.addParam(v)).join(", ");
+        return `${prefix}${w.column} NOT IN (${placeholders})`;
+      }
+      if (w.operator === "IS NULL") {
+        return `${prefix}${w.column} IS NULL`;
+      }
+      if (w.operator === "IS NOT NULL") {
+        return `${prefix}${w.column} IS NOT NULL`;
+      }
+      if (w.operator === "BETWEEN") {
+        const [min, max] = w.value;
+        return `${prefix}${w.column} BETWEEN ${this.addParam(min)} AND ${this.addParam(max)}`;
+      }
+      return `${prefix}${w.column} ${w.operator} ${this.addParam(w.value)}`;
+    }).join(" ");
+  }
+  compileInsert(table, data) {
+    this.reset();
+    const keys = Object.keys(data);
+    const columns = keys.join(", ");
+    const placeholders = keys.map((k) => this.addParam(data[k])).join(", ");
+    const returning = this.dialect === "postgresql" ? " RETURNING *" : "";
+    return {
+      sql: `INSERT INTO ${table} (${columns}) VALUES (${placeholders})${returning}`,
+      params: [...this.params]
+    };
+  }
+  compileBatchInsert(table, rows) {
+    this.reset();
+    if (rows.length === 0) {
+      return { sql: "", params: [] };
+    }
+    const keys = Object.keys(rows[0]);
+    const columns = keys.join(", ");
+    const valueRows = rows.map((row) => {
+      const placeholders = keys.map((k) => this.addParam(row[k])).join(", ");
+      return `(${placeholders})`;
+    });
+    const returning = this.dialect === "postgresql" ? " RETURNING *" : "";
+    return {
+      sql: `INSERT INTO ${table} (${columns}) VALUES ${valueRows.join(", ")}${returning}`,
+      params: [...this.params]
+    };
+  }
+  compileUpdate(state, data) {
+    this.reset();
+    const sets = Object.entries(data).map(([col, val]) => `${col} = ${this.addParam(val)}`).join(", ");
+    const whereStr = state.wheres.length > 0 ? ` WHERE ${this.compileWheres(state.wheres)}` : "";
+    const returning = this.dialect === "postgresql" ? " RETURNING *" : "";
+    return {
+      sql: `UPDATE ${state.table} SET ${sets}${whereStr}${returning}`,
+      params: [...this.params]
+    };
+  }
+  compileDelete(state) {
+    this.reset();
+    const whereStr = state.wheres.length > 0 ? ` WHERE ${this.compileWheres(state.wheres)}` : "";
+    return {
+      sql: `DELETE FROM ${state.table}${whereStr}`,
+      params: [...this.params]
+    };
+  }
+  compileCount(state, column = "*") {
+    this.reset();
+    const countCol = column === "*" ? "COUNT(*)" : `COUNT(${column})`;
+    const parts = [`SELECT ${countCol} AS count`];
+    const alias = state.alias ? ` AS ${state.alias}` : "";
+    parts.push(`FROM ${state.table}${alias}`);
+    for (const j of state.joins) {
+      parts.push(`${j.type} JOIN ${j.table} ON ${j.on}`);
+    }
+    if (state.wheres.length > 0) {
+      parts.push(`WHERE ${this.compileWheres(state.wheres)}`);
+    }
+    return { sql: parts.join(" "), params: [...this.params] };
+  }
+  compileExists(state) {
+    const selectCompiled = this.compileSelect({
+      ...state,
+      selects: ["1"],
+      limitVal: 1
+    });
+    return {
+      sql: `SELECT EXISTS(${selectCompiled.sql}) as exists`,
+      params: selectCompiled.params
+    };
+  }
+}
+
+// src/database/orm/builder.ts
+class OrmQueryBuilder {
+  state;
+  compiler;
+  db;
+  rowTransformer;
+  constructor(db, table, dialect) {
+    this.db = db;
+    this.compiler = new QueryCompiler(dialect || db.getDriver());
+    this.state = {
+      table,
+      selects: [],
+      wheres: [],
+      orders: [],
+      joins: [],
+      groupBys: [],
+      havings: [],
+      distinct: false
+    };
+  }
+  clone() {
+    const cloned = new OrmQueryBuilder(this.db, this.state.table);
+    cloned.state = {
+      ...this.state,
+      wheres: [...this.state.wheres],
+      orders: [...this.state.orders],
+      joins: [...this.state.joins],
+      selects: [...this.state.selects],
+      groupBys: [...this.state.groupBys],
+      havings: [...this.state.havings]
+    };
+    cloned.compiler = this.compiler;
+    cloned.rowTransformer = this.rowTransformer;
+    return cloned;
+  }
+  setRowTransformer(fn) {
+    this.rowTransformer = fn;
+    return this;
+  }
+  select(...columns) {
+    this.state.selects = columns;
+    return this;
+  }
+  addSelect(...columns) {
+    this.state.selects.push(...columns);
+    return this;
+  }
+  distinct() {
+    this.state.distinct = true;
+    return this;
+  }
+  where(column, operatorOrValue, value) {
+    const [operator, val] = value === undefined ? ["=", operatorOrValue] : [String(operatorOrValue), value];
+    this.state.wheres.push({
+      type: "and",
+      column,
+      operator,
+      value: val
+    });
+    return this;
+  }
+  orWhere(column, operatorOrValue, value) {
+    const [operator, val] = value === undefined ? ["=", operatorOrValue] : [String(operatorOrValue), value];
+    this.state.wheres.push({
+      type: "or",
+      column,
+      operator,
+      value: val
+    });
+    return this;
+  }
+  whereRaw(sql, params) {
+    this.state.wheres.push({
+      type: "and",
+      raw: sql,
+      rawParams: params
+    });
+    return this;
+  }
+  whereIn(column, values) {
+    this.state.wheres.push({
+      type: "and",
+      column,
+      operator: "IN",
+      value: values
+    });
+    return this;
+  }
+  whereNotIn(column, values) {
+    this.state.wheres.push({
+      type: "and",
+      column,
+      operator: "NOT IN",
+      value: values
+    });
+    return this;
+  }
+  whereNull(column) {
+    this.state.wheres.push({
+      type: "and",
+      column,
+      operator: "IS NULL"
+    });
+    return this;
+  }
+  whereNotNull(column) {
+    this.state.wheres.push({
+      type: "and",
+      column,
+      operator: "IS NOT NULL"
+    });
+    return this;
+  }
+  whereBetween(column, min, max) {
+    this.state.wheres.push({
+      type: "and",
+      column,
+      operator: "BETWEEN",
+      value: [min, max]
+    });
+    return this;
+  }
+  join(table, on, type = "INNER") {
+    this.state.joins.push({ type, table, on });
+    return this;
+  }
+  leftJoin(table, on) {
+    return this.join(table, on, "LEFT");
+  }
+  rightJoin(table, on) {
+    return this.join(table, on, "RIGHT");
+  }
+  crossJoin(table) {
+    this.state.joins.push({ type: "CROSS", table, on: "" });
+    return this;
+  }
+  groupBy(...columns) {
+    this.state.groupBys.push(...columns);
+    return this;
+  }
+  having(raw, params) {
+    this.state.havings.push(raw);
+    if (params) {}
+    return this;
+  }
+  orderBy(column, direction = "ASC") {
+    this.state.orders.push({ column, direction });
+    return this;
+  }
+  orderByDesc(column) {
+    return this.orderBy(column, "DESC");
+  }
+  limit(n) {
+    this.state.limitVal = n;
+    return this;
+  }
+  offset(n) {
+    this.state.offsetVal = n;
+    return this;
+  }
+  lockForShare() {
+    this.state.lockMode = "share";
+    return this;
+  }
+  lockForUpdate() {
+    this.state.lockMode = "update";
+    return this;
+  }
+  async get() {
+    const { sql, params } = this.compiler.compileSelect(this.state);
+    const rows = await this.db.raw(sql, params);
+    return rows.map((row) => this.rowTransformer ? this.rowTransformer(row) : row);
+  }
+  async first() {
+    const results = await this.limit(1).get();
+    return results.length > 0 ? results[0] : null;
+  }
+  async firstOrFail() {
+    const result = await this.first();
+    if (!result) {
+      throw new Error(`No record found for query`);
+    }
+    return result;
+  }
+  async find(id) {
+    return this.where("id", id).first();
+  }
+  async findOrFail(id) {
+    const result = await this.find(id);
+    if (!result) {
+      throw new Error(`Record with id ${id} not found`);
+    }
+    return result;
+  }
+  async count(column = "*") {
+    const { sql, params } = this.compiler.compileCount(this.state, column);
+    const rows = await this.db.raw(sql, params);
+    return Number(rows[0]?.count ?? 0);
+  }
+  async exists() {
+    const count = await this.count();
+    return count > 0;
+  }
+  async pluck(column) {
+    const results = await this.select(String(column)).get();
+    return results.map((row) => row[column]);
+  }
+  async value(column) {
+    const result = await this.select(String(column)).first();
+    return result ? result[column] : null;
+  }
+  async paginate(page, limit) {
+    const offset = (page - 1) * limit;
+    const [data, total] = await Promise.all([
+      this.clone().offset(offset).limit(limit).get(),
+      this.clone().count()
+    ]);
+    return {
+      data,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit)
+    };
+  }
+  async insert(data) {
+    const { sql, params } = this.compiler.compileInsert(this.state.table, data);
+    if (this.db.getDriver() === "postgresql") {
+      const rows = await this.db.raw(sql, params);
+      return this.rowTransformer ? this.rowTransformer(rows[0]) : rows[0];
+    }
+    await this.db.raw(sql, params);
+    const lastId = await this.getLastInsertId();
+    const row = await this.db.raw(`SELECT * FROM ${this.state.table} WHERE id = ?`, [lastId]);
+    return this.rowTransformer ? this.rowTransformer(row[0]) : row[0];
+  }
+  async insertMany(items) {
+    const results = [];
+    for (const item of items) {
+      const result = await this.insert(item);
+      results.push(result);
+    }
+    return results;
+  }
+  async update(data) {
+    const { sql, params } = this.compiler.compileUpdate(this.state, data);
+    if (this.db.getDriver() === "postgresql") {
+      const rows = await this.db.raw(sql, params);
+      return rows.length;
+    }
+    await this.db.raw(sql, params);
+    return 0;
+  }
+  async delete() {
+    const { sql, params } = this.compiler.compileDelete(this.state);
+    await this.db.raw(sql, params);
+    return 0;
+  }
+  async getLastInsertId() {
+    const driver = this.db.getDriver();
+    if (driver === "sqlite") {
+      const row = await this.db.raw("SELECT last_insert_rowid() as id");
+      return row[0].id;
+    }
+    if (driver === "mysql") {
+      const row = await this.db.raw("SELECT LAST_INSERT_ID() as id");
+      return row[0].id;
+    }
+    throw new Error("Unexpected driver");
+  }
+}
+function query(db, table) {
+  return new OrmQueryBuilder(db, table);
+}
+// src/database/orm/casts/index.ts
+var builtInCasts = {
+  json: {
+    get(value) {
+      if (typeof value === "string") {
+        try {
+          return JSON.parse(value);
+        } catch {
+          return value;
+        }
+      }
+      return value;
+    },
+    set(value) {
+      if (typeof value === "string")
+        return value;
+      return JSON.stringify(value);
+    }
+  },
+  boolean: {
+    get(value) {
+      if (value === null || value === undefined)
+        return null;
+      if (typeof value === "boolean")
+        return value;
+      if (typeof value === "number")
+        return value !== 0;
+      if (typeof value === "string")
+        return value !== "0" && value !== "false";
+      return Boolean(value);
+    },
+    set(value) {
+      return value ? 1 : 0;
+    }
+  },
+  integer: {
+    get(value) {
+      return Number(value);
+    },
+    set(value) {
+      return Number(value);
+    }
+  },
+  float: {
+    get(value) {
+      return Number(value);
+    },
+    set(value) {
+      return Number(value);
+    }
+  },
+  date: {
+    get(value) {
+      if (!value)
+        return null;
+      if (value instanceof Date)
+        return value;
+      return new Date(String(value));
+    },
+    set(value) {
+      if (value instanceof Date) {
+        return value.toISOString().split("T")[0];
+      }
+      return String(value);
+    }
+  },
+  datetime: {
+    get(value) {
+      if (!value)
+        return null;
+      if (value instanceof Date)
+        return value;
+      return new Date(String(value));
+    },
+    set(value) {
+      if (value instanceof Date) {
+        return value.toISOString();
+      }
+      return String(value);
+    }
+  },
+  timestamp: {
+    get(value) {
+      if (!value)
+        return null;
+      if (value instanceof Date)
+        return value;
+      if (typeof value === "number")
+        return new Date(value);
+      return new Date(Number(value));
+    },
+    set(value) {
+      if (value instanceof Date) {
+        return value.getTime();
+      }
+      return Number(value);
+    }
+  }
+};
+
+class CastRegistry {
+  static deserialize(castDef, value) {
+    if (typeof castDef === "string") {
+      const castObj = builtInCasts[castDef];
+      if (!castObj) {
+        throw new Error(`Unknown cast: ${castDef}`);
+      }
+      return castObj.get(value);
+    }
+    return castDef.get(value);
+  }
+  static serialize(castDef, value) {
+    if (typeof castDef === "string") {
+      const castObj = builtInCasts[castDef];
+      if (!castObj) {
+        throw new Error(`Unknown cast: ${castDef}`);
+      }
+      return castObj.set(value);
+    }
+    return castDef.set(value);
+  }
+}
+
+// src/database/orm/model-registry.ts
+var registry = new Map;
+var defaultDb = null;
+function setDefaultDatabase(db) {
+  defaultDb = db;
+}
+function getDefaultDatabase() {
+  if (!defaultDb) {
+    throw new Error("No default database configured. Call setDefaultDatabase() before using models.");
+  }
+  return defaultDb;
+}
+function registerModelDatabase(modelName, db) {
+  registry.set(modelName, db);
+}
+function getModelDatabase(modelName) {
+  return registry.get(modelName) ?? getDefaultDatabase();
+}
+function clearModelDatabaseRegistry() {
+  registry.clear();
+}
+function clearDefaultDatabase() {
+  defaultDb = null;
+}
+
+// src/database/orm/relationships/base.ts
+class Relationship {
+  parentModel;
+  relatedClass;
+  foreignKey;
+  localKey;
+  query;
+  db;
+  constructor(parentModel, relatedClass, foreignKey, localKey = "id") {
+    this.parentModel = parentModel;
+    this.relatedClass = relatedClass;
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    this.db = getModelDatabase(relatedClass.name);
+    this.query = new OrmQueryBuilder(this.db, relatedClass.table);
+    this.addConstraints();
+  }
+  initConstraints() {
+    this.query = new OrmQueryBuilder(this.db, this.relatedClass.table);
+    this.addConstraints();
+  }
+  resetQuery() {
+    this.query = new OrmQueryBuilder(this.db, this.relatedClass.table);
+  }
+  where(column, operator, value) {
+    this.query.where(column, operator, value);
+    return this;
+  }
+  orWhere(column, operator, value) {
+    this.query.orWhere(column, operator, value);
+    return this;
+  }
+  orderBy(column, direction) {
+    this.query.orderBy(column, direction);
+    return this;
+  }
+  limit(n) {
+    this.query.limit(n);
+    return this;
+  }
+  async get() {
+    const rows = await this.query.get();
+    return this.relatedClass.hydrate(rows);
+  }
+  async first() {
+    const rows = await this.query.limit(1).get();
+    if (rows.length === 0)
+      return null;
+    return this.relatedClass.hydrate([rows[0]])[0];
+  }
+  async count() {
+    return this.query.count();
+  }
+  async exists() {
+    return this.query.exists();
+  }
+  async create(data) {
+    const model_data = {
+      ...data,
+      [this.foreignKey]: this.parentModel.getAttribute(this.localKey)
+    };
+    return this.relatedClass.create(model_data);
+  }
+}
+// src/database/orm/relationships/has-one.ts
+class HasOne extends Relationship {
+  addConstraints() {
+    const parentId = this.parentModel.getAttribute(this.localKey);
+    this.query.where(this.foreignKey, parentId);
+  }
+  addEagerConstraints(parents) {
+    const ids = parents.map((p) => p.getAttribute(this.localKey));
+    this.query.whereIn(this.foreignKey, ids);
+  }
+  match(parents, results, relation) {
+    const grouped = new Map;
+    for (const result of results) {
+      const key = result.getAttribute(this.foreignKey);
+      grouped.set(key, result);
+    }
+    for (const parent of parents) {
+      const key = parent.getAttribute(this.localKey);
+      const related = grouped.get(key) ?? null;
+      parent._relations.set(relation, related);
+    }
+  }
+  async getResults() {
+    return this.first();
+  }
+}
+// src/database/orm/relationships/has-many.ts
+class HasMany extends Relationship {
+  addConstraints() {
+    const parentId = this.parentModel.getAttribute(this.localKey);
+    this.query.where(this.foreignKey, parentId);
+  }
+  addEagerConstraints(parents) {
+    const ids = parents.map((p) => p.getAttribute(this.localKey));
+    this.query.whereIn(this.foreignKey, ids);
+  }
+  match(parents, results, relation) {
+    const grouped = new Map;
+    for (const result of results) {
+      const key = result.getAttribute(this.foreignKey);
+      if (!grouped.has(key)) {
+        grouped.set(key, []);
+      }
+      grouped.get(key).push(result);
+    }
+    for (const parent of parents) {
+      const key = parent.getAttribute(this.localKey);
+      const related = grouped.get(key) ?? [];
+      parent._relations.set(relation, related);
+    }
+  }
+  async getResults() {
+    return this.get();
+  }
+}
+// src/database/orm/relationships/belongs-to.ts
+class BelongsTo extends Relationship {
+  constructor(parentModel, relatedClass, foreignKey, ownerKey = "id") {
+    super(parentModel, relatedClass, foreignKey, ownerKey);
+  }
+  addConstraints() {
+    const parentForeignId = this.parentModel.getAttribute(this.foreignKey);
+    this.query.where(this.localKey, parentForeignId);
+  }
+  addEagerConstraints(parents) {
+    const ids = parents.map((p) => p.getAttribute(this.foreignKey));
+    this.query.whereIn(this.localKey, ids);
+  }
+  match(parents, results, relation) {
+    const grouped = new Map;
+    for (const result of results) {
+      const key = result.getAttribute(this.localKey);
+      grouped.set(key, result);
+    }
+    for (const parent of parents) {
+      const key = parent.getAttribute(this.foreignKey);
+      const related = grouped.get(key) ?? null;
+      parent._relations.set(relation, related);
+    }
+  }
+  async getResults() {
+    return this.first();
+  }
+}
+// src/database/orm/relationships/belongs-to-many.ts
+class BelongsToMany extends Relationship {
+  pivotTable;
+  foreignPivotKey;
+  relatedPivotKey;
+  parentKey;
+  relatedKey;
+  pivotData = new Set;
+  constructor(parentModel, relatedClass, pivotTable, foreignPivotKey, relatedPivotKey, parentKey = "id", relatedKey = "id") {
+    super(parentModel, relatedClass, foreignPivotKey, parentKey);
+    this.pivotTable = pivotTable;
+    this.foreignPivotKey = foreignPivotKey;
+    this.relatedPivotKey = relatedPivotKey;
+    this.parentKey = parentKey;
+    this.relatedKey = relatedKey;
+    this.initConstraints();
+  }
+  addConstraints() {
+    if (!this.pivotTable)
+      return;
+    const parentId = this.parentModel.getAttribute(this.parentKey);
+    this.query.join(this.pivotTable, `${this.pivotTable}.${this.relatedPivotKey} = ${this.relatedClass.table}.${this.relatedKey}`);
+    this.query.where(`${this.pivotTable}.${this.foreignPivotKey}`, parentId);
+  }
+  addEagerConstraints(parents) {
+    const ids = parents.map((p) => p.getAttribute(this.parentKey));
+    this.query.whereIn(`${this.pivotTable}.${this.foreignPivotKey}`, ids);
+  }
+  match(parents, results, relation) {
+    const grouped = new Map;
+    for (const result of results) {
+      const parentId = result.getAttribute(this.foreignPivotKey);
+      if (!grouped.has(parentId)) {
+        grouped.set(parentId, []);
+      }
+      grouped.get(parentId).push(result);
+    }
+    for (const parent of parents) {
+      const key = parent.getAttribute(this.parentKey);
+      const related = grouped.get(key) ?? [];
+      parent._relations.set(relation, related);
+    }
+  }
+  withPivot(...columns) {
+    for (const col of columns) {
+      this.pivotData.add(col);
+    }
+    return this;
+  }
+  async attach(ids, pivotData) {
+    const idArray = Array.isArray(ids) ? ids : [ids];
+    const parentId = this.parentModel.getAttribute(this.parentKey);
+    const db = getModelDatabase(this.relatedClass.name);
+    for (const id of idArray) {
+      const data = {
+        [this.foreignPivotKey]: parentId,
+        [this.relatedPivotKey]: id,
+        ...pivotData
+      };
+      const columns = Object.keys(data).join(", ");
+      const placeholders = Object.keys(data).map(() => "?").join(", ");
+      const values = Object.values(data);
+      await db.raw(`INSERT INTO ${this.pivotTable} (${columns}) VALUES (${placeholders})`, values);
+    }
+  }
+  async detach(ids) {
+    const parentId = this.parentModel.getAttribute(this.parentKey);
+    const db = getModelDatabase(this.relatedClass.name);
+    let builder = new OrmQueryBuilder(db, this.pivotTable).where(this.foreignPivotKey, parentId);
+    if (ids) {
+      const idArray = Array.isArray(ids) ? ids : [ids];
+      builder = builder.whereIn(this.relatedPivotKey, idArray);
+    }
+    await builder.delete();
+  }
+  async sync(ids, detaching = true) {
+    if (detaching) {
+      await this.detach();
+    }
+    await this.attach(ids);
+  }
+  async toggle(ids) {
+    const idArray = Array.isArray(ids) ? ids : [ids];
+    const attached = await this.get();
+    const attachedIds = attached.map((m) => m.getAttribute(this.relatedKey));
+    const toAttach = idArray.filter((id) => !attachedIds.includes(id));
+    const toDetach = attachedIds.filter((id) => idArray.includes(id));
+    await Promise.all([this.attach(toAttach), this.detach(toDetach)]);
+  }
+  async updateExistingPivot(id, data) {
+    const parentId = this.parentModel.getAttribute(this.parentKey);
+    const db = getModelDatabase(this.relatedClass.name);
+    await new OrmQueryBuilder(db, this.pivotTable).where(this.foreignPivotKey, parentId).where(this.relatedPivotKey, id).update(data);
+  }
+  async getResults() {
+    return this.get();
+  }
+}
+// src/database/orm/model.ts
+class ModelNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ModelNotFoundError";
+  }
+}
+
+class ModelOperationAbortedError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ModelOperationAbortedError";
+  }
+}
+
+class Model {
+  static table;
+  static primaryKey = "id";
+  static timestamps = true;
+  static createdAtColumn = "created_at";
+  static updatedAtColumn = "updated_at";
+  static softDeletes = false;
+  static deletedAtColumn = "deleted_at";
+  static fillable = [];
+  static guarded = [];
+  static casts = {};
+  static scopeRegistry = new Map;
+  static hookRegistry = new Map;
+  _attributes = {};
+  _original = {};
+  _relations = new Map;
+  _exists = false;
+  _isDirty = false;
+  constructor(attributes) {
+    if (attributes) {
+      this.fill(attributes);
+    }
+    return new Proxy(this, {
+      get: (target, prop) => {
+        if (prop.startsWith("_")) {
+          return target[prop];
+        }
+        if (target._relations.has(prop)) {
+          return target._relations.get(prop);
+        }
+        if (typeof target[prop] === "function") {
+          return target[prop];
+        }
+        return target.getAttribute(prop);
+      },
+      set: (target, prop, value) => {
+        if (prop.startsWith("_") || prop in Object.getPrototypeOf(target)) {
+          target[prop] = value;
+          return true;
+        }
+        target.setAttribute(prop, value);
+        return true;
+      },
+      has: (target, prop) => {
+        if (prop.startsWith("_") || prop in Object.getPrototypeOf(target)) {
+          return true;
+        }
+        if (target._relations.has(prop)) {
+          return true;
+        }
+        return target._attributes.hasOwnProperty(prop);
+      }
+    });
+  }
+  static query() {
+    return new ModelQueryBuilder(this);
+  }
+  static async find(id) {
+    return this.query().where("id", id).first();
+  }
+  static async findOrFail(id) {
+    const result = await this.find(id);
+    if (!result) {
+      throw new ModelNotFoundError(`${this.name} with id ${id} not found`);
+    }
+    return result;
+  }
+  static where(column, operator, value) {
+    return this.query().where(column, operator, value);
+  }
+  static async all() {
+    return this.query().get();
+  }
+  static async create(data) {
+    const instance = new this;
+    instance.fill(data);
+    await instance.save();
+    return instance;
+  }
+  static async firstOrCreate(conditions, values) {
+    let instance = await this.query();
+    for (const [key, value] of Object.entries(conditions)) {
+      instance = instance.where(key, value);
+    }
+    const found = await instance.first();
+    if (found)
+      return found;
+    const create_data = { ...conditions, ...values };
+    return this.create(create_data);
+  }
+  static async updateOrCreate(conditions, values) {
+    let query2 = this.query();
+    for (const [key, value] of Object.entries(conditions)) {
+      query2 = query2.where(key, value);
+    }
+    const found = await query2.first();
+    if (found) {
+      await found.fill(values).save();
+      return found;
+    }
+    return this.create({ ...conditions, ...values });
+  }
+  getAttribute(key) {
+    return this._attributes[key];
+  }
+  setAttribute(key, value) {
+    this._attributes[key] = value;
+    this._isDirty = true;
+  }
+  fill(data) {
+    const guarded = this.constructor.guarded;
+    const fillable = this.constructor.fillable;
+    for (const [key, value] of Object.entries(data)) {
+      if (guarded.includes("*"))
+        break;
+      if (guarded.includes(key))
+        continue;
+      if (fillable.length > 0 && !fillable.includes(key))
+        continue;
+      this.setAttribute(key, value);
+    }
+    return this;
+  }
+  forceFill(data) {
+    for (const [key, value] of Object.entries(data)) {
+      this.setAttribute(key, value);
+    }
+    return this;
+  }
+  toJSON() {
+    return { ...this._attributes };
+  }
+  toObject() {
+    return { ...this._attributes };
+  }
+  isDirty(key) {
+    if (key) {
+      return this._attributes[key] !== this._original[key];
+    }
+    return this._isDirty;
+  }
+  isClean(key) {
+    return !this.isDirty(key);
+  }
+  getDirty() {
+    const dirty = {};
+    for (const [key, value] of Object.entries(this._attributes)) {
+      if (value !== this._original[key]) {
+        dirty[key] = value;
+      }
+    }
+    return dirty;
+  }
+  getOriginal(key) {
+    if (key) {
+      return this._original[key];
+    }
+    return { ...this._original };
+  }
+  async save() {
+    const modelClass = this.constructor;
+    const db = getModelDatabase(modelClass.name);
+    if (this._exists) {
+      if (!this.isDirty())
+        return;
+      const dirty = this.getDirty();
+      if (modelClass.timestamps) {
+        const now = new Date().toISOString();
+        dirty[modelClass.updatedAtColumn] = now;
+        this._attributes[modelClass.updatedAtColumn] = now;
+      }
+      const builder = new OrmQueryBuilder(db, modelClass.table);
+      builder.where(modelClass.primaryKey, this.getAttribute(modelClass.primaryKey));
+      await builder.update(dirty);
+      this._original = { ...this._attributes };
+      this._isDirty = false;
+    } else {
+      const data = { ...this._attributes };
+      if (modelClass.timestamps) {
+        const now = new Date().toISOString();
+        data[modelClass.createdAtColumn] = now;
+        data[modelClass.updatedAtColumn] = now;
+      }
+      const builder = new OrmQueryBuilder(db, modelClass.table);
+      const result = await builder.insert(data);
+      this._attributes = result;
+      this._original = { ...result };
+      this._exists = true;
+      this._isDirty = false;
+    }
+  }
+  async delete() {
+    const modelClass = this.constructor;
+    const db = getModelDatabase(modelClass.name);
+    if (modelClass.softDeletes) {
+      this.setAttribute(modelClass.deletedAtColumn, new Date().toISOString());
+      await this.save();
+    } else {
+      const builder = new OrmQueryBuilder(db, modelClass.table);
+      builder.where(modelClass.primaryKey, this.getAttribute(modelClass.primaryKey));
+      await builder.delete();
+    }
+  }
+  async restore() {
+    const modelClass = this.constructor;
+    if (!modelClass.softDeletes) {
+      throw new Error(`Model ${modelClass.name} does not use soft deletes`);
+    }
+    this.setAttribute(modelClass.deletedAtColumn, null);
+    await this.save();
+  }
+  async refresh() {
+    const modelClass = this.constructor;
+    const id = this.getAttribute(modelClass.primaryKey);
+    const fresh = await modelClass.query().find(id);
+    if (fresh) {
+      this._attributes = fresh._attributes;
+      this._original = { ...fresh._attributes };
+    }
+  }
+  async fresh() {
+    const modelClass = this.constructor;
+    const id = this.getAttribute(modelClass.primaryKey);
+    return modelClass.query().find(id);
+  }
+  hasOne(relatedClass, foreignKey, localKey) {
+    return new HasOne(this, relatedClass, foreignKey, localKey ?? "id");
+  }
+  hasMany(relatedClass, foreignKey, localKey) {
+    return new HasMany(this, relatedClass, foreignKey, localKey ?? "id");
+  }
+  belongsTo(relatedClass, foreignKey, ownerKey) {
+    return new BelongsTo(this, relatedClass, foreignKey, ownerKey ?? "id");
+  }
+  belongsToMany(relatedClass, pivotTable, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+    return new BelongsToMany(this, relatedClass, pivotTable, foreignPivotKey, relatedPivotKey, parentKey ?? "id", relatedKey ?? "id");
+  }
+  static hydrate(rows) {
+    return rows.map((row) => {
+      const instance = new this;
+      instance._attributes = {};
+      for (const [key, value] of Object.entries(row)) {
+        const castDef = this.casts[key];
+        instance._attributes[key] = castDef ? CastRegistry.deserialize(castDef, value) : value;
+      }
+      instance._original = { ...instance._attributes };
+      instance._exists = true;
+      return instance;
+    });
+  }
+  static on(hookName, callback) {
+    if (!Model.hookRegistry.has(this.name)) {
+      Model.hookRegistry.set(this.name, new Map);
+    }
+    const registry2 = Model.hookRegistry.get(this.name);
+    if (!registry2.has(hookName)) {
+      registry2.set(hookName, []);
+    }
+    registry2.get(hookName).push(callback);
+  }
+  static getHookCallbacks(hookName) {
+    const registry2 = Model.hookRegistry.get(this.name);
+    return registry2?.get(hookName) ?? [];
+  }
+  static booting() {}
+}
+
+class ModelQueryBuilder extends OrmQueryBuilder {
+  modelClass;
+  eagerLoads = new Map;
+  constructor(modelClass) {
+    const db = getModelDatabase(modelClass.name);
+    super(db, modelClass.table);
+    this.modelClass = modelClass;
+  }
+  with(relation, callback) {
+    this.eagerLoads.set(relation, callback ?? null);
+    return this;
+  }
+  async get() {
+    const rows = await super.get();
+    const models = this.modelClass.hydrate(rows);
+    for (const [relation, callback] of this.eagerLoads) {
+      await this.loadRelation(models, relation, callback);
+    }
+    return models;
+  }
+  async first() {
+    const rows = await OrmQueryBuilder.prototype.get.call(this);
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    const models = this.modelClass.hydrate([row]);
+    for (const [relation, callback] of this.eagerLoads) {
+      await this.loadRelation(models, relation, callback ?? undefined);
+    }
+    return models[0] ?? null;
+  }
+  async paginate(page, limit) {
+    const offset = (page - 1) * limit;
+    const [data, total] = await Promise.all([
+      this.clone().offset(offset).limit(limit).get(),
+      this.clone().count()
+    ]);
+    return {
+      data,
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit)
+    };
+  }
+  async firstOrCreate(conditions, values) {
+    const query2 = new ModelQueryBuilder(this.modelClass);
+    for (const [key, value] of Object.entries(conditions)) {
+      query2.where(key, value);
+    }
+    const found = await query2.first();
+    if (found)
+      return found;
+    const createData = { ...conditions, ...values };
+    return this.modelClass.create(createData);
+  }
+  async updateOrCreate(conditions, values) {
+    const query2 = new ModelQueryBuilder(this.modelClass);
+    for (const [key, value] of Object.entries(conditions)) {
+      query2.where(key, value);
+    }
+    const found = await query2.first();
+    if (found) {
+      found.fill(values);
+      await found.save();
+      return found;
+    }
+    const createData = { ...conditions, ...values };
+    return this.modelClass.create(createData);
+  }
+  async loadRelation(models, relation, callback) {
+    if (models.length === 0)
+      return;
+    const dotIndex = relation.indexOf(".");
+    if (dotIndex !== -1) {
+      const head = relation.substring(0, dotIndex);
+      const tail = relation.substring(dotIndex + 1);
+      await this.loadRelation(models, head, undefined);
+      const intermediates = models.flatMap((m) => m._relations.get(head) ?? []);
+      if (intermediates.length === 0)
+        return;
+      const intermediateModelClass = intermediates[0].constructor;
+      const intermediateBuilder = new ModelQueryBuilder(intermediateModelClass);
+      await intermediateBuilder.loadRelation(intermediates, tail, callback);
+      return;
+    }
+    const representative = models[0];
+    const relationMethod = representative[relation];
+    if (!relationMethod || typeof relationMethod !== "function") {
+      throw new Error(`Relation "${relation}" not found on ${this.modelClass.name}`);
+    }
+    const relationship = relationMethod.call(representative);
+    relationship.resetQuery();
+    relationship.addEagerConstraints(models);
+    if (callback) {
+      callback(relationship.query);
+    }
+    const rawRows = await relationship.query.get();
+    const related = relationship.relatedClass.hydrate(rawRows);
+    relationship.match(models, related, relation);
+  }
+  static createScoped(modelClass) {
+    const builder = new ModelQueryBuilder(modelClass);
+    return new Proxy(builder, {
+      get: (target, prop) => {
+        if (typeof prop === "string" && prop.startsWith("scope")) {
+          const methodName = `scope${prop.charAt(5).toUpperCase()}${prop.slice(6)}`;
+          if (typeof modelClass[methodName] === "function") {
+            return (...args) => {
+              return modelClass[methodName](target, ...args);
+            };
+          }
+        }
+        return target[prop];
+      }
+    });
+  }
+}
+// src/database/orm/scopes/index.ts
+class ScopeRegistry {
+  globalScopes = new Map;
+  addGlobalScope(name, scope) {
+    this.globalScopes.set(name, scope);
+  }
+  removeGlobalScope(name) {
+    this.globalScopes.delete(name);
+  }
+  getGlobalScopes() {
+    return Array.from(this.globalScopes.values());
+  }
+  clearGlobalScopes() {
+    this.globalScopes.clear();
+  }
+  hasGlobalScope(name) {
+    return this.globalScopes.has(name);
+  }
+}
+
+class SoftDeleteScope {
+  apply(query2) {
+    query2.whereNull("deleted_at");
+  }
+}
+// src/database/orm/hooks/index.ts
+class HookRunner {
+  modelClass;
+  hooks = new Map;
+  constructor(modelClass) {
+    this.modelClass = modelClass;
+    this.initializeHooks();
+  }
+  initializeHooks() {}
+  on(hookName, callback) {
+    if (!this.hooks.has(hookName)) {
+      this.hooks.set(hookName, []);
+    }
+    this.hooks.get(hookName).push(callback);
+  }
+  async run(hookName, model) {
+    const callbacks = this.hooks.get(hookName) ?? [];
+    for (const callback of callbacks) {
+      const result = await callback(model);
+      if (result === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+class Model2 {
+  static hookRegistry = new Map;
+  static getHookRegistry(modelName) {
+    if (!Model2.hookRegistry.has(modelName)) {
+      Model2.hookRegistry.set(modelName, new Map);
+    }
+    return Model2.hookRegistry.get(modelName);
+  }
+  static on(hookName, callback) {
+    const registry2 = Model2.getHookRegistry(this.name);
+    if (!registry2.has(hookName)) {
+      registry2.set(hookName, []);
+    }
+    registry2.get(hookName).push(callback);
+  }
+  static getHookCallbacks(hookName) {
+    const registry2 = Model2.getHookRegistry(this.name);
+    return registry2.get(hookName) ?? [];
+  }
+}
+export {
+  setDefaultDatabase,
+  registerModelDatabase,
+  query,
+  getModelDatabase,
+  getDefaultDatabase,
+  clearModelDatabaseRegistry,
+  clearDefaultDatabase,
+  SoftDeleteScope,
+  ScopeRegistry,
+  Relationship,
+  QueryCompiler,
+  OrmQueryBuilder,
+  ModelQueryBuilder,
+  ModelOperationAbortedError,
+  ModelNotFoundError,
+  Model,
+  HookRunner,
+  HasOne,
+  HasMany,
+  CastRegistry,
+  BelongsToMany,
+  BelongsTo
+};