@h3ravel/arquebus 0.1.4

package/dist/index.js

@@ -0,0 +1,4513 @@
+// src/migrations/migration-repository.js
+var MigrationRepository = class {
+  resolver;
+  table;
+  connection = null;
+  constructor(resolver, table) {
+    this.resolver = resolver;
+    this.table = table;
+  }
+  async getRan() {
+    return await this.getTable().orderBy("batch", "asc").orderBy("migration", "asc").pluck("migration");
+  }
+  async getMigrations(steps) {
+    const query = this.getTable().where("batch", ">=", "1");
+    return await query.orderBy("batch", "desc").orderBy("migration", "desc").take(steps).get();
+  }
+  async getMigrationsByBatch(batch) {
+    return await this.getTable().where("batch", batch).orderBy("migration", "desc").get();
+  }
+  async getLast() {
+    const query = this.getTable().where("batch", await this.getLastBatchNumber());
+    return await query.orderBy("migration", "desc").get();
+  }
+  async getMigrationBatches() {
+    const migrations = await this.getTable().select("batch", "migration").orderBy("batch", "asc").orderBy("migration", "asc").get();
+    const migrationBatches = {};
+    migrations.map((migration) => {
+      migrationBatches[migration.migration] = migration.batch;
+    });
+    return migrationBatches;
+  }
+  async log(file, batch) {
+    await this.getTable().insert({
+      migration: file,
+      batch
+    });
+  }
+  async delete(migration) {
+    await this.getTable().where("migration", migration.migration).delete();
+  }
+  async getNextBatchNumber() {
+    return await this.getLastBatchNumber() + 1;
+  }
+  async getLastBatchNumber() {
+    return await this.getTable().max("batch");
+  }
+  async createRepository() {
+    const schema = this.getConnection().schema;
+    await schema.createTable(this.table, function(table) {
+      table.increments("id");
+      table.string("migration");
+      table.integer("batch");
+    });
+  }
+  repositoryExists() {
+    const schema = this.getConnection().schema;
+    return schema.hasTable(this.table);
+  }
+  async deleteRepository() {
+    const schema = this.getConnection().schema;
+    await schema.drop(this.table);
+  }
+  getTable() {
+    return this.getConnection().table(this.table);
+  }
+  getConnection() {
+    return this.resolver.connection(this.connection);
+  }
+  setSource(name) {
+    this.connection = name;
+  }
+};
+var migration_repository_default = MigrationRepository;
+
+// src/migrations/migrator.js
+import * as color from "colorette";
+import fs from "fs";
+import path from "path";
+import { promisify } from "util";
+async function glob(folderPath) {
+  const files = await promisify(fs.readdir)(folderPath);
+  const allFiles = [];
+  for (const file of files) {
+    const filePath = `${folderPath}/${file}`;
+    const stats = await promisify(fs.stat)(filePath);
+    if (stats.isFile()) {
+      allFiles.push(filePath);
+    } else if (stats.isDirectory()) {
+      const subFiles = await glob(filePath);
+      allFiles.push(...subFiles);
+    }
+  }
+  return allFiles;
+}
+var Migrator = class {
+  events = null;
+  repository;
+  files;
+  resolver;
+  connection = null;
+  paths = [];
+  output = null;
+  constructor(repository, resolver = null, files = null, dispatcher = null) {
+    this.repository = repository;
+    this.files = files;
+    this.resolver = resolver;
+    this.events = dispatcher;
+  }
+  async run(paths = [], options = {}) {
+    const files = await this.getMigrationFiles(paths);
+    const ran = await this.repository.getRan();
+    const migrations = this.pendingMigrations(files, ran);
+    await this.runPending(migrations, options);
+    return migrations;
+  }
+  pendingMigrations(files, ran) {
+    return Object.values(files).filter((file) => !ran.includes(this.getMigrationName(file)));
+  }
+  async runPending(migrations, options = {}) {
+    if (migrations.length === 0) {
+      this.write("Nothing to migrate");
+      return;
+    }
+    let batch = await this.repository.getNextBatchNumber();
+    const pretend = options.pretend || false;
+    const step = options.step || false;
+    this.write("Running migrations.");
+    for (const file of migrations) {
+      await this.runUp(file, batch, pretend);
+      if (step) {
+        batch++;
+      }
+    }
+  }
+  async runUp(file, batch, pretend) {
+    const migration = this.resolvePath(file);
+    const name = this.getMigrationName(file);
+    await this.writeTask(name, () => this.runMigration(migration, "up"));
+    await this.repository.log(name, batch);
+  }
+  async rollback(paths = [], options = {}) {
+    const migrations = await this.getMigrationsForRollback(options);
+    if (migrations.length === 0) {
+      this.write("Nothing to rollback.");
+      return [];
+    }
+    return await this.rollbackMigrations(migrations, paths, options);
+  }
+  async getMigrationsForRollback(options) {
+    if (options.step > 0) {
+      return await this.repository.getMigrations(options.step);
+    }
+    if (options.batch > 0) {
+      return await this.repository.getMigrationsByBatch(options.batch);
+    }
+    return await this.repository.getLast();
+  }
+  async rollbackMigrations(migrations, paths, options) {
+    const rolledBack = [];
+    const files = await this.getMigrationFiles(paths);
+    this.write("Rolling back migrations.");
+    for (const migration of migrations) {
+      const file = files[migration.migration];
+      if (!file) {
+        this.writeTwoColumns(migration.migration, color.yellow("Migration not found"));
+        continue;
+      }
+      rolledBack.push(file);
+      await this.runDown(file, migration, options.pretend || false);
+    }
+    return rolledBack;
+  }
+  async runDown(file, migration, pretend) {
+    const instance = this.resolvePath(file);
+    const name = this.getMigrationName(file);
+    await this.writeTask(name, () => this.runMigration(instance, "down"));
+    await this.repository.delete(migration);
+  }
+  reset(paths = [], pretend = false) {
+    const migrations = this.repository.getRan().reverse();
+    if (migrations.length === 0) {
+      this.write(Info, "Nothing to rollback.");
+      return [];
+    }
+    return this.resetMigrations(migrations, paths, pretend);
+  }
+  resetMigrations(migrations, paths, pretend = false) {
+    migrations = migrations.map((m) => ({ migration: m }));
+    return this.rollbackMigrations(migrations, paths, { pretend });
+  }
+  async runMigration(migration, method) {
+    const connection = this.resolveConnection(migration.getConnection());
+    const callback = async (trx) => {
+      if (typeof migration[method] === "function") {
+        await this.runMethod(trx, migration, method);
+      }
+    };
+    if (migration.withinTransaction) {
+      await connection.transaction(callback);
+    } else {
+      await callback(connection);
+    }
+  }
+  async runMethod(connection, migration, method) {
+    try {
+      await migration[method](connection.schema, connection);
+    } finally {
+    }
+  }
+  resolvePath(path3) {
+    return new migrationClass();
+  }
+  getMigrationClass(migrationName) {
+    return migrationName.split("_").slice(4).map((str) => str.charAt(0).toUpperCase() + str.slice(1)).join("");
+  }
+  async getMigrationFiles(paths) {
+    const files = [];
+    for (const path3 of paths) {
+      if (path3.endsWith(".js")) {
+        files.push(path3);
+        continue;
+      }
+      files.push(...await glob(path3));
+    }
+    return files.filter(Boolean).reduce((result, file) => {
+      result[this.getMigrationName(file)] = file;
+      return result;
+    }, {});
+  }
+  getMigrationName(filePath) {
+    return path.basename(filePath).replace(".js", "");
+  }
+  path(path3) {
+    this.paths = Array.from(/* @__PURE__ */ new Set([...this.paths, path3]));
+  }
+  getPaths() {
+    return this.paths;
+  }
+  getConnection() {
+    return this.connection;
+  }
+  resolveConnection(connection) {
+    return this.resolver.connection(connection || this.connection);
+  }
+  getRepository() {
+    return this.repository;
+  }
+  repositoryExists() {
+    return this.repository.repositoryExists();
+  }
+  async hasRunAnyMigrations() {
+    const ran = await this.repository.getRan();
+    const exists = await this.repositoryExists();
+    return exists && ran.length > 0;
+  }
+  deleteRepository() {
+    this.repository.deleteRepository();
+  }
+  setOutput(output) {
+    this.output = output;
+    return this;
+  }
+  write(...args) {
+    if (this.output) {
+      console.log(...args);
+    }
+  }
+  writeTwoColumns(name, ...args) {
+    const value = args.join(" ");
+    const regex = /\x1b\[\d+m/g;
+    const width = Math.min(process.stdout.columns, 100);
+    const dots = Math.max(width - name.replace(regex, "").length - value.replace(regex, "").length - 10, 0);
+    return this.write(name, color.gray(".".repeat(dots)), value);
+  }
+  async writeTask(description, task) {
+    const startTime = process.hrtime();
+    let result = false;
+    try {
+      result = await (task || (() => true))();
+    } catch (e) {
+      throw e;
+    } finally {
+      const endTime = process.hrtime(startTime);
+      const duration = (endTime[0] * 1e9 + endTime[1]) / 1e6;
+      this.writeTwoColumns(color.green(description), color.gray(`${Math.floor(duration)}ms`), result !== false ? color.green("\u2714") : color.red("\u2718"));
+    }
+  }
+};
+var migrator_default = Migrator;
+
+// src/utils.js
+import { camel, dash, snake, trim } from "radashi";
+import advancedFormat from "dayjs/plugin/advancedFormat";
+import dayjs from "dayjs";
+dayjs.extend(advancedFormat);
+var now = (format = "YYYY-MM-DD HH:mm:ss") => dayjs().format(format);
+var getRelationName = (relationMethod) => {
+  return snake(relationMethod.substring(8));
+};
+var getScopeName = (scopeMethod) => {
+  return snake(scopeMethod.substring(5));
+};
+var getRelationMethod = (relation) => {
+  return camel(`relation_${relation}`);
+};
+var getScopeMethod = (scope) => {
+  return camel(`scope_${scope}`);
+};
+var getAttrMethod = (attr) => {
+  return camel(`attribute_${attr}`);
+};
+var getGetterMethod = (attr) => {
+  return camel(`get_${attr}_attribute`);
+};
+var getSetterMethod = (attr) => {
+  return camel(`set_${attr}_attribute`);
+};
+var getAttrName = (attrMethod) => {
+  return attrMethod.substring(3, attrMethod.length - 9).toLowerCase();
+};
+var tap = (instance, callback) => {
+  const result = callback(instance);
+  return result instanceof Promise ? result.then(() => instance) : instance;
+};
+function compose(Base, ...mixins) {
+  return mixins.reduce(
+    (cls, mixin) => mixin(cls),
+    Base
+  );
+}
+var flattenDeep = (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
+var kebabCase = (str) => trim(dash(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
+var snakeCase = (str) => trim(snake(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
+
+// src/casts/attribute.js
+var Attribute = class _Attribute {
+  get;
+  set;
+  withCaching = false;
+  withObjectCaching = true;
+  constructor({ get: get2 = null, set: set2 = null }) {
+    this.get = get2;
+    this.set = set2;
+  }
+  static make(get2 = null, set2 = null) {
+    return new _Attribute(get2, set2);
+  }
+  static get(get2) {
+    return new _Attribute(get2);
+  }
+  static set(set2) {
+    return new _Attribute(null, set2);
+  }
+  withoutObjectCaching() {
+    this.withObjectCaching = false;
+    return this;
+  }
+  shouldCache() {
+    this.withCaching = true;
+    return this;
+  }
+};
+var attribute_default = Attribute;
+
+// src/arquebus.js
+import Knex from "knex";
+
+// src/relations/relation.js
+var Relation = class {
+  query;
+  parent;
+  related;
+  eagerKeysWereEmpty = false;
+  static constraints = true;
+  constructor(query, parent) {
+    this.query = query;
+    this.parent = parent;
+    this.related = this.query.model;
+  }
+  static extend(trait) {
+    for (const methodName in trait) {
+      this.prototype[methodName] = trait[methodName];
+    }
+  }
+  static noConstraints(callback) {
+    const previous = this.constraints;
+    this.constraints = false;
+    try {
+      return callback();
+    } finally {
+      this.constraints = previous;
+    }
+  }
+  asProxy() {
+    const handler = {
+      get: function(target, prop) {
+        if (typeof target[prop] !== "undefined") {
+          return target[prop];
+        }
+        if (typeof prop === "string") {
+          if (typeof target.query[prop] === "function") {
+            return (...args) => {
+              target.query[prop](...args);
+              return target.asProxy();
+            };
+          }
+        }
+      }
+    };
+    return new Proxy(this, handler);
+  }
+  getRelated() {
+    return this.related;
+  }
+  getKeys(models, key2) {
+    return models.map((model) => key2 ? model.attributes[key2] : model.getKey()).sort();
+  }
+  getRelationQuery() {
+    return this.query;
+  }
+  whereInEager(whereIn, key2, modelKeys, query = null) {
+    (query || this.query)[whereIn](key2, modelKeys);
+    if (modelKeys.length === 0) {
+      this.eagerKeysWereEmpty = true;
+    }
+  }
+  whereInMethod(model, key2) {
+    return "whereIn";
+    const segments = key2.split(".");
+    return model.getKeyName() === segments.pop() && ["int", "integer"].includes(model.getKeyType()) ? "whereIntegerInRaw" : "whereIn";
+  }
+  getEager() {
+    return this.eagerKeysWereEmpty ? this.query.getModel().newCollection() : this.get();
+  }
+  async get(columns = "*") {
+    return await this.query.get(columns);
+  }
+  async first(columns = "*") {
+    return await this.query.first(columns);
+  }
+  async paginate(...args) {
+    return await this.query.paginate(...args);
+  }
+  async count(...args) {
+    return await this.query.clearSelect().count(...args);
+  }
+  toSql() {
+    return this.query.toSql();
+  }
+  addConstraints() {
+  }
+  getRelationCountHash(incrementJoinCount = true) {
+    return "arquebus_reserved_" + (incrementJoinCount ? this.constructor.selfJoinCount++ : this.constructor.selfJoinCount);
+  }
+  getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+    return query.select(columns).whereColumn(this.getQualifiedParentKeyName(), "=", this.getExistenceCompareKey());
+  }
+  getRelationExistenceCountQuery(query, parentQuery) {
+    const db = this.related.getConnection();
+    return this.getRelationExistenceQuery(query, parentQuery, db.raw("count(*)"));
+  }
+  getQualifiedParentKeyName() {
+    return this.parent.getQualifiedKeyName();
+  }
+};
+var relation_default = Relation;
+
+// src/relations/concerns/supports-default-models.js
+var SupportsDefaultModels = (Relation2) => {
+  return class extends Relation2 {
+    _withDefault;
+    withDefault(callback = true) {
+      this._withDefault = callback;
+      return this;
+    }
+    getDefaultFor(parent) {
+      if (!this._withDefault) {
+        return null;
+      }
+      const instance = this.newRelatedInstanceFor(parent);
+      if (typeof this._withDefault === "function") {
+        return this._withDefault(instance, parent) || instance;
+      }
+      if (typeof this._withDefault === "object") {
+        for (const key2 in this._withDefault) {
+          instance.setAttribute(key2, this._withDefault[key2]);
+        }
+      }
+      return instance;
+    }
+  };
+};
+var supports_default_models_default = SupportsDefaultModels;
+
+// src/relations/belongs-to.js
+var BelongsTo = class extends compose(relation_default, supports_default_models_default) {
+  foreignKey;
+  ownerKey;
+  child;
+  relationName;
+  constructor(query, child, foreignKey, ownerKey, relationName) {
+    super(query, child);
+    this.foreignKey = foreignKey;
+    this.ownerKey = ownerKey;
+    this.child = child;
+    this.relationName = relationName;
+    this.addConstraints();
+    return this.asProxy();
+  }
+  async getResults() {
+    if (this.child[this.foreignKey] === null) {
+      return this.getDefaultFor(this.parent);
+    }
+    const result = await this.query.first();
+    return result || this.getDefaultFor(this.parent);
+  }
+  match(models, results, relation) {
+    const foreign = this.foreignKey;
+    const owner = this.ownerKey;
+    const dictionary = {};
+    results.map((result) => {
+      const attribute = result.attributes[owner];
+      dictionary[attribute] = result;
+    });
+    models.map((model) => {
+      const attribute = model[foreign];
+      if (dictionary[attribute] !== void 0) {
+        model.setRelation(relation, dictionary[attribute]);
+      }
+    });
+    return models;
+  }
+  getQualifiedForeignKeyName() {
+    return this.child.qualifyColumn(this.foreignKey);
+  }
+  getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+    if (parentQuery.getQuery()._single.table == query.getQuery()._single.table) {
+      return this.getRelationExistenceQueryForSelfRelation(query, parentQuery, columns);
+    }
+    return query.select(columns).whereColumn(this.getQualifiedForeignKeyName(), "=", query.qualifyColumn(this.ownerKey));
+  }
+  getRelationExistenceQueryForSelfRelation(query, parentQuery, columns = ["*"]) {
+    const hash = this.getRelationCountHash();
+    query.select(columns).from(query.getModel().getTable() + " as " + hash);
+    query.getModel().setTable(hash);
+    return query.whereColumn(hash + "." + this.ownerKey, "=", this.getQualifiedForeignKeyName());
+  }
+  initRelation(models, relation) {
+    models.map((model) => {
+      model.setRelation(relation, this.getDefaultFor(model));
+    });
+    return models;
+  }
+  addEagerConstraints(models) {
+    const key2 = `${this.related.getTable()}.${this.ownerKey}`;
+    this.query.whereIn(key2, this.getEagerModelKeys(models));
+  }
+  getEagerModelKeys(models) {
+    const keys = [];
+    models.map((model) => {
+      const value = model[this.foreignKey];
+      if (value !== null && value !== void 0) {
+        keys.push(value);
+      }
+    });
+    keys.sort();
+    return [...new Set(keys)];
+  }
+  associate(model) {
+    const ownerKey = model instanceof Model ? model.attributes[this.ownerKey] : model;
+    this.child[this.foreignKey] = ownerKey;
+    if (model instanceof Model) {
+      this.child.setRelation(this.relationName, model);
+    } else {
+      this.child.unsetRelation(this.relationName);
+    }
+    return this.child;
+  }
+  dissociate() {
+    this.child[this.foreignKey] = null;
+    return this.child.setRelation(this.relationName, null);
+  }
+  addConstraints() {
+    if (this.constructor.constraints) {
+      const table = this.related.getTable();
+      this.query.where(table + "." + this.ownerKey, "=", this.child[this.foreignKey]);
+    }
+  }
+  newRelatedInstanceFor(parent) {
+    return this.related.newInstance();
+  }
+};
+var belongs_to_default = BelongsTo;
+
+// src/relations/belongs-to-many.js
+import { isEqual, omit as omit2 } from "radashi";
+
+// src/collection.js
+import { Collection as BaseCollection, collect } from "collect.js";
+import { diff as difference, isArray, isEmpty, omit, pick } from "radashi";
+var Collection = class _Collection extends BaseCollection {
+  async load(...relations) {
+    if (this.isNotEmpty()) {
+      const query = this.first().constructor.query().with(...relations);
+      const items = await query.eagerLoadRelations(this.items);
+      return new this.constructor(items);
+    }
+    return this;
+  }
+  async loadAggregate(relations, column, action = null) {
+    if (this.isEmpty()) {
+      return this;
+    }
+    const models = (await this.first().newModelQuery().whereIn(this.first().getKeyName(), this.modelKeys()).select(this.first().getKeyName()).withAggregate(relations, column, action).get()).keyBy(this.first().getKeyName());
+    const attributes = difference(Object.keys(models.first().getAttributes()), [models.first().getKeyName()]);
+    this.each((model) => {
+      const extraAttributes = pick(models.get(model.getKey()).getAttributes(), attributes);
+      model.fill(extraAttributes).syncOriginalAttributes(attributes);
+    });
+    return this;
+  }
+  loadCount(relations) {
+    return this.loadAggregate(relations, "*", "count");
+  }
+  loadMax(relation, column) {
+    return this.loadAggregate(relation, column, "max");
+  }
+  loadMin(relation, column) {
+    return this.loadAggregate(relation, column, "min");
+  }
+  loadSum(relation, column) {
+    return this.loadAggregate(relation, column, "sum");
+  }
+  loadAvg(relation, column) {
+    return this.loadAggregate(relation, column, "avg");
+  }
+  mapThen(callback) {
+    return Promise.all(this.map(callback));
+  }
+  modelKeys() {
+    return this.all().map((item) => item.getKey());
+  }
+  contains(key2, operator = null, value = null) {
+    if (arguments.length > 1) {
+      return super.contains(key2, operator, value);
+    }
+    if (key2 instanceof model_default) {
+      return super.contains((model) => {
+        return model.is(key2);
+      });
+    }
+    return super.contains((model) => {
+      return model.getKey() == key2;
+    });
+  }
+  diff(items) {
+    const diff = new this.constructor();
+    const dictionary = this.getDictionary(items);
+    this.items.map((item) => {
+      if (dictionary[item.getKey()] === void 0) {
+        diff.add(item);
+      }
+    });
+    return diff;
+  }
+  except(keys) {
+    const dictionary = omit(this.getDictionary(), keys);
+    return new this.constructor(Object.values(dictionary));
+  }
+  intersect(items) {
+    const intersect = new this.constructor();
+    if (isEmpty(items)) {
+      return intersect;
+    }
+    const dictionary = this.getDictionary(items);
+    for (let item of this.items) {
+      if (dictionary[item.getKey()] !== void 0) {
+        intersect.add(item);
+      }
+    }
+    return intersect;
+  }
+  unique(key2 = null, strict = false) {
+    if (key2 !== null) {
+      return super.unique(key2, strict);
+    }
+    return new this.constructor(Object.values(this.getDictionary()));
+  }
+  find(key2, defaultValue = null) {
+    if (key2 instanceof model_default) {
+      key2 = key2.getKey();
+    }
+    if (isArray(key2)) {
+      if (this.isEmpty()) {
+        return new this.constructor();
+      }
+      return this.whereIn(this.first().getKeyName(), key2);
+    }
+    collect(this.items).first((model) => {
+      return model.getKey() == key2;
+    });
+    return this.items.filter((model) => {
+      return model.getKey() == key2;
+    })[0] || defaultValue;
+  }
+  async fresh(...args) {
+    if (this.isEmpty()) {
+      return new this.constructor();
+    }
+    const model = this.first();
+    const freshModels = (await model.newQuery().with(...args).whereIn(model.getKeyName(), this.modelKeys()).get()).getDictionary();
+    return this.filter((model2) => {
+      return model2.exists && freshModels[model2.getKey()] !== void 0;
+    }).map((model2) => {
+      return freshModels[model2.getKey()];
+    });
+  }
+  makeVisible(attributes) {
+    return this.each((item) => {
+      item.makeVisible(attributes);
+    });
+  }
+  makeHidden(attributes) {
+    return this.each((item) => {
+      item.makeHidden(attributes);
+    });
+  }
+  append(attributes) {
+    return this.each((item) => {
+      item.append(attributes);
+    });
+  }
+  only(keys) {
+    if (keys === null) {
+      return new _Collection(this.items);
+    }
+    const dictionary = pick(this.getDictionary(), keys);
+    return new this.constructor(Object.values(dictionary));
+  }
+  getDictionary(items = null) {
+    items = items === null ? this.items : items;
+    const dictionary = {};
+    items.map((value) => {
+      dictionary[value.getKey()] = value;
+    });
+    return dictionary;
+  }
+  toQuery() {
+    const model = this.first();
+    if (!model) {
+      throw new Error("Unable to create query for empty collection.");
+    }
+    const modelName = model.constructor.name;
+    if (this.filter((model2) => {
+      return !(model2 instanceof modelName);
+    }).isNotEmpty()) {
+      throw new Error("Unable to create query for collection with mixed types.");
+    }
+    return model.newModelQuery().whereKey(this.modelKeys());
+  }
+  toData() {
+    return this.all().map((item) => typeof item.toData == "function" ? item.toData() : item);
+  }
+  toJSON() {
+    return this.toData();
+  }
+  toJson(...args) {
+    return JSON.stringify(this.toData(), ...args);
+  }
+  [Symbol.iterator]() {
+    const items = this.items;
+    let length = this.items.length;
+    let n = 0;
+    return {
+      next() {
+        return n < length ? {
+          value: items[n++],
+          done: false
+        } : {
+          done: true
+        };
+      }
+    };
+  }
+};
+var collection_default = Collection;
+
+// src/relations/concerns/interacts-with-pivot-table.js
+import { diff as difference2, isArray as isArray2, merge } from "radashi";
+import { collect as collect2 } from "collect.js";
+var InteractsWithPivotTable = (Relation2) => {
+  return class extends Relation2 {
+    newExistingPivot(attributes = []) {
+      return this.newPivot(attributes, true);
+    }
+    newPivot(attributes = [], exists = false) {
+      const pivot = this.related.newPivot(this.parent, attributes, this.getTable(), exists, this.using);
+      return pivot.setPivotKeys(this.foreignPivotKey, this.relatedPivotKey);
+    }
+    async attach(id, attributes = {}, touch = true) {
+      if (this.using) {
+        await this.attachUsingCustomClass(id, attributes);
+      } else {
+        await this.newPivotStatement().insert(this.formatAttachRecords(this.parseIds(id), attributes));
+      }
+    }
+    async detach(ids = null, touch = true) {
+      let results;
+      if (this.using && ids !== null && this.pivotWheres.length == 0 && this.pivotWhereIns.length == 0 && this.pivotWhereNulls.length == 0) {
+        results = await this.detachUsingCustomClass(ids);
+      } else {
+        const query = this.newPivotQuery();
+        if (ids !== null) {
+          ids = this.parseIds(ids);
+          if (ids.length == 0) {
+            return 0;
+          }
+          query.whereIn(this.getQualifiedRelatedPivotKeyName(), ids);
+        }
+        results = await query.delete();
+      }
+      return results;
+    }
+    async sync(ids, detaching = true) {
+      let changes = {
+        attached: [],
+        detached: [],
+        updated: []
+      };
+      let records;
+      const results = await this.getCurrentlyAttachedPivots();
+      const current = results.length === 0 ? [] : results.map((result) => result.toData()).pluck(this.relatedPivotKey).all().map((i) => String(i));
+      const detach = difference2(current, Object.keys(records = this.formatRecordsList(this.parseIds(ids))));
+      if (detaching && detach.length > 0) {
+        await this.detach(detach);
+        changes.detached = this.castKeys(detach);
+      }
+      changes = merge(changes, await this.attachNew(records, current, false));
+      return changes;
+    }
+    syncWithoutDetaching(ids) {
+      return this.sync(ids, false);
+    }
+    syncWithPivotValues(ids, values, detaching = true) {
+      return this.sync(collect2(this.parseIds(ids)).mapWithKeys((id) => {
+        return [id, values];
+      }), detaching);
+    }
+    withPivot(columns) {
+      this.pivotColumns = this.pivotColumns.concat(isArray2(columns) ? columns : Array.prototype.slice.call(arguments));
+      return this;
+    }
+    async attachNew(records, current, touch = true) {
+      const changes = {
+        attached: [],
+        updated: []
+      };
+      for (const id in records) {
+        const attributes = records[id];
+        if (!current.includes(id)) {
+          await this.attach(id, attributes, touch);
+          changes.attached.push(this.castKey(id));
+        } else if (Object.keys(attributes).length > 0 && await this.updateExistingPivot(id, attributes, touch)) {
+          changes.updated.push(this.castKey(id));
+        }
+      }
+      return changes;
+    }
+    async updateExistingPivot(id, attributes, touch = true) {
+      if (this.using && this.pivotWheres.length > 0 && this.pivotWhereInspivotWheres.length > 0 && this.pivotWhereNullspivotWheres.length > 0) {
+        return await this.updateExistingPivotUsingCustomClass(id, attributes, touch);
+      }
+      if (this.hasPivotColumn(this.updatedAt())) {
+        attributes = this.addTimestampsToAttachment(attributes, true);
+      }
+      const updated = this.newPivotStatementForId(this.parseId(id)).update(this.castAttributes(attributes));
+      return updated;
+    }
+    addTimestampsToAttachment(record, exists = false) {
+      let fresh = this.parent.freshTimestamp();
+      if (this.using) {
+        const pivotModel = new this.using();
+        fresh = pivotModel.fromDateTime(fresh);
+      }
+      if (!exists && this.hasPivotColumn(this.createdAt())) {
+        record[this.createdAt()] = fresh;
+      }
+      if (this.hasPivotColumn(this.updatedAt())) {
+        record[this.updatedAt()] = fresh;
+      }
+      return record;
+    }
+    async updateExistingPivotUsingCustomClass(id, attributes, touch) {
+      const pivot = await this.getCurrentlyAttachedPivots().where(this.foreignPivotKey, this.parent[this.parentKey]).where(this.relatedPivotKey, this.parseId(id)).first();
+      const updated = pivot ? pivot.fill(attributes).isDirty() : false;
+      if (updated) {
+        await pivot.save();
+      }
+      return parseInt(updated);
+    }
+    formatRecordsList(records) {
+      return collect2(records).mapWithKeys((attributes, id) => {
+        if (!isArray2(attributes)) {
+          [id, attributes] = [attributes, {}];
+        }
+        return [id, attributes];
+      }).all();
+    }
+    async getCurrentlyAttachedPivots() {
+      const query = this.newPivotQuery();
+      const results = await query.get();
+      return results.map((record) => {
+        const modelClass = this.using || Pivot;
+        const pivot = modelClass.fromRawAttributes(this.parent, record, this.getTable(), true);
+        return pivot.setPivotKeys(this.foreignPivotKey, this.relatedPivotKey);
+      });
+    }
+    castKeys(keys) {
+      return keys.map((v) => {
+        return this.castKey(v);
+      });
+    }
+    castKey(key2) {
+      return this.getTypeSwapValue(this.related.getKeyType(), key2);
+    }
+    getTypeSwapValue(type, value) {
+      switch (type.toLowerCase()) {
+        case "int":
+        case "integer":
+          return parseInt(value);
+        case "real":
+        case "float":
+        case "double":
+          return parseFloat(value);
+        case "string":
+          return String(value);
+        default:
+          return value;
+      }
+    }
+    newPivotQuery() {
+      const query = this.newPivotStatement();
+      this.pivotWheres.map((args) => {
+        query.where(...args);
+      });
+      this.pivotWhereIns.map((args) => {
+        query.whereIn(...args);
+      });
+      this.pivotWhereNulls.map((args) => {
+        query.whereNull(...args);
+      });
+      return query.where(this.getQualifiedForeignPivotKeyName(), this.parent[this.parentKey]);
+    }
+    async detachUsingCustomClass(ids) {
+      let results = 0;
+      for (const id in this.parseIds(ids)) {
+        results += await this.newPivot({
+          [this.foreignPivotKey]: this.parent[this.parentKey],
+          [this.relatedPivotKey]: id
+        }, true).delete();
+      }
+      ;
+      return results;
+    }
+    newPivotStatement() {
+      const builder = this.parent.newQuery();
+      builder.setTable(this.table);
+      return builder;
+    }
+    async attachUsingCustomClass(id, attributes) {
+      const records = this.formatAttachRecords(this.parseIds(id), attributes);
+      await Promise.all(records.map(async (record) => {
+        await this.newPivot(record, false).save();
+      }));
+    }
+    formatAttachRecords(ids, attributes) {
+      const records = [];
+      const hasTimestamps = this.hasPivotColumn(this.createdAt()) || this.hasPivotColumn(this.updatedAt());
+      for (const key2 in ids) {
+        const value = ids[key2];
+        records.push(this.formatAttachRecord(key2, value, attributes, hasTimestamps));
+      }
+      return records;
+    }
+    formatAttachRecord(key2, value, attributes, hasTimestamps) {
+      const [id, newAttributes] = this.extractAttachIdAndAttributes(key2, value, attributes);
+      return merge(this.baseAttachRecord(id, hasTimestamps), newAttributes);
+    }
+    baseAttachRecord(id, timed) {
+      let record = {};
+      record[this.relatedPivotKey] = id;
+      record[this.foreignPivotKey] = this.parent[this.parentKey];
+      if (timed) {
+        record = this.addTimestampsToAttachment(record);
+      }
+      this.pivotValues.map((value) => {
+        record[value.column] = value.value;
+      });
+      return record;
+    }
+    extractAttachIdAndAttributes(key2, value, newAttributes) {
+      return isArray2(value) ? [key2, { ...value, ...newAttributes }] : [value, newAttributes];
+    }
+    hasPivotColumn = function(column) {
+      return this.pivotColumns.includes(column);
+    };
+    parseIds(value) {
+      if (value instanceof Model) {
+        return [value[this.relatedKey]];
+      }
+      if (value instanceof collection_default) {
+        return value.pluck(this.relatedKey).all();
+      }
+      return isArray2(value) ? value : [value];
+    }
+  };
+};
+var interacts_with_pivot_table_default = InteractsWithPivotTable;
+
+// src/relations/belongs-to-many.js
+import { collect as collect3 } from "collect.js";
+var BelongsToMany = class extends compose(relation_default, interacts_with_pivot_table_default) {
+  table;
+  foreignPivotKey;
+  relatedPivotKey;
+  parentKey;
+  relatedKey;
+  pivotColumns = [];
+  pivotValues = [];
+  pivotWheres = [];
+  pivotWhereIns = [];
+  pivotWhereNulls = [];
+  accessor = "pivot";
+  // withTimestamps = false;
+  using;
+  pivotCreatedAt;
+  pivotUpdatedAt;
+  constructor(query, parent, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+    super(query, parent);
+    this.table = table;
+    this.foreignPivotKey = foreignPivotKey;
+    this.relatedPivotKey = relatedPivotKey;
+    this.parentKey = parentKey;
+    this.relatedKey = relatedKey;
+    this.addConstraints();
+    return this.asProxy();
+  }
+  initRelation(models, relation) {
+    models.map((model) => {
+      model.setRelation(relation, new collection_default([]));
+    });
+    return models;
+  }
+  addConstraints() {
+    this.performJoin();
+    if (this.constructor.constraints) {
+      this.addWhereConstraints();
+    }
+  }
+  performJoin(query = null) {
+    query = query || this.query;
+    query.join(this.getTable(), this.getQualifiedRelatedKeyName(), "=", this.qualifyPivotColumn(this.relatedPivotKey));
+    return this;
+  }
+  getTable() {
+    return this.table;
+  }
+  getQualifiedRelatedKeyName() {
+    return this.related.qualifyColumn(this.relatedKey);
+  }
+  async getResults() {
+    return this.parent[this.parentKey] !== null ? await this.get() : new collection_default([]);
+  }
+  addWhereConstraints() {
+    this.query.where(this.getQualifiedForeignPivotKeyName(), "=", this.parent[this.parentKey]);
+    return this;
+  }
+  async get(columns = ["*"]) {
+    const builder = this.query.applyScopes();
+    columns = builder.query?._statements?.find((item) => item.grouping == "columns") ? [] : columns;
+    let models = await builder.select(this.shouldSelect(columns)).getModels();
+    this.hydratePivotRelation(models);
+    if (models.length > 0) {
+      models = await builder.eagerLoadRelations(models);
+    }
+    return new collection_default(models);
+  }
+  async first(columns = ["*"]) {
+    const results = await this.take(1).get(columns);
+    return results.count() > 0 ? results.first() : null;
+  }
+  async firstOrFail(columns = ["*"]) {
+    const model = await this.first(columns);
+    if (model !== null) {
+      return model;
+    }
+    throw new ModelNotFoundError().setModel(this.related.constructor);
+  }
+  async paginate(page = 1, perPage = 15, columns = ["*"]) {
+    this.query.select(this.shouldSelect(columns));
+    return tap(await this.query.paginate(page, perPage), (paginator) => {
+      this.hydratePivotRelation(paginator.items());
+    });
+  }
+  async chunk(count, callback) {
+    return await this.prepareQueryBuilder().chunk(count, async (results, page) => {
+      this.hydratePivotRelation(results.all());
+      return await callback(results, page);
+    });
+  }
+  setUsing(model) {
+    this.using = model;
+    return this;
+  }
+  as(accessor) {
+    this.accessor = accessor;
+    return this;
+  }
+  prepareQueryBuilder() {
+    return this.query.select(this.shouldSelect());
+  }
+  hydratePivotRelation(models) {
+    models.map((model) => {
+      model.setRelation(this.accessor, this.newExistingPivot(this.migratePivotAttributes(model)));
+    });
+  }
+  migratePivotAttributes(model) {
+    const values = {};
+    for (const key2 in model.attributes) {
+      const value = model.attributes[key2];
+      if (key2.startsWith("pivot_")) {
+        values[key2.substring(6)] = value;
+        model.attributes = omit2(model.attributes, [key2]);
+      }
+    }
+    return values;
+  }
+  withTimestamps(createdAt = null, updatedAt = null) {
+    this.pivotCreatedAt = createdAt;
+    this.pivotUpdatedAt = updatedAt;
+    return this.withPivot(this.createdAt(), this.updatedAt());
+  }
+  shouldSelect(columns = ["*"]) {
+    if (isEqual(columns, ["*"])) {
+      columns = [this.related.getTable() + ".*"];
+    }
+    return columns.concat(this.aliasedPivotColumns());
+  }
+  aliasedPivotColumns() {
+    const defaults = [this.foreignPivotKey, this.relatedPivotKey];
+    return collect3(defaults.concat(this.pivotColumns)).map((column) => {
+      return this.qualifyPivotColumn(column) + " as pivot_" + column;
+    }).unique().all();
+  }
+  qualifyPivotColumn(column) {
+    return column.includes(".") ? column : this.getTable() + "." + column;
+  }
+  match(models, results, relation) {
+    const dictionary = this.buildDictionary(results);
+    models.map((model) => {
+      const key2 = model.getKey();
+      if (dictionary[key2] !== void 0) {
+        model.setRelation(relation, dictionary[key2]);
+      }
+    });
+    return models;
+  }
+  buildDictionary(results) {
+    const dictionary = {};
+    results.map((result) => {
+      const value = result[this.accessor][this.foreignPivotKey];
+      if (dictionary[value] === void 0) {
+        dictionary[value] = new collection_default([]);
+      }
+      dictionary[value].push(result);
+    });
+    return dictionary;
+  }
+  addEagerConstraints(models) {
+    this.query.whereIn(this.getQualifiedForeignPivotKeyName(), this.getKeys(models, this.parentKey));
+  }
+  getQualifiedForeignPivotKeyName() {
+    return this.qualifyPivotColumn(this.foreignPivotKey);
+  }
+  getQualifiedRelatedPivotKeyName() {
+    return this.qualifyPivotColumn(this.relatedPivotKey);
+  }
+  wherePivot(column, operator = null, value = null, boolean = "and") {
+    this.pivotWheres.push(Array.prototype.slice.call(arguments));
+    return this.where(this.qualifyPivotColumn(column), operator, value, boolean);
+  }
+  wherePivotBetween(column, values, boolean = "and", not = false) {
+    return this.whereBetween(this.qualifyPivotColumn(column), values, boolean, not);
+  }
+  orWherePivotBetween(column, values) {
+    return this.wherePivotBetween(column, values, "or");
+  }
+  wherePivotNotBetween(column, values, boolean = "and") {
+    return this.wherePivotBetween(column, values, boolean, true);
+  }
+  orWherePivotNotBetween(column, values) {
+    return this.wherePivotBetween(column, values, "or", true);
+  }
+  wherePivotIn(column, values, boolean = "and", not = false) {
+    return this.whereIn(this.qualifyPivotColumn(column), values, boolean, not);
+  }
+  orWherePivot(column, operator = null, value = null) {
+    return this.wherePivot(column, operator, value, "or");
+  }
+  orWherePivotIn(column, values) {
+    return this.wherePivotIn(column, values, "or");
+  }
+  wherePivotNotIn(column, values, boolean = "and") {
+    return this.wherePivotIn(column, values, boolean, true);
+  }
+  orWherePivotNotIn(column, values) {
+    return this.wherePivotNotIn(column, values, "or");
+  }
+  wherePivotNull(column, boolean = "and", not = false) {
+    return this.whereNull(this.qualifyPivotColumn(column), boolean, not);
+  }
+  wherePivotNotNull(column, boolean = "and") {
+    return this.wherePivotNull(column, boolean, true);
+  }
+  orWherePivotNull(column, not = false) {
+    return this.wherePivotNull(column, "or", not);
+  }
+  orWherePivotNotNull(column) {
+    return this.orWherePivotNull(column, true);
+  }
+  orderByPivot(column, direction = "asc") {
+    return this.orderBy(this.qualifyPivotColumn(column), direction);
+  }
+  createdAt() {
+    return this.pivotCreatedAt || this.parent.getCreatedAtColumn();
+  }
+  updatedAt() {
+    return this.pivotUpdatedAt || this.parent.getUpdatedAtColumn();
+  }
+  getExistenceCompareKey() {
+    return this.getQualifiedForeignPivotKeyName();
+  }
+  // touchIfTouching() {
+  //   if (this.touchingParent()) {
+  //     this.getParent().touch();
+  //   }
+  //   if (this.getParent().touches(this.relationName)) {
+  //     this.touch();
+  //   }
+  // }
+  getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+    if (parentQuery.getQuery()._single.table == query.getQuery()._single.table) {
+      return this.getRelationExistenceQueryForSelfJoin(query, parentQuery, columns);
+    }
+    this.performJoin(query);
+    return super.getRelationExistenceQuery(query, parentQuery, columns);
+  }
+  getRelationExistenceQueryForSelfJoin(query, parentQuery, columns = ["*"]) {
+    const hash = this.getRelationCountHash();
+    query.select(columns).from(this.related.getTable() + " as " + hash);
+    this.related.setTable(hash);
+    this.performJoin(query);
+    return super.getRelationExistenceQuery(query, parentQuery, columns);
+  }
+};
+var belongs_to_many_default = BelongsToMany;
+
+// src/errors.js
+import { isArray as isArray3 } from "radashi";
+var BaseError = class extends Error {
+  constructor(message, entity) {
+    super(message);
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.message = message;
+  }
+};
+var ModelNotFoundError2 = class extends BaseError {
+  model;
+  ids;
+  setModel(model, ids = []) {
+    this.model = model;
+    this.ids = isArray3(ids) ? ids : [ids];
+    this.message = `No query results for model [${model}]`;
+    if (this.ids.length > 0) {
+      this.message += " " + this.ids.join(", ");
+    } else {
+      this.message += ".";
+    }
+    return this;
+  }
+  getModel() {
+    return this.model;
+  }
+  getIds() {
+    return this.ids;
+  }
+};
+var RelationNotFoundError = class extends BaseError {
+};
+var InvalidArgumentError = class extends BaseError {
+};
+
+// src/builder.js
+import { diff as difference3, flat as flatten, isArray as isArray4, isString, assign as merge2, omit as omit3, snake as snake2 } from "radashi";
+import { Collection as BaseCollection2 } from "collect.js";
+
+// src/paginator.js
+var Paginator = class {
+  static formatter = null;
+  _items;
+  _total;
+  _perPage;
+  _lastPage;
+  _currentPage;
+  static setFormatter(formatter) {
+    if (typeof formatter !== "function" && formatter !== null && formatter !== void 0) {
+      throw new Error("Paginator formatter must be a function or null");
+    }
+    this.formatter = formatter;
+  }
+  constructor(items, total, perPage, currentPage = null, options = {}) {
+    this.options = options;
+    for (const key2 in options) {
+      const value = options[key2];
+      this[key2] = value;
+    }
+    this._total = total;
+    this._perPage = parseInt(perPage);
+    this._lastPage = Math.max(Math.ceil(total / perPage), 1);
+    this._currentPage = currentPage;
+    this.setItems(items);
+  }
+  setItems(items) {
+    this._items = items instanceof collection_default ? items : new collection_default(items);
+    this.hasMore = this._items.count() > this._perPage;
+    this._items = this._items.slice(0, this._perPage);
+  }
+  firstItem() {
+    return this.count() > 0 ? (this._currentPage - 1) * this._perPage + 1 : null;
+  }
+  lastItem() {
+    return this.count() > 0 ? this.firstItem() + this.count() - 1 : null;
+  }
+  hasMorePages() {
+    return this._currentPage < this._lastPage;
+  }
+  get(index) {
+    return this._items.get(index);
+  }
+  count() {
+    return this._items.count();
+  }
+  items() {
+    return this._items;
+  }
+  map(callback) {
+    return this._items.map(callback);
+  }
+  currentPage() {
+    return this._currentPage;
+  }
+  onFirstPage() {
+    return this._currentPage === 1;
+  }
+  perPage() {
+    return this._perPage;
+  }
+  lastPage() {
+    return this._lastPage;
+  }
+  total() {
+    return this._total;
+  }
+  toData() {
+    if (this.constructor.formatter && typeof this.constructor.formatter === "function") {
+      return this.constructor.formatter(this);
+    }
+    return {
+      current_page: this._currentPage,
+      data: this._items.toData(),
+      per_page: this._perPage,
+      total: this._total,
+      last_page: this._lastPage,
+      count: this.count()
+    };
+  }
+  toJSON() {
+    return this.toData();
+  }
+  toJson(...args) {
+    return JSON.stringify(this.toData(), ...args);
+  }
+};
+var paginator_default = Paginator;
+
+// src/scope.js
+var Scope = class _Scope {
+  constructor() {
+    if (this.constructor === _Scope) {
+      throw new Error("Scope cannot be instantiated");
+    }
+  }
+  apply(builder, model) {
+    throw new Error("apply not implemented");
+  }
+};
+var scope_default = Scope;
+
+// src/builder.js
+var Builder = class _Builder {
+  query;
+  connection;
+  model;
+  actions;
+  localMacros = {};
+  eagerLoad = {};
+  globalScopes = {};
+  constructor(query) {
+    this.query = query;
+    return this.asProxy();
+  }
+  asProxy() {
+    const handler = {
+      get: function(target, prop) {
+        if (typeof target[prop] !== "undefined") {
+          return target[prop];
+        }
+        if ([
+          "select",
+          "from",
+          "where",
+          "orWhere",
+          "whereColumn",
+          "whereRaw",
+          "whereNot",
+          "orWhereNot",
+          "whereIn",
+          "orWhereIn",
+          "whereNotIn",
+          "orWhereNotIn",
+          "whereNull",
+          "orWhereNull",
+          "whereNotNull",
+          "orWhereNotNull",
+          "whereExists",
+          "orWhereExists",
+          "whereNotExists",
+          "orWhereNotExists",
+          "whereBetween",
+          "orWhereBetween",
+          "whereNotBetween",
+          "orWhereNotBetween",
+          "whereLike",
+          "orWhereLike",
+          "whereILike",
+          "orWhereILike",
+          "whereJsonObject",
+          "whereJsonPath",
+          "whereJsonSupersetOf",
+          "whereJsonSubsetOf",
+          "join",
+          "joinRaw",
+          "leftJoin",
+          "leftOuterJoin",
+          "rightJoin",
+          "rightOuterJoin",
+          "crossJoin",
+          "transacting",
+          "groupBy",
+          "groupByRaw",
+          "returning",
+          "having",
+          "havingRaw",
+          "havingBetween",
+          "limit",
+          "offset",
+          "orderBy",
+          "orderByRaw",
+          // 'inRandomOrder',
+          "union",
+          "insert",
+          "forUpdate",
+          "forShare",
+          "distinct",
+          "clearOrder",
+          "clear",
+          "clearSelect",
+          "clearWhere",
+          "clearHaving",
+          "clearGroup"
+        ].includes(prop)) {
+          return (...args) => {
+            target.query[prop](...args);
+            return target.asProxy();
+          };
+        }
+        if ([
+          "avg",
+          "max",
+          "min",
+          "sum",
+          "count"
+        ].includes(prop)) {
+          return (column) => {
+            const instance = target.asProxy();
+            instance.applyScopes();
+            column = !column && prop === "count" ? "*" : column;
+            return instance.query[prop](column);
+          };
+        }
+        if (typeof prop === "string") {
+          if (target.hasMacro(prop)) {
+            const instance = target.asProxy();
+            return (...args) => {
+              return instance.localMacros[prop](instance, ...args);
+            };
+          }
+          if (target.hasNamedScope(prop)) {
+            const instance = target.asProxy();
+            return (...args) => {
+              instance.callNamedScope(prop, args);
+              return instance;
+            };
+          }
+          if (prop.startsWith("where")) {
+            const column = snake2(prop.substring(5));
+            return (...args) => {
+              target.query.where(column, ...args);
+              return target.asProxy();
+            };
+          }
+        }
+      }
+    };
+    return new Proxy(this, handler);
+  }
+  orWhere(...args) {
+    if (typeof args[0] === "function") {
+      const callback = args[0];
+      this.query.orWhere((query) => {
+        this.query = query;
+        callback(this);
+      });
+      return this;
+    }
+    this.query.orWhere(...args);
+    return this;
+  }
+  async chunk(count, callback) {
+    let page = 1;
+    let countResults;
+    do {
+      this.enforceOrderBy();
+      const builder = this.clone();
+      const results = await builder.forPage(page, count).get();
+      countResults = results.count();
+      if (countResults == 0) {
+        break;
+      }
+      const bool = await callback(results, page);
+      if (bool === false) {
+        return false;
+      }
+      page++;
+    } while (countResults === count);
+    return true;
+  }
+  enforceOrderBy() {
+    if (this.query._statements.filter((item) => item.grouping === "order").length === 0) {
+      this.orderBy(this.model.getQualifiedKeyName(), "asc");
+    }
+  }
+  clone() {
+    const query = this.query.clone();
+    const builder = new this.constructor(query);
+    builder.connection = this.connection;
+    builder.setModel(this.model);
+    builder.globalScopes = { ...this.globalScopes };
+    builder.localMacros = { ...this.localMacros };
+    builder.eagerLoad = { ...this.eagerLoad };
+    return builder;
+  }
+  forPage(page, perPage = 15) {
+    return this.offset((page - 1) * perPage).limit(perPage);
+  }
+  insert(...args) {
+    return this.query.insert(...args);
+  }
+  update(values) {
+    this.applyScopes();
+    return this.query.update(this.addUpdatedAtColumn(values));
+  }
+  increment(column, amount = 1, extra = {}) {
+    this.applyScopes();
+    const db = this.model.getConnection();
+    return this.query.update(this.addUpdatedAtColumn({
+      ...extra,
+      [column]: db.raw(`${column} + ${amount}`)
+    }));
+  }
+  decrement(column, amount = 1, extra = {}) {
+    this.applyScopes();
+    const db = this.model.getConnection();
+    return this.query.update(this.addUpdatedAtColumn({
+      ...extra,
+      [column]: db.raw(`${column} - ${amount}`)
+    }));
+  }
+  addUpdatedAtColumn(values) {
+    if (!this.model.usesTimestamps() || this.model.getUpdatedAtColumn() === null) {
+      return values;
+    }
+    const column = this.model.getUpdatedAtColumn();
+    values = merge2({ [column]: this.model.freshTimestampString() }, values);
+    return values;
+  }
+  delete() {
+    if (this.onDeleteCallback) {
+      return this.onDeleteCallback(this);
+    }
+    return this.query.delete();
+  }
+  onDelete(callback) {
+    this.onDeleteCallback = callback;
+  }
+  forceDelete() {
+    return this.query.delete();
+  }
+  async create(attributes = {}) {
+    return await tap(this.newModelInstance(attributes), async (instance) => {
+      await instance.save({
+        client: this.query
+      });
+    });
+  }
+  newModelInstance(attributes = {}) {
+    return this.model.newInstance(attributes).setConnection(this.model.getConnectionName());
+  }
+  getQuery() {
+    return this.query;
+  }
+  getModel() {
+    return this.model;
+  }
+  setModel(model) {
+    this.model = model;
+    if (typeof this.query?.client?.table == "function") {
+      this.query = this.query.client.table(this.model.getTable());
+    } else {
+      this.query = this.query?.table(this.model.getTable());
+    }
+    return this;
+  }
+  qualifyColumn(column) {
+    return this.model.qualifyColumn(column);
+  }
+  setTable(table) {
+    this.query = this.query.table(table);
+    return this;
+  }
+  applyScopes() {
+    if (!this.globalScopes) {
+      return this;
+    }
+    const builder = this;
+    for (const identifier in builder.globalScopes) {
+      const scope = builder.globalScopes[identifier];
+      if (scope instanceof scope_default) {
+        scope.apply(builder, builder.getModel());
+      } else {
+        scope(builder);
+      }
+    }
+    return builder;
+  }
+  hasNamedScope(name) {
+    return this.model && this.model.hasNamedScope(name);
+  }
+  callNamedScope(scope, parameters) {
+    return this.model.callNamedScope(scope, [this, ...parameters]);
+  }
+  callScope(scope, parameters = []) {
+    const result = scope(this, ...parameters) || this;
+    return result;
+  }
+  scopes(scopes) {
+    scopes.map((scopeName) => {
+      const scopeMethod = getScopeMethod(scopeName);
+      if (typeof this.model[scopeMethod] === "function") {
+        this.globalScopes[scopeName] = this.model[scopeMethod];
+      }
+    });
+    return this;
+  }
+  withGlobalScope(identifier, scope) {
+    this.globalScopes[identifier] = scope;
+    if (typeof scope.extend === "function") {
+      scope.extend(this);
+    }
+    return this;
+  }
+  withoutGlobalScope(scope) {
+    if (typeof scope !== "string") {
+      scope = scope.constructor.name;
+    }
+    this.globalScopes = omit3(this.globalScopes, [scope]);
+    return this;
+  }
+  macro(name, callback) {
+    this.localMacros[name] = callback;
+    return;
+  }
+  hasMacro(name) {
+    return name in this.localMacros;
+  }
+  getMacro(name) {
+    return this.localMacros[name];
+  }
+  with(...args) {
+    let eagerLoads = {};
+    if (typeof args[1] === "function") {
+      let eagerLoad = this.parseWithRelations({
+        [args[0]]: args[1]
+      });
+      this.eagerLoad = merge2(this.eagerLoad, eagerLoad);
+      return this;
+    }
+    const relations = flattenDeep(args);
+    if (relations.length === 0) {
+      return this;
+    }
+    for (const relation of relations) {
+      let eagerLoad;
+      if (typeof relation === "string") {
+        eagerLoad = {
+          [relation]: (q) => q
+        };
+      } else if (typeof relation === "object") {
+        eagerLoad = relation;
+      }
+      eagerLoads = merge2(eagerLoads, eagerLoad);
+    }
+    this.eagerLoad = merge2(this.eagerLoad, this.parseWithRelations(eagerLoads));
+    return this;
+  }
+  has(relation, operator = ">=", count = 1, boolean = "and", callback = null) {
+    if (isString(relation)) {
+      if (relation.includes(".")) {
+        return this.hasNested(relation, operator, count, boolean, callback);
+      }
+      relation = this.getRelationWithoutConstraints(getRelationMethod(relation));
+    }
+    const method = this.canUseExistsForExistenceCheck(operator, count) ? "getRelationExistenceQuery" : "getRelationExistenceCountQuery";
+    const hasQuery = relation[method](relation.getRelated().newModelQuery(), this);
+    if (callback) {
+      callback(hasQuery);
+    }
+    return this.addHasWhere(hasQuery, relation, operator, count, boolean);
+  }
+  orHas(relation, operator = ">=", count = 1) {
+    return this.has(relation, operator, count, "or");
+  }
+  doesntHave(relation, boolean = "and", callback = null) {
+    return this.has(relation, "<", 1, boolean, callback);
+  }
+  orDoesntHave(relation) {
+    return this.doesntHave(relation, "or");
+  }
+  whereHas(relation, callback = null, operator = ">=", count = 1) {
+    return this.has(relation, operator, count, "and", callback);
+  }
+  orWhereHas(relation, callback = null, operator = ">=", count = 1) {
+    return this.has(relation, operator, count, "or", callback);
+  }
+  whereRelation(relation, ...args) {
+    const column = args.shift();
+    return this.whereHas(relation, (query) => {
+      if (typeof column === "function") {
+        column(query);
+      } else {
+        query.where(column, ...args);
+      }
+    });
+  }
+  orWhereRelation(relation, ...args) {
+    const column = args.shift();
+    return this.orWhereHas(relation, function(query) {
+      if (typeof column === "function") {
+        column(query);
+      } else {
+        query.where(column, ...args);
+      }
+    });
+  }
+  hasNested(relations, operator = ">=", count = 1, boolean = "and", callback = null) {
+    relations = relations.split(".");
+    const doesntHave = operator === "<" && count === 1;
+    if (doesntHave) {
+      operator = ">=";
+      count = 1;
+    }
+    const closure = (q) => {
+      relations.length > 1 ? q.whereHas(relations.shift(), closure) : q.has(relations.shift(), operator, count, "and", callback);
+    };
+    return this.has(relations.shift(), doesntHave ? "<" : ">=", 1, boolean, closure);
+  }
+  canUseExistsForExistenceCheck(operator, count) {
+    return (operator === ">=" || operator === "<") && count === 1;
+  }
+  addHasWhere(hasQuery, relation, operator, count, boolean) {
+    hasQuery.mergeConstraintsFrom(relation.getQuery());
+    return this.canUseExistsForExistenceCheck(operator, count) ? this.addWhereExistsQuery(hasQuery.getQuery(), boolean, operator === "<" && count === 1) : this.addWhereCountQuery(hasQuery.getQuery(), operator, count, boolean);
+  }
+  addWhereExistsQuery(query, boolean = "and", not = false) {
+    const type = not ? "NotExists" : "Exists";
+    const method = boolean === "and" ? "where" + type : "orWhere" + type;
+    this[method](query.connector);
+    return this;
+  }
+  addWhereCountQuery(query, operator = ">=", count = 1, boolean = "and") {
+    const db = this.model.getConnection();
+    return this.where(db.raw("(" + query.toSQL().sql + ")"), operator, typeof count === "number" ? db.raw(count) : count, boolean);
+  }
+  withAggregate(relations, column, action = null) {
+    if (relations.length === 0) {
+      return this;
+    }
+    relations = flattenDeep([relations]);
+    let eagerLoads = {};
+    for (const relation of relations) {
+      let eagerLoad;
+      if (typeof relation === "string") {
+        eagerLoad = {
+          [relation]: (q) => q
+        };
+      } else if (typeof relation === "object") {
+        eagerLoad = relation;
+      }
+      eagerLoads = merge2(eagerLoads, eagerLoad);
+    }
+    relations = eagerLoads;
+    const db = this.model.getConnection();
+    const columns = this.query._statements.filter((item) => item.grouping == "columns").map((item) => item.value).flat();
+    if (columns.length === 0) {
+      this.query.select([this.query._single.table + ".*"]);
+    }
+    const parses = this.parseWithRelations(relations);
+    for (let name in parses) {
+      const constraints = parses[name];
+      const segments = name.split(" ");
+      let alias, expression;
+      if (segments.length === 3 && segments[1].toLocaleLowerCase() === "as") {
+        [name, alias] = [segments[0], segments[2]];
+      }
+      const relation = this.getRelationWithoutConstraints(getRelationMethod(name));
+      if (action) {
+        const hashedColumn = this.query._single.table === relation.query.query._single.table ? `${relation.getRelationCountHash(false)}.${column}` : column;
+        const wrappedColumn = column === "*" ? column : relation.getRelated().qualifyColumn(hashedColumn);
+        expression = action === "exists" ? wrappedColumn : `${action}(${wrappedColumn})`;
+      } else {
+        expression = column;
+      }
+      const query = relation.getRelationExistenceQuery(relation.getRelated().newModelQuery(), this, db.raw(expression));
+      constraints(query);
+      alias = alias || snake2(`${name} ${action} ${column}`.replace("/[^[:alnum:][:space:]_]/u", ""));
+      if (action === "exists") {
+        this.select(db.raw(`exists(${query.toSql().sql}) as ${alias}`));
+      } else {
+        this.selectSub(action ? query : query.limit(1), alias);
+      }
+    }
+    return this;
+  }
+  toSql() {
+    const query = this.clone();
+    query.applyScopes();
+    return query.query.toSQL();
+  }
+  mergeConstraintsFrom(from) {
+    return this;
+    const whereBindings = from.getQuery().getRawBindings()["where"] || [];
+    const wheres = from.getQuery()._single.table !== this.getQuery()._single.table ? this.requalifyWhereTables(from.getQuery().wheres, from.getQuery().from, this.getModel().getTable()) : from.getQuery().wheres;
+    return this.where([], []);
+  }
+  selectSub(query, as) {
+    const [querySub, bindings] = this.createSub(query);
+    const db = this.model.getConnection();
+    return this.select(db.raw("(" + querySub + ") as " + as, bindings));
+  }
+  createSub(query) {
+    return this.parseSub(query);
+  }
+  parseSub(query) {
+    if (query instanceof _Builder || query instanceof relation_default) {
+      return [query.toSql().sql, query.toSql().bindings];
+    } else if (isString(query)) {
+      return [query, []];
+    } else {
+      throw new Error("A subquery must be a query builder instance, a Closure, or a string.");
+    }
+  }
+  prependDatabaseNameIfCrossDatabaseQuery(query) {
+    if (query.query._single.table !== this.query._single.table) {
+      const databaseName = query.query._single.table;
+      if (!query.query._single.table.startsWith(databaseName) && !query.query._single.table.contains(".")) {
+        query.from(databaseName + "." + query.from);
+      }
+    }
+    return query;
+  }
+  getRelationWithoutConstraints(relation) {
+    return relation_default.noConstraints(() => {
+      return this.getModel()[relation]();
+    });
+  }
+  withCount(...args) {
+    return this.withAggregate(flattenDeep(args), "*", "count");
+  }
+  withMax(relation, column) {
+    return this.withAggregate(relation, column, "max");
+  }
+  withMin(relation, column) {
+    return this.withAggregate(relation, column, "min");
+  }
+  withAvg(relation, column) {
+    return this.withAggregate(relation, column, "avg");
+  }
+  withSum(relation, column) {
+    return this.withAggregate(relation, column, "sum");
+  }
+  withExists(relation) {
+    return this.withAggregate(relation, "*", "exists");
+  }
+  parseWithRelations(relations) {
+    if (relations.length === 0) {
+      return [];
+    }
+    let results = {};
+    const constraintsMap = this.prepareNestedWithRelationships(relations);
+    for (const name in constraintsMap) {
+      results = this.addNestedWiths(name, results);
+      results[name] = constraintsMap[name];
+    }
+    return results;
+  }
+  addNestedWiths(name, results) {
+    const progress = [];
+    name.split(".").map((segment) => {
+      progress.push(segment);
+      const last = progress.join(".");
+      if (results[last] === void 0) {
+        results[last] = () => {
+        };
+      }
+    });
+    return results;
+  }
+  prepareNestedWithRelationships(relations, prefix = "") {
+    let preparedRelationships = {};
+    if (prefix !== "") {
+      prefix += ".";
+    }
+    for (const key2 in relations) {
+      const value = relations[key2];
+      if (isString(value) || Number.isFinite(parseInt(value))) {
+        continue;
+      }
+      const [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(key2, value);
+      preparedRelationships = merge2(preparedRelationships, {
+        [`${prefix}${attribute}`]: attributeSelectConstraint
+      }, this.prepareNestedWithRelationships(value, `${prefix}${attribute}`));
+      relations = omit3(relations, [key2]);
+    }
+    for (const key2 in relations) {
+      const value = relations[key2];
+      let attribute = key2, attributeSelectConstraint = value;
+      if (isString(value)) {
+        [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(value);
+      }
+      preparedRelationships[`${prefix}${attribute}`] = this.combineConstraints([
+        attributeSelectConstraint,
+        preparedRelationships[`${prefix}${attribute}`] || (() => {
+        })
+      ]);
+    }
+    return preparedRelationships;
+  }
+  combineConstraints(constraints) {
+    return (builder) => {
+      constraints.map((constraint) => {
+        builder = constraint(builder) || builder;
+      });
+      return builder;
+    };
+  }
+  parseNameAndAttributeSelectionConstraint(name, value) {
+    return name.includes(":") ? this.createSelectWithConstraint(name) : [name, value];
+  }
+  createSelectWithConstraint(name) {
+    return [name.split(":")[0], (query) => {
+      query.select(name.split(":")[1].split(",").map((column) => {
+        if (column.includes(".")) {
+          return column;
+        }
+        return query instanceof belongs_to_many_default ? query.related.getTable() + "." + column : column;
+      }));
+    }];
+  }
+  related(relation) {
+    if (typeof this.model[getRelationMethod(relation)] !== "function") {
+      const message = `Model [${this.model.constructor.name}]'s relation [${relation}] doesn't exist.`;
+      throw new RelationNotFoundError(message);
+    }
+    return this.model[getRelationMethod(relation)]();
+  }
+  take(...args) {
+    return this.limit(...args);
+  }
+  skip(...args) {
+    return this.offset(...args);
+  }
+  async first(...columns) {
+    this.applyScopes();
+    this.limit(1);
+    let models = await this.getModels(columns);
+    if (models.length > 0) {
+      models = await this.eagerLoadRelations(models);
+    }
+    return models[0] || null;
+  }
+  async firstOrFail(...columns) {
+    const data = await this.first(...columns);
+    if (data === null) {
+      throw new ModelNotFoundError2().setModel(this.model.constructor.name);
+    }
+    return data;
+  }
+  async findOrFail(ids, columns = "*") {
+    const data = await this.find(ids, columns);
+    if (isArray4(ids)) {
+      if (data.count() !== ids.length) {
+        throw new ModelNotFoundError2().setModel(this.model.constructor.name, difference3(ids, data.modelKeys()));
+      }
+      return data;
+    }
+    if (data === null) {
+      throw new ModelNotFoundError2().setModel(this.model.constructor.name, ids);
+    }
+    return data;
+  }
+  async findOrNew(id, columns = ["*"]) {
+    const model = await this.find(id, columns);
+    if (model !== null) {
+      return model;
+    }
+    return this.newModelInstance();
+  }
+  async firstOrNew(attributes = {}, values = {}) {
+    const instance = await this.where(attributes).first();
+    if (instance !== null) {
+      return instance;
+    }
+    return this.newModelInstance(merge2(attributes, values));
+  }
+  async firstOrCreate(attributes = {}, values = {}) {
+    const instance = await this.where(attributes).first();
+    if (instance !== null) {
+      return instance;
+    }
+    return tap(this.newModelInstance(merge2(attributes, values)), async (instance2) => {
+      await instance2.save({
+        client: this.query
+      });
+    });
+  }
+  async updateOrCreate(attributes, values = {}) {
+    return await tap(await this.firstOrNew(attributes), async (instance) => {
+      await instance.fill(values).save({
+        client: this.query
+      });
+    });
+  }
+  latest(column = null) {
+    if (column === null) {
+      column = this.model.getCreatedAtColumn() || "created_at";
+    }
+    this.query.orderBy(column, "desc");
+    return this;
+  }
+  oldest(column = null) {
+    if (column === null) {
+      column = this.model.getCreatedAtColumn() || "created_at";
+    }
+    this.query.orderBy(column, "asc");
+    return this;
+  }
+  async find(id, columns = "*") {
+    if (isArray4(id) || id instanceof collection_default) {
+      return await this.findMany(id, columns);
+    }
+    return await this.where(this.model.getKeyName(), id).first(columns);
+  }
+  async findMany(ids, columns = "*") {
+    if (ids instanceof collection_default) {
+      ids = ids.modelKeys();
+    }
+    ids = isArray4(ids) ? ids : [ids];
+    if (ids.length === 0) {
+      return new collection_default([]);
+    }
+    return await this.whereIn(this.model.getKeyName(), ids).get(columns);
+  }
+  async pluck(column) {
+    const data = await this.query.pluck(column);
+    return new collection_default(data);
+  }
+  async destroy(ids) {
+    if (ids instanceof collection_default) {
+      ids = ids.modelKeys();
+    }
+    if (ids instanceof BaseCollection2) {
+      ids = ids.all();
+    }
+    ids = isArray4(ids) ? ids : Array.prototype.slice.call(arguments);
+    if (ids.length === 0) {
+      return 0;
+    }
+    const instance = this.model.newInstance();
+    const key2 = instance.getKeyName();
+    let count = 0;
+    const models = await this.model.newModelQuery().whereIn(key2, ids).get();
+    for (const model of models) {
+      if (await model.delete()) {
+        count++;
+      }
+    }
+    return count;
+  }
+  async get(columns = "*") {
+    this.applyScopes();
+    let models = await this.getModels(columns);
+    if (models.length > 0) {
+      models = await this.eagerLoadRelations(models);
+    }
+    return new collection_default(models);
+  }
+  async all(columns = "*") {
+    return await this.model.newModelQuery().get(columns);
+  }
+  async paginate(page, perPage) {
+    page = page || 1;
+    perPage = perPage || this?.model?.perPage || 15;
+    this.applyScopes();
+    const query = this.query.clone();
+    const total = await query.clearOrder().clearSelect().count(this.primaryKey);
+    let results;
+    if (total > 0) {
+      const skip = (page - 1) * perPage;
+      this.take(perPage).skip(skip);
+      results = await this.getModels();
+      if (results.length > 0) {
+        results = await this.eagerLoadRelations(results);
+      }
+    } else {
+      results = [];
+    }
+    return new paginator_default(results, parseInt(total), perPage, page);
+  }
+  async getModels(...columns) {
+    columns = flatten(columns);
+    if (columns.length > 0) {
+      if (this.query._statements.filter((item) => item.grouping == "columns").length == 0 && columns[0] !== "*") {
+        this.query.select(...columns);
+      }
+    }
+    return this.hydrate(await this.query.get()).all();
+  }
+  getRelation(name) {
+    if (typeof this.model[getRelationMethod(name)] !== "function") {
+      const message = `Model [${this.model.constructor.name}]'s relation [${name}] doesn't exist.`;
+      throw new RelationNotFoundError(message);
+    }
+    const relation = relation_default.noConstraints(() => this.model.newInstance(this.model.attributes)[getRelationMethod(name)]());
+    const nested = this.relationsNestedUnder(name);
+    if (Object.keys(nested).length > 0) {
+      relation.query.with(nested);
+    }
+    return relation.asProxy();
+  }
+  relationsNestedUnder(relation) {
+    const nested = {};
+    for (const name in this.eagerLoad) {
+      const constraints = this.eagerLoad[name];
+      if (this.isNestedUnder(relation, name)) {
+        nested[name.substring((relation + ".").length)] = constraints;
+      }
+    }
+    return nested;
+  }
+  isNestedUnder(relation, name) {
+    return name.includes(".") && name.startsWith(relation + ".");
+  }
+  async eagerLoadRelation(models, name, constraints) {
+    const relation = this.getRelation(name);
+    relation.addEagerConstraints(models);
+    constraints(relation);
+    return relation.match(relation.initRelation(models, name), await relation.get(), name);
+  }
+  async eagerLoadRelations(models) {
+    for (const name in this.eagerLoad) {
+      const constraints = this.eagerLoad[name];
+      if (!name.includes(".")) {
+        models = await this.eagerLoadRelation(models, name, constraints);
+      }
+    }
+    return models;
+  }
+  hydrate(items) {
+    return new collection_default(items.map((item) => {
+      if (!this.model) {
+        return item;
+      }
+      const model = this.model.newFromBuilder(item);
+      return model;
+    }));
+  }
+};
+var builder_default = Builder;
+
+// src/concerns/has-attributes.js
+import { flat as flatten2, omit as omit4 } from "radashi";
+
+// src/casts-attributes.js
+var CastsAttributes = class _CastsAttributes {
+  constructor() {
+    if (this.constructor === _CastsAttributes) {
+      throw new Error("CastsAttributes cannot be instantiated");
+    }
+  }
+  static get() {
+    throw new Error("get not implemented");
+  }
+  static set() {
+    throw new Error("set not implemented");
+  }
+};
+var casts_attributes_default = CastsAttributes;
+
+// src/concerns/has-attributes.js
+import collect4 from "collect.js";
+import dayjs2 from "dayjs";
+var HasAttributes = (Model2) => {
+  return class extends Model2 {
+    static castTypeCache = {};
+    attributes = {};
+    original = {};
+    casts = {};
+    changes = {};
+    appends = [];
+    setAppends(appends) {
+      this.appends = appends;
+      return this;
+    }
+    append(...keys) {
+      const appends = flattenDeep(keys);
+      this.appends = [...this.appends, ...appends];
+      return this;
+    }
+    normalizeCastClassResponse(key2, value) {
+      return value?.constructor?.name === "Object" ? value : {
+        [key2]: value
+      };
+    }
+    syncOriginal() {
+      this.original = this.getAttributes();
+      return this;
+    }
+    syncChanges() {
+      this.changes = this.getDirty();
+      return this;
+    }
+    syncOriginalAttribute(attribute) {
+      this.syncOriginalAttributes(attribute);
+    }
+    syncOriginalAttributes(...attributes) {
+      attributes = flattenDeep(attributes);
+      const modelAttributes = this.getAttributes();
+      for (const attribute of attributes) {
+        this.original[attribute] = modelAttributes[attribute];
+      }
+      return this;
+    }
+    isDirty(...attributes) {
+      const changes = this.getDirty();
+      attributes = flattenDeep(attributes);
+      if (attributes.length === 0) {
+        return Object.keys(changes).length > 0;
+      }
+      for (const attribute of attributes) {
+        if (attribute in changes) {
+          return true;
+        }
+      }
+      return false;
+    }
+    getDirty() {
+      const dirty = {};
+      const attributes = this.getAttributes();
+      for (const key2 in attributes) {
+        const value = attributes[key2];
+        if (!this.originalIsEquivalent(key2)) {
+          dirty[key2] = value;
+        }
+      }
+      return dirty;
+    }
+    originalIsEquivalent(key2) {
+      if (this.original[key2] === void 0) {
+        return false;
+      }
+      const attribute = this.attributes[key2];
+      const original = this.original[key2];
+      if (attribute === original) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    setAttributes(attributes) {
+      this.attributes = { ...attributes };
+    }
+    setRawAttributes(attributes, sync = false) {
+      this.attributes = attributes;
+      if (sync) {
+        this.syncOriginal();
+      }
+      return this;
+    }
+    getAttributes() {
+      return { ...this.attributes };
+    }
+    setAttribute(key2, value) {
+      const setterMethod = getSetterMethod(key2);
+      if (typeof this[setterMethod] === "function") {
+        this[setterMethod](value);
+        return this;
+      }
+      const attrMethod = getAttrMethod(key2);
+      if (typeof this[attrMethod] === "function") {
+        const attribute = this[attrMethod]();
+        const callback = attribute.set || ((value2) => {
+          this.attributes[key2] = value2;
+        });
+        this.attributes = {
+          ...this.attributes,
+          ...this.normalizeCastClassResponse(key2, callback(value, this.attributes))
+        };
+        return this;
+      }
+      const casts = this.getCasts();
+      const castType = casts[key2];
+      if (this.isCustomCast(castType)) {
+        value = castType.set(this, key2, value, this.attributes);
+      }
+      if (castType === "json") {
+        value = JSON.stringify(value);
+      }
+      if (castType === "collection") {
+        value = JSON.stringify(value);
+      }
+      if (value !== null && this.isDateAttribute(key2)) {
+        value = this.fromDateTime(value);
+      }
+      this.attributes[key2] = value;
+      return this;
+    }
+    getAttribute(key2) {
+      if (!key2) {
+        return;
+      }
+      const getterMethod = getGetterMethod(key2);
+      if (typeof this[getterMethod] === "function") {
+        return this[getterMethod](this.attributes[key2], this.attributes);
+      }
+      const attrMethod = getAttrMethod(key2);
+      if (typeof this[attrMethod] === "function") {
+        const caster = this[attrMethod]();
+        return caster.get(this.attributes[key2], this.attributes);
+      }
+      if (key2 in this.attributes) {
+        if (this.hasCast(key2)) {
+          return this.castAttribute(key2, this.attributes[key2]);
+        }
+        if (this.getDates().includes(key2)) {
+          return this.asDateTime(this.attributes[key2]);
+        }
+        return this.attributes[key2];
+      }
+      if (key2 in this.relations) {
+        return this.relations[key2];
+      }
+      return;
+    }
+    castAttribute(key2, value) {
+      const castType = this.getCastType(key2);
+      if (!castType) {
+        return value;
+      }
+      if (value === null) {
+        return value;
+      }
+      switch (castType) {
+        case "int":
+        case "integer":
+          return parseInt(value);
+        case "real":
+        case "float":
+        case "double":
+          return parseFloat(value);
+        case "decimal":
+          return this.asDecimal(value, castType.split(":")[1]);
+        case "string":
+          return String(value);
+        case "bool":
+        case "boolean":
+          return Boolean(value);
+        case "object":
+        case "json":
+          try {
+            return JSON.parse(value);
+          } catch (e) {
+            return null;
+          }
+        case "collection":
+          try {
+            return collect4(JSON.parse(value));
+          } catch (e) {
+            return collect4([]);
+          }
+        case "date":
+          return this.asDate(value);
+        case "datetime":
+        case "custom_datetime":
+          return this.asDateTime(value);
+        case "timestamp":
+          return this.asTimestamp(value);
+      }
+      if (this.isCustomCast(castType)) {
+        return castType.get(this, key2, value, this.attributes);
+      }
+      return value;
+    }
+    attributesToData() {
+      let attributes = { ...this.attributes };
+      for (const key2 in attributes) {
+        if (this.hidden.includes(key2)) {
+          attributes = omit4(attributes, [key2]);
+        }
+        if (this.visible.length > 0 && this.visible.includes(key2) === false) {
+          attributes = omit4(attributes, [key2]);
+        }
+      }
+      for (const key2 of this.getDates()) {
+        if (attributes[key2] === void 0) {
+          continue;
+        }
+        attributes[key2] = this.serializeDate(this.asDateTime(attributes[key2]));
+      }
+      const casts = this.getCasts();
+      for (const key2 in casts) {
+        const value = casts[key2];
+        if (key2 in attributes === false) {
+          continue;
+        }
+        attributes[key2] = this.castAttribute(key2, attributes[key2]);
+        if (key2 in attributes && ["date", "datetime"].includes(value)) {
+          attributes[key2] = this.serializeDate(attributes[key2]);
+        }
+        if (key2 in attributes && this.isCustomDateTimeCast(value)) {
+          attributes[key2] = dayjs2(attributes[key2]).format(value.split(":")[1]);
+        }
+      }
+      for (const key2 of this.appends) {
+        attributes[key2] = this.mutateAttribute(key2, null);
+      }
+      return attributes;
+    }
+    mutateAttribute(key2, value) {
+      if (typeof this[getGetterMethod(key2)] === "function") {
+        return this[getGetterMethod(key2)](value);
+      } else if (typeof this[getAttrMethod(key2)] === "function") {
+        const caster = this[getAttrMethod(key2)]();
+        return caster.get(key2, this.attributes);
+      } else if (key2 in this) {
+        return this[key2];
+      }
+      return value;
+    }
+    mutateAttributeForArray(key2, value) {
+    }
+    isDateAttribute(key2) {
+      return this.getDates().includes(key2) || this.isDateCastable(key2);
+    }
+    serializeDate(date) {
+      return date ? dayjs2(date).toISOString() : null;
+    }
+    getDates() {
+      return this.usesTimestamps() ? [
+        this.getCreatedAtColumn(),
+        this.getUpdatedAtColumn()
+      ] : [];
+    }
+    getCasts() {
+      if (this.getIncrementing()) {
+        return {
+          [this.getKeyName()]: this.getKeyType(),
+          ...this.casts
+        };
+      }
+      return this.casts;
+    }
+    getCastType(key2) {
+      const castType = this.getCasts()[key2];
+      let castTypeCacheKey;
+      if (typeof castType === "string") {
+        castTypeCacheKey = castType;
+      } else if (new castType() instanceof casts_attributes_default) {
+        castTypeCacheKey = castType.name;
+      }
+      if (castTypeCacheKey && this.constructor.castTypeCache[castTypeCacheKey] !== void 0) {
+        return this.constructor.castTypeCache[castTypeCacheKey];
+      }
+      let convertedCastType;
+      if (this.isCustomDateTimeCast(castType)) {
+        convertedCastType = "custom_datetime";
+      } else if (this.isDecimalCast(castType)) {
+        convertedCastType = "decimal";
+      } else if (this.isCustomCast(castType)) {
+        convertedCastType = castType;
+      } else {
+        convertedCastType = castType.toLocaleLowerCase().trim();
+      }
+      return this.constructor.castTypeCache[castTypeCacheKey] = convertedCastType;
+    }
+    hasCast(key2, types = []) {
+      if (key2 in this.casts) {
+        types = flatten2(types);
+        return types.length > 0 ? types.includes(this.getCastType(key2)) : true;
+      }
+      return false;
+    }
+    withDayjs(date) {
+      return dayjs2(date);
+    }
+    isCustomCast(cast) {
+      return typeof cast === "function" && new cast() instanceof casts_attributes_default;
+    }
+    isCustomDateTimeCast(cast) {
+      if (typeof cast !== "string") {
+        return false;
+      }
+      return cast.startsWith("date:") || cast.startsWith("datetime:");
+    }
+    isDecimalCast(cast) {
+      if (typeof cast !== "string") {
+        return false;
+      }
+      return cast.startsWith("decimal:");
+    }
+    isDateCastable(key2) {
+      return this.hasCast(key2, ["date", "datetime"]);
+    }
+    fromDateTime(value) {
+      return dayjs2(this.asDateTime(value)).format(this.getDateFormat());
+    }
+    getDateFormat() {
+      return this.dateFormat || "YYYY-MM-DD HH:mm:ss";
+    }
+    asDecimal(value, decimals) {
+      return parseFloat(value).toFixed(decimals);
+    }
+    asDateTime(value) {
+      if (value === null) {
+        return null;
+      }
+      if (value instanceof Date) {
+        return value;
+      }
+      if (typeof value === "number") {
+        return new Date(value * 1e3);
+      }
+      return new Date(value);
+    }
+    asDate(value) {
+      const date = this.asDateTime(value);
+      return dayjs2(date).startOf("day").toDate();
+    }
+  };
+};
+var has_attributes_default = HasAttributes;
+
+// src/concerns/has-global-scopes.js
+import { get, set } from "radashi";
+var HasGlobalScopes = (Model2) => {
+  return class extends Model2 {
+    static addGlobalScope(scope, implementation = null) {
+      if (typeof scope === "string" && implementation instanceof scope_default) {
+        this.globalScopes = set(this.globalScopes, this.name + "." + scope, implementation);
+        return implementation;
+      } else if (scope instanceof scope_default) {
+        this.globalScopes = set(this.globalScopes, this.name + "." + scope.constructor.name, scope);
+        return scope;
+      }
+      throw new InvalidArgumentError("Global scope must be an instance of Scope.");
+    }
+    static hasGlobalScope(scope) {
+      return this.getGlobalScope(scope) !== null;
+    }
+    static getGlobalScope(scope) {
+      if (typeof scope === "string") {
+        return get(this.globalScopes, this.name + "." + scope);
+      }
+      return get(this.globalScopes, this.name + "." + scope.constructor.name);
+    }
+    static getAllGlobalScopes() {
+      return this.globalScopes;
+    }
+    static setAllGlobalScopes(scopes) {
+      this.globalScopes = scopes;
+    }
+    getGlobalScopes() {
+      return get(this.constructor.globalScopes, this.constructor.name, {});
+    }
+  };
+};
+var has_global_scopes_default = HasGlobalScopes;
+
+// src/hooks.js
+var Hooks = class {
+  hooks = {
+    creating: [],
+    created: [],
+    updating: [],
+    updated: [],
+    saving: [],
+    saved: [],
+    deleting: [],
+    deleted: [],
+    restoring: [],
+    restored: [],
+    trashed: [],
+    forceDeleting: [],
+    forceDeleted: []
+  };
+  add(hook, callback) {
+    if (typeof this.hooks[hook] === "undefined") {
+      this.hooks[hook] = [];
+    }
+    this.hooks[hook].push(callback);
+  }
+  async exec(hook, data) {
+    if (typeof this.hooks[hook] === "undefined") {
+      return true;
+    }
+    for (const callback of this.hooks[hook]) {
+      await callback(...data);
+    }
+    return true;
+  }
+};
+var hooks_default = Hooks;
+
+// src/concerns/has-hooks.js
+var HasHooks = (Model2) => {
+  return class extends Model2 {
+    static hooks = null;
+    static addHook(hook, callback) {
+      if (this.hooks instanceof hooks_default === false) {
+        this.hooks = new hooks_default();
+      }
+      this.hooks.add(hook, callback);
+    }
+    static creating(callback) {
+      this.addHook("creating", callback);
+    }
+    static created(callback) {
+      this.addHook("created", callback);
+    }
+    static updating(callback) {
+      this.addHook("updating", callback);
+    }
+    static updated(callback) {
+      this.addHook("updated", callback);
+    }
+    static saving(callback) {
+      this.addHook("saving", callback);
+    }
+    static saved(callback) {
+      this.addHook("saved", callback);
+    }
+    static deleting(callback) {
+      this.addHook("deleting", callback);
+    }
+    static deleted(callback) {
+      this.addHook("deleted", callback);
+    }
+    static restoring(callback) {
+      this.addHook("restoring", callback);
+    }
+    static restored(callback) {
+      this.addHook("restored", callback);
+    }
+    static trashed(callback) {
+      this.addHook("trashed", callback);
+    }
+    static forceDeleted(callback) {
+      this.addHook("forceDeleted", callback);
+    }
+    async execHooks(hook, options) {
+      if (this.constructor.hooks instanceof hooks_default === false) {
+        return;
+      }
+      return await this.constructor.hooks.exec(hook, [this, options]);
+    }
+  };
+};
+var has_hooks_default = HasHooks;
+
+// src/relations/has-one-or-many.js
+import collect5 from "collect.js";
+var HasOneOrMany = (Relation2) => {
+  return class extends Relation2 {
+    getRelationValue(dictionary, key2, type) {
+      const value = dictionary[key2];
+      return type === "one" ? value[0] : new collection_default(value);
+    }
+    matchOneOrMany(models, results, relation, type) {
+      const dictionary = this.buildDictionary(results);
+      models.map((model) => {
+        const key2 = model.attributes[this.localKey];
+        if (dictionary[key2] !== void 0) {
+          model.setRelation(relation, this.getRelationValue(dictionary, key2, type));
+        }
+      });
+      return models;
+    }
+    buildDictionary(results) {
+      const foreign = this.getForeignKeyName();
+      return collect5(results).mapToDictionary((result) => [
+        result[foreign],
+        result
+      ]).all();
+    }
+    async save(model) {
+      this.setForeignAttributesForCreate(model);
+      return await model.save() ? model : false;
+    }
+    async saveMany(models) {
+      await Promise.all(models.map(async (model) => {
+        await this.save(model);
+      }));
+      return models instanceof collection_default ? models : new collection_default(models);
+    }
+    async create(attributes = {}) {
+      return await tap(this.related.constructor.init(attributes), async (instance) => {
+        this.setForeignAttributesForCreate(instance);
+        await instance.save();
+      });
+    }
+    async createMany(records) {
+      const instances = await Promise.all(records.map(async (record) => {
+        return await this.create(record);
+      }));
+      return instances instanceof collection_default ? instances : new collection_default(instances);
+    }
+    setForeignAttributesForCreate(model) {
+      model[this.getForeignKeyName()] = this.getParentKey();
+    }
+    getForeignKeyName() {
+      const segments = this.getQualifiedForeignKeyName().split(".");
+      return segments[segments.length - 1];
+    }
+    getParentKey() {
+      return this.parent.attributes[this.localKey];
+    }
+    getQualifiedForeignKeyName() {
+      return this.foreignKey;
+    }
+    getExistenceCompareKey() {
+      return this.getQualifiedForeignKeyName();
+    }
+    addConstraints() {
+      if (this.constructor.constraints) {
+        const query = this.getRelationQuery();
+        query.where(this.foreignKey, "=", this.getParentKey());
+        query.whereNotNull(this.foreignKey);
+      }
+    }
+  };
+};
+var has_one_or_many_default = HasOneOrMany;
+
+// src/relations/has-many.js
+import { collect as collect6 } from "collect.js";
+var HasMany = class extends compose(relation_default, has_one_or_many_default) {
+  foreignKey;
+  localKey;
+  constructor(query, parent, foreignKey, localKey) {
+    super(query, parent);
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    this.addConstraints();
+    return this.asProxy();
+  }
+  initRelation(models, relation) {
+    models.map((model) => {
+      model.setRelation(relation, new collection_default([]));
+    });
+    return models;
+  }
+  async getResults() {
+    return this.getParentKey() !== null ? await this.query.get() : new collection_default([]);
+  }
+  getForeignKeyName() {
+    const segments = this.foreignKey.split(".");
+    return segments.pop();
+  }
+  buildDictionary(results) {
+    const foreign = this.getForeignKeyName();
+    return collect6(results).mapToDictionary((result) => [
+      result[foreign],
+      result
+    ]).all();
+  }
+  match(models, results, relation) {
+    return this.matchOneOrMany(models, results, relation, "many");
+  }
+  addEagerConstraints(models) {
+    this.query.whereIn(this.foreignKey, this.getKeys(models, this.localKey));
+  }
+};
+var has_many_default = HasMany;
+
+// src/relations/has-one.js
+var HasOne = class extends compose(relation_default, has_one_or_many_default, supports_default_models_default) {
+  foreignKey;
+  localKey;
+  constructor(query, parent, foreignKey, localKey) {
+    super(query, parent);
+    this.foreignKey = foreignKey;
+    this.localKey = localKey;
+    this.addConstraints();
+    return this.asProxy();
+  }
+  initRelation(models, relation) {
+    models.map((model) => {
+      model.setRelation(relation, this.getDefaultFor(model));
+    });
+    return models;
+  }
+  matchOne(models, results, relation) {
+    return this.matchOneOrMany(models, results, relation, "one");
+  }
+  getForeignKeyName() {
+    const segments = this.foreignKey.split(".");
+    return segments.pop();
+  }
+  async getResults() {
+    if (this.getParentKey() === null) {
+      return this.getDefaultFor(this.parent);
+    }
+    const results = await this.query.first();
+    return results || this.getDefaultFor(this.parent);
+  }
+  match(models, results, relation) {
+    return this.matchOneOrMany(models, results, relation, "one");
+  }
+  addEagerConstraints(models) {
+    this.query.whereIn(this.foreignKey, this.getKeys(models, this.localKey));
+  }
+  newRelatedInstanceFor(parent) {
+    return this.related.newInstance().setAttribute(this.getForeignKeyName(), parent[this.localKey]);
+  }
+};
+var has_one_default = HasOne;
+
+// src/relations/has-many-through.js
+import { isArray as isArray5 } from "radashi";
+var HasManyThrough = class extends relation_default {
+  throughParent;
+  farParent;
+  firstKey;
+  secondKey;
+  localKey;
+  secondLocalKey;
+  constructor(query, farParent, throughParent, firstKey, secondKey, localKey, secondLocalKey) {
+    super(query, throughParent);
+    this.localKey = localKey;
+    this.firstKey = firstKey;
+    this.secondKey = secondKey;
+    this.farParent = farParent;
+    this.throughParent = throughParent;
+    this.secondLocalKey = secondLocalKey;
+    return this.asProxy();
+  }
+  addConstraints() {
+    const localValue = this.farParent[this.localKey];
+    this.performJoin();
+    if (this.constructor.constraints) {
+      this.query.where(this.getQualifiedFirstKeyName(), "=", localValue);
+    }
+  }
+  performJoin(query = null) {
+    query = query || this.query;
+    const farKey = this.getQualifiedFarKeyName();
+    query.join(this.throughParent.getTable(), this.getQualifiedParentKeyName(), "=", farKey);
+    if (this.throughParentSoftDeletes()) {
+      query.withGlobalScope("SoftDeletableHasManyThrough", (query2) => {
+        query2.whereNull(this.throughParent.getQualifiedDeletedAtColumn());
+      });
+    }
+  }
+  getQualifiedParentKeyName() {
+    return this.parent.qualifyColumn(this.secondLocalKey);
+  }
+  throughParentSoftDeletes() {
+    return this.throughParent.pluginInitializers["SoftDeletes"] !== void 0;
+  }
+  withTrashedParents() {
+    this.query.withoutGlobalScope("SoftDeletableHasManyThrough");
+    return this;
+  }
+  addEagerConstraints(models) {
+    const whereIn = this.whereInMethod(this.farParent, this.localKey);
+    this.whereInEager(whereIn, this.getQualifiedFirstKeyName(), this.getKeys(models, this.localKey));
+  }
+  initRelation(models, relation) {
+    for (const model of models) {
+      model.setRelation(relation, this.related.newCollection());
+    }
+    return models;
+  }
+  match(models, results, relation) {
+    const dictionary = this.buildDictionary(results);
+    for (const model of models) {
+      if (dictionary[key = this.getDictionaryKey(model.getAttribute(this.localKey))] !== void 0) {
+        model.setRelation(relation, this.related.newCollection(dictionary[key]));
+      }
+    }
+    return models;
+  }
+  buildDictionary(results) {
+    const dictionary = {};
+    for (const result of results) {
+      if (dictionary[result.laravel_through_key] === void 0) {
+        dictionary[result.laravel_through_key] = [];
+      }
+      dictionary[result.laravel_through_key].push(result);
+    }
+    return dictionary;
+  }
+  async firstOrNew(attributes) {
+    let instance = await this.where(attributes).first();
+    return instance || this.related.newInstance(attributes);
+  }
+  async updateOrCreate(attributes, values = {}) {
+    return tap(await this.firstOrCreate(attributes, values), async (instance) => {
+      if (!instance.wasRecentlyCreated) {
+        await instance.fill(values).save();
+      }
+    });
+  }
+  async firstWhere(column, operator = null, value = null, boolean = "and") {
+    return await this.where(column, operator, value, boolean).first();
+  }
+  async first(columns = ["*"]) {
+    const results = await this.take(1).get(columns);
+    return results.count() > 0 ? results.first() : null;
+  }
+  async firstOrFail(columns = ["*"]) {
+    const model = await this.first(columns);
+    if (model) {
+      return model;
+    }
+    throw new ModelNotFoundError2().setModel(this.related.constructor);
+  }
+  async firstOr(columns = ["*"], callback = null) {
+    if (typeof columns === "function") {
+      callback = columns;
+      columns = ["*"];
+    }
+    const model = await this.first(columns);
+    if (model) {
+      return model;
+    }
+    return callback();
+  }
+  async find(id, columns = ["*"]) {
+    if (isArray5(id)) {
+      return await this.findMany(id, columns);
+    }
+    return await this.where(this.getRelated().getQualifiedKeyName(), "=", id).first(columns);
+  }
+  async findMany(ids, columns = ["*"]) {
+    if (ids.length === 0) {
+      return this.getRelated().newCollection();
+    }
+    return await this.whereIn(this.getRelated().getQualifiedKeyName(), ids).get(columns);
+  }
+  async findOrFail(id, columns = ["*"]) {
+    const result = await this.find(id, columns);
+    if (isArray5(id)) {
+      if (result.count() === id.length) {
+        return result;
+      }
+    } else if (result) {
+      return result;
+    }
+    throw new ModelNotFoundError2().setModel(this.related.constructor, id);
+  }
+  async getResults() {
+    return this.farParent[this.localKey] ? await this.get() : this.related.newCollection();
+  }
+  async get(columns = ["*"]) {
+    const builder = this.prepareQueryBuilder(columns);
+    let models = await builder.getModels();
+    if (models.count() > 0) {
+      models = await builder.eagerLoadRelations(models);
+    }
+    return this.related.newCollection(models);
+  }
+  async paginate(perPage = null, columns = ["*"], pageName = "page", page = null) {
+    this.query.addSelect(this.shouldSelect(columns));
+    return await this.query.paginate(perPage, columns, pageName, page);
+  }
+  shouldSelect(columns = ["*"]) {
+    if (columns == ["*"]) {
+      columns = [this.related.getTable() + ".*"];
+    }
+    return [...columns, this.getQualifiedFirstKeyName() + " as laravel_through_key"];
+  }
+  async chunk(count, callback) {
+    return await this.prepareQueryBuilder().chunk(count, callback);
+  }
+  prepareQueryBuilder(columns = ["*"]) {
+    const builder = this.query.applyScopes();
+    return builder.addSelect(this.shouldSelect(builder.getQuery().columns ? [] : columns));
+  }
+  getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
+    if (parentQuery.getQuery().from === query.getQuery().from) {
+      return this.getRelationExistenceQueryForSelfRelation(query, parentQuery, columns);
+    }
+    if (parentQuery.getQuery().from === this.throughParent.getTable()) {
+      return this.getRelationExistenceQueryForThroughSelfRelation(query, parentQuery, columns);
+    }
+    this.performJoin(query);
+    return query.select(columns).where(this.getQualifiedLocalKeyName(), "=", this.getQualifiedFirstKeyName());
+  }
+  getRelationExistenceQueryForSelfRelation(query, parentQuery, columns = ["*"]) {
+    const hash = this.getRelationCountHash();
+    query.from(query.getModel().getTable() + " as " + hash);
+    query.join(this.throughParent.getTable(), this.getQualifiedParentKeyName(), "=", hash + "." + this.secondKey);
+    if (this.throughParentSoftDeletes()) {
+      query.whereNull(this.throughParent.getQualifiedDeletedAtColumn());
+    }
+    query.getModel().setTable(hash);
+    return query.select(columns).whereColumn(parentQuery.getQuery().from + "." + this.localKey, "=", this.getQualifiedFirstKeyName());
+  }
+  getRelationExistenceQueryForThroughSelfRelation(query, parentQuery, columns = ["*"]) {
+    const hash = this.getRelationCountHash();
+    const table = this.throughParent.getTable() + " as " + hash;
+    query.join(table, hash + "." + this.secondLocalKey, "=", this.getQualifiedFarKeyName());
+    if (this.throughParentSoftDeletes()) {
+      query.whereNull(hash + "." + this.throughParent.getDeletedAtColumn());
+    }
+    return query.select(columns).where(parentQuery.getQuery().from + "." + this.localKey, "=", hash + "." + this.firstKey);
+  }
+  getQualifiedFarKeyName() {
+    return this.getQualifiedForeignKeyName();
+  }
+  getFirstKeyName() {
+    return this.firstKey;
+  }
+  getQualifiedFirstKeyName() {
+    return this.throughParent.qualifyColumn(this.firstKey);
+  }
+  getForeignKeyName() {
+    return this.secondKey;
+  }
+  getQualifiedForeignKeyName() {
+    return this.related.qualifyColumn(this.secondKey);
+  }
+  getLocalKeyName() {
+    return this.localKey;
+  }
+  getQualifiedLocalKeyName() {
+    return this.farParent.qualifyColumn(this.localKey);
+  }
+  getSecondLocalKeyName() {
+    return this.secondLocalKey;
+  }
+};
+var has_many_through_default = HasManyThrough;
+
+// src/relations/has-one-through.js
+var HasOneThrough = class extends compose(has_many_through_default, supports_default_models_default) {
+  async getResults() {
+    return await this.first() || this.getDefaultFor(this.farParent);
+  }
+  initRelation(models, relation) {
+    for (const model of models) {
+      model.setRelation(relation, this.getDefaultFor(model));
+    }
+    return models;
+  }
+  match(models, results, relation) {
+    const dictionary = this.buildDictionary(results);
+    for (const model of models) {
+      const key2 = this.getDictionaryKey(model.getAttribute(this.localKey));
+      if (dictionary[key2] !== void 0) {
+        const value = dictionary[key2];
+        model.setRelation(relation, value[0]);
+      }
+    }
+    return models;
+  }
+  newRelatedInstanceFor(parent) {
+    return this.related.newInstance();
+  }
+};
+var has_one_through_default = HasOneThrough;
+
+// src/concerns/has-relations.js
+import { omit as omit5 } from "radashi";
+var HasRelations = (Model2) => {
+  return class extends Model2 {
+    relations = {};
+    getRelation(relation) {
+      return this.relations[relation];
+    }
+    setRelation(relation, value) {
+      this.relations[relation] = value;
+      return this;
+    }
+    unsetRelation(relation) {
+      this.relations = omit5(this.relations, [relation]);
+      return this;
+    }
+    relationLoaded(relation) {
+      return this.relations[relation] !== void 0;
+    }
+    related(relation) {
+      if (typeof this[getRelationMethod(relation)] !== "function") {
+        const message = `Model [${this.constructor.name}]'s relation [${relation}] doesn't exist.`;
+        throw new RelationNotFoundError(message);
+      }
+      return this[getRelationMethod(relation)]();
+    }
+    async getRelated(relation) {
+      return await this.related(relation).getResults();
+    }
+    relationsToData() {
+      const data = {};
+      for (const key2 in this.relations) {
+        if (this.hidden.includes(key2)) {
+          continue;
+        }
+        if (this.visible.length > 0 && this.visible.includes(key2) === false) {
+          continue;
+        }
+        data[key2] = this.relations[key2] instanceof Array ? this.relations[key2].map((item) => item.toData()) : this.relations[key2] === null ? null : this.relations[key2].toData();
+      }
+      return data;
+    }
+    guessBelongsToRelation() {
+      let e = new Error();
+      let frame = e.stack.split("\n")[2];
+      let functionName = frame.split(" ")[5];
+      return getRelationName(functionName);
+    }
+    joiningTable(related, instance = null) {
+      const segments = [
+        instance ? instance.joiningTableSegment() : snakeCase(related.name),
+        this.joiningTableSegment()
+      ];
+      return segments.sort().join("_").toLocaleLowerCase();
+    }
+    joiningTableSegment() {
+      return snakeCase(this.constructor.name);
+    }
+    hasOne(related, foreignKey = null, localKey = null) {
+      const query = related.query();
+      const instance = new related();
+      foreignKey = foreignKey || this.getForeignKey();
+      localKey = localKey || this.getKeyName();
+      return new has_one_default(query, this, instance.getTable() + "." + foreignKey, localKey);
+    }
+    hasMany(related, foreignKey = null, localKey = null) {
+      const query = related.query();
+      const instance = new related();
+      foreignKey = foreignKey || this.getForeignKey();
+      localKey = localKey || this.getKeyName();
+      return new has_many_default(query, this, instance.getTable() + "." + foreignKey, localKey);
+    }
+    belongsTo(related, foreignKey = null, ownerKey = null, relation = null) {
+      const query = related.query();
+      const instance = new related();
+      foreignKey = foreignKey || instance.getForeignKey();
+      ownerKey = ownerKey || instance.getKeyName();
+      relation = relation || this.guessBelongsToRelation();
+      return new belongs_to_default(query, this, foreignKey, ownerKey, relation);
+    }
+    belongsToMany(related, table = null, foreignPivotKey = null, relatedPivotKey = null, parentKey = null, relatedKey = null) {
+      const query = related.query();
+      const instance = new related();
+      table = table || this.joiningTable(related, instance);
+      foreignPivotKey = foreignPivotKey || this.getForeignKey();
+      relatedPivotKey = relatedPivotKey || instance.getForeignKey();
+      parentKey = parentKey || this.getKeyName();
+      relatedKey = relatedKey || instance.getKeyName();
+      return new belongs_to_many_default(query, this, table, foreignPivotKey, relatedPivotKey, parentKey, relatedKey);
+    }
+    hasOneThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
+      through = new through();
+      const query = related.query();
+      firstKey = firstKey || this.getForeignKey();
+      secondKey = secondKey || through.getForeignKey();
+      return new has_one_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
+    }
+    hasManyThrough(related, through, firstKey = null, secondKey = null, localKey = null, secondLocalKey = null) {
+      through = new through();
+      const query = related.query();
+      firstKey = firstKey || this.getForeignKey();
+      secondKey = secondKey || through.getForeignKey();
+      return new has_many_through_default(query, this, through, firstKey, secondKey, localKey || this.getKeyName(), secondLocalKey || through.getKeyName());
+    }
+  };
+};
+var has_relations_default = HasRelations;
+
+// src/concerns/has-timestamps.js
+var HasTimestamps = (Model2) => {
+  return class extends Model2 {
+    static CREATED_AT = "created_at";
+    static UPDATED_AT = "updated_at";
+    static DELETED_AT = "deleted_at";
+    timestamps = true;
+    dateFormat = "YYYY-MM-DD HH:mm:ss";
+    usesTimestamps() {
+      return this.timestamps;
+    }
+    updateTimestamps() {
+      const time = this.freshTimestampString();
+      const updatedAtColumn = this.getUpdatedAtColumn();
+      if (updatedAtColumn && !this.isDirty(updatedAtColumn)) {
+        this.setUpdatedAt(time);
+      }
+      const createdAtColumn = this.getCreatedAtColumn();
+      if (!this.exists && createdAtColumn && !this.isDirty(createdAtColumn)) {
+        this.setCreatedAt(time);
+      }
+      return this;
+    }
+    getCreatedAtColumn() {
+      return this.constructor.CREATED_AT;
+    }
+    getUpdatedAtColumn() {
+      return this.constructor.UPDATED_AT;
+    }
+    setCreatedAt(value) {
+      this.attributes[this.getCreatedAtColumn()] = value;
+      return this;
+    }
+    setUpdatedAt(value) {
+      this.attributes[this.getUpdatedAtColumn()] = value;
+      return this;
+    }
+    freshTimestamp() {
+      const time = /* @__PURE__ */ new Date();
+      time.setMilliseconds(0);
+      return time;
+    }
+    freshTimestampString() {
+      return this.fromDateTime(this.freshTimestamp());
+    }
+  };
+};
+var has_timestamps_default = HasTimestamps;
+
+// src/concerns/hides-attributes.js
+import { diff as difference4 } from "radashi";
+var HidesAttributes = (Model2) => {
+  return class extends Model2 {
+    hidden = [];
+    visible = [];
+    makeVisible(...keys) {
+      const visible = flattenDeep(keys);
+      if (this.visible.length > 0) {
+        this.visible = [...this.visible, ...visible];
+      }
+      this.hidden = difference4(this.hidden, visible);
+      return this;
+    }
+    makeHidden(...keys) {
+      const hidden = flattenDeep(keys);
+      if (this.hidden.length > 0) {
+        this.hidden = [...this.hidden, ...hidden];
+      }
+      return this;
+    }
+    getHidden() {
+      return this.hidden;
+    }
+    getVisible() {
+      return this.visible;
+    }
+    setHidden(hidden) {
+      this.hidden = hidden;
+      return this;
+    }
+    setVisible(visible) {
+      this.visible = visible;
+      return this;
+    }
+  };
+};
+var hides_attributes_default = HidesAttributes;
+
+// src/concerns/unique-ids.js
+var UniqueIds = (Model2) => {
+  return class extends Model2 {
+    useUniqueIds = false;
+    usesUniqueIds() {
+      return this.useUniqueIds;
+    }
+    uniqueIds() {
+      return [];
+    }
+    newUniqueId() {
+      return null;
+    }
+    setUniqueIds() {
+      const uniqueIds = this.uniqueIds();
+      for (const column of uniqueIds) {
+        if (this[column] === null || this[column] === void 0) {
+          this[column] = this.newUniqueId();
+        }
+      }
+    }
+  };
+};
+var unique_ids_default = UniqueIds;
+
+// src/model.js
+import collect7 from "collect.js";
+import { assign as merge3 } from "radashi";
+import pluralize from "pluralize";
+var BaseModel = compose(class {
+}, has_attributes_default, hides_attributes_default, has_relations_default, has_timestamps_default, has_hooks_default, has_global_scopes_default, unique_ids_default);
+var Model = class _Model extends BaseModel {
+  primaryKey = "id";
+  // protected
+  builder = null;
+  // protected
+  table = null;
+  // protected
+  connection = null;
+  // protected
+  keyType = "int";
+  // protected
+  incrementing = true;
+  // protected
+  perPage = 15;
+  // protected
+  exists = false;
+  eagerLoad = {};
+  with = [];
+  withCount = [];
+  // protected
+  trx = null;
+  static globalScopes = {};
+  static pluginInitializers = {};
+  static _booted = {};
+  static resolver = null;
+  static query(trx = null) {
+    const instance = new this();
+    return instance.newQuery(trx);
+  }
+  static on(connection = null) {
+    const instance = new this();
+    instance.setConnection(connection);
+    return instance.newQuery();
+  }
+  static init(attributes = {}) {
+    return new this(attributes);
+  }
+  static extend(plugin, options) {
+    plugin(this, options);
+  }
+  static make(attributes = {}) {
+    const instance = new this();
+    for (let attribute in attributes) {
+      if (typeof instance[getRelationMethod(attribute)] !== "function") {
+        instance.setAttribute(attribute, attributes[attribute]);
+      } else {
+        const relation = instance[getRelationMethod(attribute)]();
+        const related = relation.getRelated().constructor;
+        if (relation instanceof has_one_default || relation instanceof belongs_to_default) {
+          instance.setRelation(attribute, related.make(attributes[attribute]));
+        } else if ((relation instanceof has_many_default || relation instanceof belongs_to_many_default) && Array.isArray(attributes[attribute])) {
+          instance.setRelation(attribute, new collection_default(attributes[attribute].map((item) => related.make(item))));
+        }
+      }
+    }
+    return instance;
+  }
+  constructor(attributes = {}) {
+    super();
+    this.bootIfNotBooted();
+    this.initializePlugins();
+    this.syncOriginal();
+    this.fill(attributes);
+    return this.asProxy();
+  }
+  bootIfNotBooted() {
+    if (this.constructor._booted[this.constructor.name] === void 0) {
+      this.constructor._booted[this.constructor.name] = true;
+      this.constructor.booting();
+      this.initialize();
+      this.constructor.boot();
+      this.constructor.booted();
+    }
+  }
+  static booting() {
+  }
+  static boot() {
+  }
+  static booted() {
+  }
+  static setConnectionResolver(resolver) {
+    this.resolver = resolver;
+  }
+  initialize() {
+  }
+  initializePlugins() {
+    if (typeof this.constructor.pluginInitializers[this.constructor.name] === "undefined") {
+      return;
+    }
+    for (const method of this.constructor.pluginInitializers[this.constructor.name]) {
+      this[method]();
+    }
+  }
+  addPluginInitializer(method) {
+    if (!this.constructor.pluginInitializers[this.constructor.name]) {
+      this.constructor.pluginInitializers[this.constructor.name] = [];
+    }
+    this.constructor.pluginInitializers[this.constructor.name].push(method);
+  }
+  newInstance(attributes = {}, exists = false) {
+    const model = new this.constructor();
+    model.exists = exists;
+    model.setConnection(this.getConnectionName());
+    model.setTable(this.getTable());
+    model.fill(attributes);
+    return model;
+  }
+  newFromBuilder(attributes = {}, connection = null) {
+    const model = this.newInstance({}, true);
+    model.setRawAttributes(attributes, true);
+    model.setConnection(connection || this.getConnectionName());
+    return model;
+  }
+  asProxy() {
+    const handler = {
+      get: function(target, prop) {
+        if (target[prop] !== void 0) {
+          return target[prop];
+        }
+        if (typeof prop === "string") {
+          return target.getAttribute(prop);
+        }
+      },
+      set: function(target, prop, value) {
+        if (target[prop] !== void 0 && typeof target !== "function") {
+          target[prop] = value;
+          return target;
+        }
+        if (typeof prop === "string") {
+          return target.setAttribute(prop, value);
+        }
+        return target;
+      }
+    };
+    return new Proxy(this, handler);
+  }
+  getKey() {
+    return this.getAttribute(this.getKeyName());
+  }
+  getKeyName() {
+    return this.primaryKey;
+  }
+  getForeignKey() {
+    return snakeCase(this.constructor.name) + "_" + this.getKeyName();
+  }
+  getConnectionName() {
+    return this.connection;
+  }
+  getTable() {
+    return this.table || pluralize(snakeCase(this.constructor.name));
+  }
+  getConnection() {
+    if (this.constructor.resolver) {
+      return this.constructor.resolver.getConnection(this.connection);
+    }
+    return arquebus_default.connection(this.connection);
+  }
+  setConnection(connection) {
+    this.connection = connection;
+    return this;
+  }
+  getKeyType() {
+    return this.keyType;
+  }
+  newQuery(trx = null) {
+    return this.addGlobalScopes(this.newQueryWithoutScopes(trx));
+  }
+  newQueryWithoutScopes(trx = null) {
+    return this.newModelQuery(trx).with(this.with).withCount(this.withCount);
+  }
+  newModelQuery(trx = null) {
+    const builder = new builder_default(trx || this.getConnection());
+    return builder.setModel(this);
+  }
+  addGlobalScopes(builder) {
+    const globalScopes = this.getGlobalScopes();
+    for (const identifier in globalScopes) {
+      const scope = globalScopes[identifier];
+      builder.withGlobalScope(identifier, scope);
+    }
+    return builder;
+  }
+  hasNamedScope(name) {
+    const scope = getScopeMethod(name);
+    return typeof this[scope] === "function";
+  }
+  callNamedScope(scope, parameters) {
+    const scopeMethod = getScopeMethod(scope);
+    return this[scopeMethod](...parameters);
+  }
+  setTable(table) {
+    this.table = table;
+    return this;
+  }
+  newCollection(models = []) {
+    return new collection_default(models);
+  }
+  async load(...relations) {
+    const query = this.constructor.query().with(...relations);
+    await query.eagerLoadRelations([this]);
+    return this;
+  }
+  async loadAggregate(relations, column, callback = null) {
+    await new collection_default([this]).loadAggregate(relations, column, callback);
+    return this;
+  }
+  async loadCount(...relations) {
+    relations = flattenDeep(relations);
+    return await this.loadAggregate(relations, "*", "count");
+  }
+  async loadMax(relations, column) {
+    return await this.loadAggregate(relations, column, "max");
+  }
+  async loadMin(relations, column) {
+    return await this.loadAggregate(relations, column, "min");
+  }
+  async loadSum(relations, column) {
+    return await this.loadAggregate(relations, column, "sum");
+  }
+  async increment(column, amount = 1, extra = {}, options = {}) {
+    return await this.incrementOrDecrement(column, amount, extra, "increment", options);
+  }
+  async decrement(column, amount = 1, extra = {}, options = {}) {
+    return await this.incrementOrDecrement(column, amount, extra, "decrement", options);
+  }
+  async incrementOrDecrement(column, amount, extra, method, options) {
+    const query = this.newModelQuery(options.client);
+    if (!this.exists) {
+      return await query[method](column, amount, extra);
+    }
+    this.attributes[column] = this[column] + (method === "increment" ? amount : amount * -1);
+    for (let key2 in extra) {
+      this.attributes[key2] = extra[key2];
+    }
+    await this.execHooks("updating", options);
+    return await tap(await query.where(this.getKeyName(), this.getKey())[method](column, amount, extra), async () => {
+      this.syncChanges();
+      await this.execHooks("updated", options);
+      this.syncOriginalAttribute(column);
+    });
+  }
+  toData() {
+    return merge3(this.attributesToData(), this.relationsToData());
+  }
+  toJSON() {
+    return this.toData();
+  }
+  toJson(...args) {
+    return JSON.stringify(this.toData(), ...args);
+  }
+  toString() {
+    return this.toJson();
+  }
+  fill(attributes) {
+    for (const key2 in attributes) {
+      this.setAttribute(key2, attributes[key2]);
+    }
+    return this;
+  }
+  transacting(trx) {
+    this.trx = trx;
+    return this;
+  }
+  trashed() {
+    return this[this.getDeletedAtColumn()] !== null;
+  }
+  getIncrementing() {
+    return this.incrementing;
+  }
+  setIncrementing(value) {
+    this.incrementing = value;
+    return this;
+  }
+  async save(options = {}) {
+    const query = this.newModelQuery(options.client);
+    let saved;
+    await this.execHooks("saving", options);
+    if (this.exists) {
+      if (this.isDirty() === false) {
+        saved = true;
+      } else {
+        await this.execHooks("updating", options);
+        if (this.usesTimestamps()) {
+          this.updateTimestamps();
+        }
+        const dirty = this.getDirty();
+        if (Object.keys(dirty).length > 0) {
+          await query.where(this.getKeyName(), this.getKey()).query.update(dirty);
+          this.syncChanges();
+          await this.execHooks("updated", options);
+        }
+        saved = true;
+      }
+    } else {
+      if (this.usesUniqueIds()) {
+        this.setUniqueIds();
+      }
+      await this.execHooks("creating", options);
+      if (this.usesTimestamps()) {
+        this.updateTimestamps();
+      }
+      const attributes = this.getAttributes();
+      if (this.getIncrementing()) {
+        const keyName = this.getKeyName();
+        const data = await query.insert([attributes], [keyName]);
+        this.setAttribute(keyName, data[0]?.[keyName] || data[0]);
+      } else {
+        if (Object.keys(attributes).length > 0) {
+          await query.insert(attributes);
+        }
+      }
+      this.exists = true;
+      await this.execHooks("created", options);
+      saved = true;
+    }
+    if (saved) {
+      await this.execHooks("saved", options);
+      this.syncOriginal();
+    }
+    return saved;
+  }
+  async update(attributes = {}, options = {}) {
+    if (!this.exists) {
+      return false;
+    }
+    for (let key2 in attributes) {
+      this[key2] = attributes[key2];
+    }
+    return await this.save(options);
+  }
+  async delete(options = {}) {
+    await this.execHooks("deleting", options);
+    await this.performDeleteOnModel(options);
+    await this.execHooks("deleted", options);
+    return true;
+  }
+  async performDeleteOnModel(options = {}) {
+    await this.setKeysForSaveQuery(this.newModelQuery(options.client)).delete();
+    this.exists = false;
+  }
+  setKeysForSaveQuery(query) {
+    query.where(this.getKeyName(), "=", this.getKey());
+    return query;
+  }
+  async forceDelete(options = {}) {
+    return await this.delete(options);
+  }
+  fresh() {
+    if (!this.exists) {
+      return;
+    }
+    return this.constructor.query().where(this.getKeyName(), this.getKey()).first();
+  }
+  async refresh() {
+    if (!this.exists) {
+      return;
+    }
+    const model = await this.constructor.query().where(this.getKeyName(), this.getKey()).first();
+    this.attributes = { ...model.attributes };
+    await this.load(collect7(this.relations).reject((relation) => {
+      return relation instanceof Pivot;
+    }).keys().all());
+    this.syncOriginal();
+    return this;
+  }
+  newPivot(parent, attributes, table, exists, using = null) {
+    return using ? using.fromRawAttributes(parent, attributes, table, exists) : Pivot.fromAttributes(parent, attributes, table, exists);
+  }
+  qualifyColumn(column) {
+    if (column.includes(".")) {
+      return column;
+    }
+    return `${this.getTable()}.${column}`;
+  }
+  getQualifiedKeyName() {
+    return this.qualifyColumn(this.getKeyName());
+  }
+  async push(options = {}) {
+    const saved = await this.save(options);
+    if (!saved) {
+      return false;
+    }
+    for (const relation in this.relations) {
+      let models = this.relations[relation];
+      models = models instanceof collection_default ? models.all() : [models];
+      for (const model of models) {
+        if (!await model.push(options)) {
+          return false;
+        }
+      }
+      ;
+    }
+    return true;
+  }
+  is(model) {
+    return model && model instanceof _Model && this.getKey() === model.getKey() && this.getTable() === model.getTable() && this.getConnectionName() === model.getConnectionName();
+  }
+  isNot(model) {
+    return !this.is(model);
+  }
+};
+var Pivot = class extends Model {
+  incrementing = false;
+  guarded = [];
+  pivotParent = null;
+  foreignKey = null;
+  relatedKey = null;
+  setPivotKeys(foreignKey, relatedKey) {
+    this.foreignKey = foreignKey;
+    this.relatedKey = relatedKey;
+    return this;
+  }
+  static fromRawAttributes(parent, attributes, table, exists = false) {
+    const instance = this.fromAttributes(parent, {}, table, exists);
+    instance.timestamps = instance.hasTimestampAttributes(attributes);
+    instance.attributes = attributes;
+    instance.exists = exists;
+    return instance;
+  }
+  static fromAttributes(parent, attributes, table, exists = false) {
+    const instance = new this();
+    instance.timestamps = instance.hasTimestampAttributes(attributes);
+    instance.setConnection(parent.connection).setTable(table).fill(attributes).syncOriginal();
+    instance.pivotParent = parent;
+    instance.exists = exists;
+    return instance;
+  }
+  hasTimestampAttributes(attributes = null) {
+    return (attributes || this.attributes)[this.constructor.CREATED_AT] !== void 0;
+  }
+};
+var model_default = Model;
+
+// src/query-builder.js
+var QueryBuilder = class _QueryBuilder {
+  connector = null;
+  constructor(config, connector) {
+    this.connector = connector(config);
+    return this.asProxy();
+  }
+  asProxy() {
+    const handler = {
+      get: function(target, prop) {
+        if (typeof target[prop] !== "undefined") {
+          return target[prop];
+        }
+        if (["destroy", "schema"].includes(prop)) {
+          return target.connector.schema;
+        }
+        if ([
+          "select",
+          "from",
+          "where",
+          "orWhere",
+          "whereColumn",
+          "whereRaw",
+          "whereNot",
+          "orWhereNot",
+          "whereIn",
+          "orWhereIn",
+          "whereNotIn",
+          "orWhereNotIn",
+          "whereNull",
+          "orWhereNull",
+          "whereNotNull",
+          "orWhereNotNull",
+          "whereExists",
+          "orWhereExists",
+          "whereNotExists",
+          "orWhereNotExists",
+          "whereBetween",
+          "orWhereBetween",
+          "whereNotBetween",
+          "orWhereNotBetween",
+          "whereLike",
+          "orWhereLike",
+          "whereILike",
+          "orWhereILike",
+          "whereJsonObject",
+          "whereJsonPath",
+          "whereJsonSupersetOf",
+          "whereJsonSubsetOf",
+          "join",
+          "joinRaw",
+          "leftJoin",
+          "leftOuterJoin",
+          "rightJoin",
+          "rightOuterJoin",
+          "crossJoin",
+          "transacting",
+          "groupBy",
+          "groupByRaw",
+          "returning",
+          "having",
+          "havingRaw",
+          "havingBetween",
+          "limit",
+          "offset",
+          "orderBy",
+          "orderByRaw",
+          // 'inRandomOrder',
+          "union",
+          "insert",
+          "forUpdate",
+          "forShare",
+          "distinct",
+          "clearOrder",
+          "clear",
+          "clearSelect",
+          "clearWhere",
+          "clearHaving",
+          "clearGroup"
+        ].includes(prop)) {
+          return (...args) => {
+            target.connector[prop](...args);
+            return target.asProxy();
+          };
+        }
+        return target.connector[prop];
+      },
+      set: function(target, prop, value) {
+        if (typeof target[prop] !== "undefined") {
+          target[prop] = value;
+          return target;
+        }
+        target.connector[prop] = value;
+        return target;
+      }
+    };
+    return new Proxy(this, handler);
+  }
+  async beginTransaction() {
+    const trx = await this.connector.transaction();
+    return new _QueryBuilder(null, () => trx);
+  }
+  table(table) {
+    const c = this.connector.table(table);
+    return new _QueryBuilder(null, () => c);
+  }
+  transaction(callback) {
+    if (callback) {
+      return this.connector.transaction((trx) => {
+        return callback(new _QueryBuilder(null, () => trx));
+      });
+    }
+    return callback;
+  }
+  async find(id, columns = ["*"]) {
+    return await this.connector.where("id", id).first(...columns);
+  }
+  async get(columns = ["*"]) {
+    return await this.connector;
+  }
+  async exists() {
+    return await this.connector.first() !== null;
+  }
+  skip(...args) {
+    return this.offset(...args);
+  }
+  take(...args) {
+    return this.limit(...args);
+  }
+  async chunk(count, callback) {
+    if (this.connector._statements.filter((item) => item.grouping === "order").length === 0) {
+      throw new Error("You must specify an orderBy clause when using this function.");
+    }
+    let page = 1;
+    let countResults;
+    do {
+      const builder = this.clone();
+      const results = await builder.forPage(page, count).get();
+      countResults = results.length;
+      if (countResults == 0) {
+        break;
+      }
+      const bool = await callback(results, page);
+      if (bool === false) {
+        return false;
+      }
+      page++;
+    } while (countResults === count);
+    return true;
+  }
+  async paginate(page = 1, perPage = 15) {
+    const query = this.clone();
+    const total = await query.clearOrder().count("*");
+    let results;
+    if (total > 0) {
+      const skip = (page - 1) * perPage;
+      this.take(perPage).skip(skip);
+      results = await this.get();
+    } else {
+      results = [];
+    }
+    return new paginator_default(results, parseInt(total), perPage, page);
+  }
+  forPage(page = 1, perPage = 15) {
+    return this.offset((page - 1) * perPage).limit(perPage);
+  }
+  toSQL(...args) {
+    return this.connector.toSQL(...args);
+  }
+  async count(column) {
+    const [{ aggregate }] = await this.connector.count(column, { as: "aggregate" });
+    return Number(aggregate);
+  }
+  async min(column) {
+    const [{ aggregate }] = await this.connector.min(column, { as: "aggregate" });
+    return Number(aggregate);
+  }
+  async max(column) {
+    const [{ aggregate }] = await this.connector.max(column, { as: "aggregate" });
+    return Number(aggregate);
+  }
+  async sum(column) {
+    const [{ aggregate }] = await this.connector.sum(column, { as: "aggregate" });
+    return Number(aggregate);
+  }
+  async avg(column) {
+    const [{ aggregate }] = await this.connector.avg(column, { as: "aggregate" });
+    return Number(aggregate);
+  }
+  clone() {
+    const c = this.connector.clone();
+    return new _QueryBuilder(null, () => c);
+  }
+  async delete() {
+    return await this.connector.delete();
+  }
+  async insert(...args) {
+    return await this.connector.insert(...args);
+  }
+  async update(...args) {
+    return await this.connector.update(...args);
+  }
+  destroy(...args) {
+    return this.connector.destroy(...args);
+  }
+  get _statements() {
+    return this.connector._statements;
+  }
+  get _single() {
+    return this.connector._single;
+  }
+  get from() {
+    return this.connector.from;
+  }
+};
+var query_builder_default = QueryBuilder;
+
+// src/arquebus.js
+var arquebus = class _arquebus {
+  static connectorFactory = null;
+  static instance = null;
+  constructor() {
+    this.manager = {};
+    this.connections = {};
+    this.models = {};
+  }
+  static getInstance() {
+    if (this.instance === null) {
+      this.instance = new _arquebus();
+    }
+    return this.instance;
+  }
+  static connection(connection = null) {
+    return this.getInstance().getConnection(connection);
+  }
+  static setConnectorFactory(connectorFactory) {
+    this.connectorFactory = connectorFactory;
+  }
+  static getConnectorFactory() {
+    return this.connectorFactory || Knex;
+  }
+  static addConnection(config, name = "default") {
+    return this.getInstance().addConnection(config, name);
+  }
+  static beginTransaction(connection = null) {
+    return this.getInstance().beginTransaction(connection);
+  }
+  static transaction(callback, connection = null) {
+    return this.getInstance().transaction(callback, connection);
+  }
+  static table(name, connection = null) {
+    return this.getInstance().table(name, connection);
+  }
+  static schema(connection = null) {
+    return this.getInstance().schema(connection);
+  }
+  static async destroyAll() {
+    await this.getInstance().destroyAll();
+  }
+  static createModel(name, options) {
+    return this.getInstance().createModel(name, options);
+  }
+  connection(connection = null) {
+    return this.getConnection(connection);
+  }
+  getConnection(name = null) {
+    name = name || "default";
+    if (this.manager[name] === void 0) {
+      const queryBuilder = new query_builder_default(this.connections[name], this.constructor.getConnectorFactory());
+      this.manager[name] = queryBuilder;
+    }
+    return this.manager[name];
+  }
+  addConnection(config, name = "default") {
+    this.connections[name] = {
+      ...config,
+      connection: {
+        ...config.connection,
+        dateStrings: true,
+        typeCast: function(field, next) {
+          if (field.type === "JSON") {
+            return field.string("utf8");
+          }
+          return next();
+        }
+      }
+    };
+  }
+  beginTransaction(connection = null) {
+    return this.connection(connection).transaction();
+  }
+  transaction(callback, connection = null) {
+    return this.connection(connection).transaction(callback);
+  }
+  table(name, connection = null) {
+    return this.connection(connection).table(name);
+  }
+  schema(connection = null) {
+    return this.connection(connection).schema;
+  }
+  async destroyAll() {
+    await Promise.all(Object.values(this.manager).map((connection) => {
+      return connection?.destroy();
+    }));
+  }
+  createModel(name, options = {}) {
+    let BaseModel2 = Model;
+    if ("plugins" in options) {
+      BaseModel2 = compose(BaseModel2, ...options.plugins);
+    }
+    this.models = {
+      ...this.models,
+      [name]: class extends BaseModel2 {
+        table = options?.table ?? null;
+        connection = options?.connection ?? null;
+        timestamps = options?.timestamps ?? true;
+        primaryKey = options?.primaryKey ?? "id";
+        keyType = options?.keyType ?? "int";
+        incrementing = options?.incrementing ?? true;
+        with = options?.with ?? [];
+        casts = options?.casts ?? {};
+        static CREATED_AT = options?.CREATED_AT ?? "created_at";
+        static UPDATED_AT = options?.UPDATED_AT ?? "updated_at";
+        static DELETED_AT = options?.DELETED_AT ?? "deleted_at";
+      }
+    };
+    if ("attributes" in options) {
+      for (const attribute in options.attributes) {
+        if (options.attributes[attribute] instanceof attribute_default === false) {
+          throw new Error('Attribute must be an instance of "Attribute"');
+        }
+        this.models[name].prototype[getAttrMethod(attribute)] = () => options.attributes[attribute];
+      }
+    }
+    if ("relations" in options) {
+      for (const relation in options.relations) {
+        this.models[name].prototype[getRelationMethod(relation)] = function() {
+          return options.relations[relation](this);
+        };
+      }
+    }
+    if ("scopes" in options) {
+      for (const scope in options.scopes) {
+        this.models[name].prototype[getScopeMethod(scope)] = options.scopes[scope];
+      }
+    }
+    this.models[name].setConnectionResolver(this);
+    return this.models[name];
+  }
+};
+var arquebus_default = arquebus;
+
+// bin/utils.js
+import * as color2 from "colorette";
+import escalade from "escalade/sync";
+import path2 from "path";
+import resolveFrom from "resolve-from";
+var join = path2.join;
+async function getMigrationPaths(cwd, migrator, defaultPath, path3) {
+  if (path3) {
+    return [join(cwd, path3)];
+  }
+  return [
+    ...migrator.getPaths(),
+    join(cwd, defaultPath)
+  ];
+}
+
+// src/migrate.js
+async function prepareDatabase(migrator) {
+  const exists = await migrator.repositoryExists();
+  if (!exists) {
+    console.log("Preparing database.");
+    console.log("Creating migration table...");
+    await migrator.repository.createRepository();
+    console.log("Migration table created successfully.");
+  }
+}
+async function setupConnection(config) {
+  const table = config?.migration?.table || "migrations";
+  arquebus_default.addConnection(config, "default");
+  Object.entries(config.connections || {}).forEach(([name, connection]) => {
+    arquebus_default.addConnection(connection, name);
+  });
+  const repository = new migration_repository_default(arquebus_default, table);
+  const migrator = new migrator_default(repository, arquebus_default);
+  return { arquebus: arquebus_default, migrator };
+}
+async function migrateRun(config, options = {}, destroyAll = false) {
+  const { arquebus: arquebus2, migrator } = await setupConnection(config);
+  await prepareDatabase(migrator);
+  const paths = await getMigrationPaths(process.cwd(), migrator, config?.migrations?.path, options.path);
+  await migrator.setOutput(true).run(paths, {
+    step: options.step,
+    pretend: options.pretend
+  });
+  if (destroyAll) {
+    await arquebus2.destroyAll();
+  }
+}
+async function migrateRollback(config, options = {}, destroyAll = false) {
+  const { arquebus: arquebus2, migrator } = await setupConnection(config);
+  const paths = await getMigrationPaths(process.cwd(), migrator, config?.migrations?.path, options.path);
+  await migrator.setOutput(true).rollback(paths, {
+    step: options.step || 0,
+    pretend: options.pretend,
+    batch: options.batch || 0
+  });
+  if (destroyAll) {
+    await arquebus2.destroyAll();
+  }
+}
+async function migrateStatus(config, options = {}, destroyAll = false) {
+  const { arquebus: arquebus2, migrator } = await setupConnection(config);
+  async function getAllMigrationFiles() {
+    return await migrator.getMigrationFiles(await getMigrationPaths(process.cwd(), migrator, config?.migrations?.path, options.path));
+  }
+  async function getStatusFor(ran2, batches2) {
+    const files = await getAllMigrationFiles();
+    return Object.values(files).map(function(migration) {
+      const migrationName = migrator.getMigrationName(migration);
+      const status = {
+        name: migrationName,
+        ran: ran2.includes(migrationName),
+        batch: ran2.includes(migrationName) ? batches2[migrationName] : null
+      };
+      return status;
+    });
+  }
+  const exists = await migrator.repositoryExists();
+  if (!exists) {
+    throw new Error("Migration table does not exist.");
+  }
+  const ran = await migrator.repository.getRan();
+  const batches = await migrator.getRepository().getMigrationBatches();
+  const migrations = await getStatusFor(ran, batches);
+  if (destroyAll) {
+    await arquebus2.destroyAll();
+  }
+  return migrations;
+}
+
+// src/concerns/has-unique-ids.js
+var HasUniqueIds = (Model2) => {
+  return class extends Model2 {
+    useUniqueIds = true;
+    uniqueIds() {
+      return [this.getKeyName()];
+    }
+    getKeyType() {
+      if (this.uniqueIds().includes(this.getKeyName())) {
+        return "string";
+      }
+      return this.keyType;
+    }
+    getIncrementing() {
+      if (this.uniqueIds().includes(this.getKeyName())) {
+        return false;
+      }
+      return this.incrementing;
+    }
+  };
+};
+var has_unique_ids_default = HasUniqueIds;
+
+// src/migrations/migration.js
+var Migration = class {
+  connection;
+  withinTransaction = true;
+  getConnection() {
+    return this.connection;
+  }
+};
+var migration_default = Migration;
+
+// src/pivot.js
+var pivot_default = Pivot;
+
+// src/soft-deleting-scope.js
+var hasJoins = (statements) => {
+  for (const statement of statements) {
+    if (statement?.grouping === "join") {
+      return true;
+    }
+  }
+  return false;
+};
+var SoftDeletingScope = class extends scope_default {
+  extensions = ["Restore", "RestoreOrCreate", "CreateOrRestore", "WithTrashed", "WithoutTrashed", "OnlyTrashed"];
+  apply(builder, model) {
+    builder.whereNull(model.getQualifiedDeletedAtColumn());
+  }
+  extend(builder) {
+    for (const extension of this.extensions) {
+      this[`add${extension}`](builder);
+    }
+    builder.onDelete(async (builder2) => {
+      const column = this.getDeletedAtColumn(builder2);
+      return await builder2.update({
+        [column]: builder2.getModel().freshTimestampString()
+      });
+    });
+  }
+  getDeletedAtColumn(builder) {
+    if (hasJoins(builder.getQuery()._statements)) {
+      return builder.getModel().getQualifiedDeletedAtColumn();
+    }
+    return builder.getModel().getDeletedAtColumn();
+  }
+  addRestore(builder) {
+    builder.macro("restore", (builder2) => {
+      builder2.withTrashed();
+      return builder2.update({
+        [builder2.getModel().getDeletedAtColumn()]: null
+      });
+    });
+  }
+  addRestoreOrCreate(builder) {
+    builder.macro("restoreOrCreate", async (builder2, attributes = {}, values = {}) => {
+      builder2.withTrashed();
+      return tap(await builder2.firstOrCreate(attributes, values), async (instance) => {
+        await instance.restore();
+      });
+    });
+  }
+  addCreateOrRestore(builder) {
+    builder.macro("createOrRestore", async (builder2, attributes = {}, values = {}) => {
+      builder2.withTrashed();
+      return tap(await builder2.createOrFirst(attributes, values), async (instance) => {
+        await instance.restore();
+      });
+    });
+  }
+  addWithTrashed(builder) {
+    builder.macro("withTrashed", (builder2, withTrashed = true) => {
+      if (!withTrashed) {
+        return builder2.withoutTrashed();
+      }
+      return builder2.withoutGlobalScope(this);
+    });
+  }
+  addWithoutTrashed(builder) {
+    builder.macro("withoutTrashed", (builder2) => {
+      const model = builder2.getModel();
+      builder2.withoutGlobalScope(this).whereNull(model.getQualifiedDeletedAtColumn());
+      return builder2;
+    });
+  }
+  addOnlyTrashed(builder) {
+    builder.macro("onlyTrashed", (builder2) => {
+      const model = builder2.getModel();
+      builder2.withoutGlobalScope(this).whereNotNull(model.getQualifiedDeletedAtColumn());
+      return builder2;
+    });
+  }
+};
+var soft_deleting_scope_default = SoftDeletingScope;
+
+// src/soft-deletes.js
+import { isNullish } from "radashi";
+var softDeletes = (Model2) => {
+  return class extends Model2 {
+    forceDeleting = false;
+    static bootSoftDeletes() {
+      this.addGlobalScope(new soft_deleting_scope_default());
+    }
+    initialize() {
+      super.initialize();
+      this.constructor.bootSoftDeletes();
+      this.addPluginInitializer("initializeSoftDeletes");
+    }
+    initializeSoftDeletes() {
+      if (this.casts[this.getDeletedAtColumn()] === void 0) {
+        this.casts[this.getDeletedAtColumn()] = "datetime";
+      }
+    }
+    async forceDelete() {
+      if (this.execHooks("forceDeleting") === false) {
+        return false;
+      }
+      this.forceDeleting = true;
+      return tap(await this.delete(), (deleted) => {
+        this.forceDeleting = false;
+        if (deleted) {
+          this.execHooks("forceDeleted", false);
+        }
+      });
+    }
+    forceDeleteQuietly() {
+      return this.withoutEvents(() => this.forceDelete());
+    }
+    async performDeleteOnModel(options = {}) {
+      if (this.forceDeleting) {
+        return tap(await this.setKeysForSaveQuery(this.newModelQuery()).forceDelete(), () => {
+          this.exists = false;
+        });
+      }
+      return await this.runSoftDelete(options);
+    }
+    async runSoftDelete(options = {}) {
+      const query = this.setKeysForSaveQuery(this.newModelQuery());
+      const time = this.freshTimestamp();
+      const columns = {
+        [this.getDeletedAtColumn()]: this.fromDateTime(time)
+      };
+      this[this.getDeletedAtColumn()] = time;
+      if (this.usesTimestamps() && this.getUpdatedAtColumn()) {
+        this[this.getUpdatedAtColumn()] = time;
+        columns[this.getUpdatedAtColumn()] = this.fromDateTime(time);
+      }
+      await query.update(columns);
+      this.syncOriginalAttributes(Object.keys(columns));
+      this.execHooks("trashed", options);
+    }
+    async restore(options = {}) {
+      if (this.execHooks("restoring", options) === false) {
+        return false;
+      }
+      this[this.getDeletedAtColumn()] = null;
+      this.exists = true;
+      const result = await this.save();
+      this.execHooks("restored", options);
+      return result;
+    }
+    restoreQuietly() {
+      return this.withoutEvents(() => this.restore());
+    }
+    trashed() {
+      return !isNullish(this[this.getDeletedAtColumn()]);
+    }
+    static softDeleted(callback) {
+      this.addHook("trashed", callback);
+    }
+    static restoring(callback) {
+      this.addHook("restoring", callback);
+    }
+    static restored(callback) {
+      this.addHook("restored", callback);
+    }
+    static forceDeleting(callback) {
+      this.addHook("forceDeleting", callback);
+    }
+    static forceDeleted(callback) {
+      this.addHook("forceDeleted", callback);
+    }
+    isForceDeleting() {
+      return this.forceDeleting;
+    }
+    getDeletedAtColumn() {
+      return this.constructor.DELETED_AT || "deleted_at";
+    }
+    getQualifiedDeletedAtColumn() {
+      return this.qualifyColumn(this.getDeletedAtColumn());
+    }
+  };
+};
+var soft_deletes_default = softDeletes;
+
+// src/index.js
+var make = (model, data, options = {}) => {
+  const { paginated } = options;
+  if (paginated) {
+    return new paginator_default(
+      data.data.map((item) => model.make(item)),
+      data.total,
+      data.per_page,
+      data.current_page
+    );
+  }
+  if (Array.isArray(data)) {
+    return new collection_default(data.map((item) => model.make(item)));
+  }
+  return model.make(data);
+};
+var makeCollection = (model, data) => new collection_default(data.map((item) => model.make(item)));
+var makePaginator = (model, data) => new paginator_default(
+  data.data.map((item) => model.make(item)),
+  data.total,
+  data.per_page,
+  data.current_page
+);
+export {
+  attribute_default as Attribute,
+  builder_default as Builder,
+  casts_attributes_default as CastsAttributes,
+  collection_default as Collection,
+  has_unique_ids_default as HasUniqueIds,
+  InvalidArgumentError,
+  migration_default as Migration,
+  model_default as Model,
+  ModelNotFoundError2 as ModelNotFoundError,
+  paginator_default as Paginator,
+  pivot_default as Pivot,
+  query_builder_default as QueryBuilder,
+  RelationNotFoundError,
+  scope_default as Scope,
+  soft_deletes_default as SoftDeletes,
+  arquebus_default as arquebus,
+  compose,
+  flattenDeep,
+  getAttrMethod,
+  getAttrName,
+  getGetterMethod,
+  getRelationMethod,
+  getRelationName,
+  getScopeMethod,
+  getScopeName,
+  getSetterMethod,
+  kebabCase,
+  make,
+  makeCollection,
+  makePaginator,
+  migrateRollback,
+  migrateRun,
+  migrateStatus,
+  now,
+  snakeCase,
+  tap
+};
+//# sourceMappingURL=index.js.map