@h3ravel/arquebus 0.1.5 → 0.2.0

package/{dist/index.cjs → bin/cli.cjs}

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -11,9 +12,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -27,49 +28,149 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.js
-var index_exports = {};
-__export(index_exports, {
-  Attribute: () => attribute_default,
-  Builder: () => builder_default,
-  CastsAttributes: () => casts_attributes_default,
-  Collection: () => collection_default,
-  HasUniqueIds: () => has_unique_ids_default,
-  InvalidArgumentError: () => InvalidArgumentError,
-  Migration: () => migration_default,
-  Model: () => model_default,
-  ModelNotFoundError: () => ModelNotFoundError2,
-  Paginator: () => paginator_default,
-  Pivot: () => pivot_default,
-  QueryBuilder: () => query_builder_default,
-  RelationNotFoundError: () => RelationNotFoundError,
-  Scope: () => scope_default,
-  SoftDeletes: () => soft_deletes_default,
-  arquebus: () => arquebus_default,
-  compose: () => compose,
-  flattenDeep: () => flattenDeep,
-  getAttrMethod: () => getAttrMethod,
-  getAttrName: () => getAttrName,
-  getGetterMethod: () => getGetterMethod,
-  getRelationMethod: () => getRelationMethod,
-  getRelationName: () => getRelationName,
-  getScopeMethod: () => getScopeMethod,
-  getScopeName: () => getScopeName,
-  getSetterMethod: () => getSetterMethod,
-  kebabCase: () => kebabCase,
-  make: () => make,
-  makeCollection: () => makeCollection,
-  makePaginator: () => makePaginator,
-  migrateRollback: () => migrateRollback,
-  migrateRun: () => migrateRun,
-  migrateStatus: () => migrateStatus,
-  now: () => now,
-  snakeCase: () => snakeCase,
-  tap: () => tap
+// src/cli/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  Cli: () => Cli
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(cli_exports);
+var import_commander = require("commander");
 
-// src/migrations/migration-repository.js
+// src/cli/utils.ts
+var import_promises = require("fs/promises");
+var import_chalk = __toESM(require("chalk"), 1);
+var import_sync = __toESM(require("escalade/sync"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_resolve_from = __toESM(require("resolve-from"), 1);
+var join = import_path.default.join;
+var Utils = class {
+  /**
+   * Wraps text with chalk
+   * 
+   * @param txt 
+   * @param color 
+   * @returns 
+   */
+  static textFormat(txt, color2) {
+    return String(txt).split(":").map((e, i, a) => i == 0 && a.length > 1 ? color2(" " + e + ": ") : e).join("");
+  }
+  /**
+   * Ouput formater object
+   * 
+   * @returns 
+   */
+  static output() {
+    return {
+      success: (msg, exit = false) => {
+        console.log(import_chalk.default.green("\u2713"), this.textFormat(msg, import_chalk.default.bgGreen), "\n");
+        if (exit) process.exit(0);
+      },
+      info: (msg, exit = false) => {
+        console.log(import_chalk.default.blue("\u2139"), this.textFormat(msg, import_chalk.default.bgBlue), "\n");
+        if (exit) process.exit(0);
+      },
+      error: (msg, exit = true) => {
+        if (msg instanceof Error) {
+          if (msg.message) {
+            console.error(import_chalk.default.red("\u2716"), this.textFormat(msg.message, import_chalk.default.bgRed));
+          }
+          console.error(import_chalk.default.red(`${msg.detail ? `${msg.detail}
+` : ""}${msg.stack}`), "\n");
+        } else {
+          console.error(import_chalk.default.red("\u2716"), this.textFormat(msg, import_chalk.default.bgRed), "\n");
+        }
+        if (exit) process.exit(1);
+      },
+      quiet: () => {
+        process.exit(0);
+      }
+    };
+  }
+  static findModulePkg(moduleId, cwd) {
+    const parts = moduleId.replace(/\\/g, "/").split("/");
+    let packageName = "";
+    if (parts.length > 0 && parts[0][0] === "@") {
+      packageName += parts.shift() + "/";
+    }
+    packageName += parts.shift();
+    const packageJson = import_path.default.join(packageName, "package.json");
+    const resolved = import_resolve_from.default.silent(cwd ?? process.cwd(), packageJson);
+    if (!resolved) {
+      return;
+    }
+    return import_path.default.join(import_path.default.dirname(resolved), parts.join("/"));
+  }
+  static async getMigrationPaths(cwd, migrator, defaultPath, path5) {
+    if (path5) {
+      return [join(cwd, path5)];
+    }
+    return [
+      ...migrator.getPaths(),
+      join(cwd, defaultPath)
+    ];
+  }
+  static twoColumnDetail(name, value) {
+    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 console.log(name, import_chalk.default.gray(".".repeat(dots)), value);
+  }
+  /**
+   * Check if file exists
+   * 
+   * @param path 
+   * @returns 
+   */
+  static async fileExists(path5) {
+    try {
+      await (0, import_promises.access)(path5);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  static findUpConfig(cwd, name, extensions) {
+    return (0, import_sync.default)(cwd, (_dir, names) => {
+      for (const ext of extensions) {
+        const filename = `${name}.${ext}`;
+        if (names.includes(filename)) {
+          return filename;
+        }
+      }
+      return false;
+    });
+  }
+};
+var TableGuesser = class _TableGuesser {
+  static CREATE_PATTERNS = [
+    /^create_(\w+)_table$/,
+    /^create_(\w+)$/
+  ];
+  static CHANGE_PATTERNS = [
+    /.+_(to|from|in)_(\w+)_table$/,
+    /.+_(to|from|in)_(\w+)$/
+  ];
+  static guess(migration) {
+    for (const pattern of _TableGuesser.CREATE_PATTERNS) {
+      const matches = migration.match(pattern);
+      if (matches) {
+        return [matches[1], true];
+      }
+    }
+    for (const pattern of _TableGuesser.CHANGE_PATTERNS) {
+      const matches = migration.match(pattern);
+      if (matches) {
+        return [matches[2], false];
+      }
+    }
+    return [];
+  }
+};
+
+// src/cli/cli.ts
+var import_promises4 = require("fs/promises");
+
+// src/migrations/migration-repository.ts
 var MigrationRepository = class {
   resolver;
   table;
@@ -143,17 +244,16 @@ var MigrationRepository = class {
 };
 var migration_repository_default = MigrationRepository;
 
-// src/migrations/migrator.js
-var color = __toESM(require("colorette"), 1);
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_util = require("util");
+// src/migrations/migrator.ts
+var import_chalk2 = __toESM(require("chalk"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_path2 = __toESM(require("path"), 1);
 async function glob(folderPath) {
-  const files = await (0, import_util.promisify)(import_fs.default.readdir)(folderPath);
+  const files = await import_promises2.default.readdir(folderPath);
   const allFiles = [];
   for (const file of files) {
     const filePath = `${folderPath}/${file}`;
-    const stats = await (0, import_util.promisify)(import_fs.default.stat)(filePath);
+    const stats = await import_promises2.default.stat(filePath);
     if (stats.isFile()) {
       allFiles.push(filePath);
     } else if (stats.isDirectory()) {
@@ -168,7 +268,7 @@ var Migrator = class {
   repository;
   files;
   resolver;
-  connection = null;
+  connection;
   paths = [];
   output = null;
   constructor(repository, resolver = null, files = null, dispatcher = null) {
@@ -203,12 +303,18 @@ var Migrator = class {
       }
     }
   }
-  async runUp(file, batch, pretend) {
-    const migration = this.resolvePath(file);
+  async runUp(file, batch, _pretend) {
+    const migration = await this.resolvePath(file);
     const name = this.getMigrationName(file);
     await this.writeTask(name, () => this.runMigration(migration, "up"));
     await this.repository.log(name, batch);
   }
+  async runDown(file, migration, _pretend) {
+    const instance = await this.resolvePath(file);
+    const name = this.getMigrationName(file);
+    await this.writeTask(name, () => this.runMigration(instance, "down"));
+    await this.repository.delete(migration);
+  }
   async rollback(paths = [], options = {}) {
     const migrations = await this.getMigrationsForRollback(options);
     if (migrations.length === 0) {
@@ -218,10 +324,10 @@ var Migrator = class {
     return await this.rollbackMigrations(migrations, paths, options);
   }
   async getMigrationsForRollback(options) {
-    if (options.step > 0) {
+    if (options.step && options.step > 0) {
       return await this.repository.getMigrations(options.step);
     }
-    if (options.batch > 0) {
+    if (options.batch && options.batch > 0) {
       return await this.repository.getMigrationsByBatch(options.batch);
     }
     return await this.repository.getLast();
@@ -233,7 +339,7 @@ var Migrator = class {
     for (const migration of migrations) {
       const file = files[migration.migration];
       if (!file) {
-        this.writeTwoColumns(migration.migration, color.yellow("Migration not found"));
+        this.writeTwoColumns(migration.migration, import_chalk2.default.yellow("Migration not found"));
         continue;
       }
       rolledBack.push(file);
@@ -241,22 +347,11 @@ var Migrator = class {
     }
     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);
+  reset(_paths = [], _pretend = false) {
+    const _migrations = this.repository.getRan().then((r) => r.reverse());
+    return [];
   }
   resetMigrations(migrations, paths, pretend = false) {
-    migrations = migrations.map((m) => ({ migration: m }));
     return this.rollbackMigrations(migrations, paths, { pretend });
   }
   async runMigration(migration, method) {
@@ -273,25 +368,27 @@ var Migrator = class {
     }
   }
   async runMethod(connection, migration, method) {
+    await migration[method]?.(connection.schema, connection);
+  }
+  async resolvePath(filePath) {
     try {
-      await migration[method](connection.schema, connection);
-    } finally {
+      return new (await import(filePath)).default();
+    } catch {
     }
-  }
-  resolvePath(path3) {
-    return new migrationClass();
+    return new class {
+    }();
   }
   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);
+    for (const p of paths) {
+      if (p.endsWith(".js") || p.endsWith(".ts")) {
+        files.push(p);
         continue;
       }
-      files.push(...await glob(path3));
+      files.push(...await glob(p));
     }
     return files.filter(Boolean).reduce((result, file) => {
       result[this.getMigrationName(file)] = file;
@@ -299,10 +396,10 @@ var Migrator = class {
     }, {});
   }
   getMigrationName(filePath) {
-    return import_path.default.basename(filePath).replace(".js", "");
+    return import_path2.default.basename(filePath).replace(".js", "");
   }
-  path(path3) {
-    this.paths = Array.from(/* @__PURE__ */ new Set([...this.paths, path3]));
+  path(p) {
+    this.paths = Array.from(/* @__PURE__ */ new Set([...this.paths, p]));
   }
   getPaths() {
     return this.paths;
@@ -341,36 +438,34 @@ var Migrator = class {
     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);
+    this.write(name, import_chalk2.default.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"));
+      this.writeTwoColumns(
+        import_chalk2.default.green(description),
+        import_chalk2.default.gray(`${Math.floor(duration)}ms`),
+        result !== false ? import_chalk2.default.green("\u2714") : import_chalk2.default.red("\u2718")
+      );
     }
   }
 };
 var migrator_default = Migrator;
 
-// src/utils.js
+// src/utils.ts
 var import_radashi = require("radashi");
-var import_advancedFormat = __toESM(require("dayjs/plugin/advancedFormat"), 1);
+var import_advancedFormat = __toESM(require("dayjs/plugin/advancedFormat.js"), 1);
 var import_dayjs = __toESM(require("dayjs"), 1);
 import_dayjs.default.extend(import_advancedFormat.default);
-var now = (format = "YYYY-MM-DD HH:mm:ss") => (0, import_dayjs.default)().format(format);
 var getRelationName = (relationMethod) => {
   return (0, import_radashi.snake)(relationMethod.substring(8));
 };
-var getScopeName = (scopeMethod) => {
-  return (0, import_radashi.snake)(scopeMethod.substring(5));
-};
 var getRelationMethod = (relation) => {
   return (0, import_radashi.camel)(`relation_${relation}`);
 };
@@ -386,41 +481,37 @@ var getGetterMethod = (attr) => {
 var getSetterMethod = (attr) => {
   return (0, import_radashi.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
-  );
+  return mixins.reduce((acc, mixin) => mixin(acc), Base);
 }
 var flattenDeep = (arr) => Array.isArray(arr) ? arr.reduce((a, b) => a.concat(flattenDeep(b)), []) : [arr];
-var kebabCase = (str) => (0, import_radashi.trim)((0, import_radashi.dash)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
 var snakeCase = (str) => (0, import_radashi.trim)((0, import_radashi.snake)(str.replace(/[^a-zA-Z0-9_-]/g, "-")), "_-");
 
-// src/casts/attribute.js
+// src/casts/attribute.ts
 var Attribute = class _Attribute {
   get;
   set;
   withCaching = false;
   withObjectCaching = true;
-  constructor({ get: get2 = null, set: set2 = null }) {
+  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 make({ get: get2 = null, set: set2 = null }) {
+    return new _Attribute({ get: get2, set: set2 });
   }
   static get(get2) {
-    return new _Attribute(get2);
+    return new _Attribute({ get: get2 });
   }
   static set(set2) {
-    return new _Attribute(null, set2);
+    return new _Attribute({ set: set2 });
   }
   withoutObjectCaching() {
     this.withObjectCaching = false;
@@ -433,16 +524,17 @@ var Attribute = class _Attribute {
 };
 var attribute_default = Attribute;
 
-// src/arquebus.js
+// src/arquebus.ts
 var import_knex = __toESM(require("knex"), 1);
 
-// src/relations/relation.js
+// src/relations/relation.ts
 var Relation = class {
   query;
   parent;
   related;
   eagerKeysWereEmpty = false;
   static constraints = true;
+  static selfJoinCount = 0;
   constructor(query, parent) {
     this.query = query;
     this.parent = parent;
@@ -483,30 +575,30 @@ var Relation = class {
   getRelated() {
     return this.related;
   }
-  getKeys(models, key2) {
-    return models.map((model) => key2 ? model.attributes[key2] : model.getKey()).sort();
+  getKeys(models, key) {
+    return models.map((model) => key ? model.attributes[key] : model.getKey()).sort();
   }
   getRelationQuery() {
     return this.query;
   }
-  whereInEager(whereIn, key2, modelKeys, query = null) {
-    (query || this.query)[whereIn](key2, modelKeys);
+  whereInEager(whereIn, key, modelKeys, query = null) {
+    (query || this.query)[whereIn](key, modelKeys);
     if (modelKeys.length === 0) {
       this.eagerKeysWereEmpty = true;
     }
   }
-  whereInMethod(model, key2) {
+  whereInMethod(model, key) {
     return "whereIn";
-    const segments = key2.split(".");
+    const segments = key.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 = "*") {
+  async get(columns = ["*"]) {
     return await this.query.get(columns);
   }
-  async first(columns = "*") {
+  async first(columns = ["*"]) {
     return await this.query.first(columns);
   }
   async paginate(...args) {
@@ -533,10 +625,13 @@ var Relation = class {
   getQualifiedParentKeyName() {
     return this.parent.getQualifiedKeyName();
   }
+  getExistenceCompareKey() {
+    return this.getQualifiedForeignKeyName?.();
+  }
 };
 var relation_default = Relation;
 
-// src/relations/concerns/supports-default-models.js
+// src/relations/concerns/supports-default-models.ts
 var SupportsDefaultModels = (Relation2) => {
   return class extends Relation2 {
     _withDefault;
@@ -553,8 +648,8 @@ var SupportsDefaultModels = (Relation2) => {
         return this._withDefault(instance, parent) || instance;
       }
       if (typeof this._withDefault === "object") {
-        for (const key2 in this._withDefault) {
-          instance.setAttribute(key2, this._withDefault[key2]);
+        for (const key in this._withDefault) {
+          instance.setAttribute(key, this._withDefault[key]);
         }
       }
       return instance;
@@ -563,7 +658,7 @@ var SupportsDefaultModels = (Relation2) => {
 };
 var supports_default_models_default = SupportsDefaultModels;
 
-// src/relations/belongs-to.js
+// src/relations/belongs-to.ts
 var BelongsTo = class extends compose(relation_default, supports_default_models_default) {
   foreignKey;
   ownerKey;
@@ -605,7 +700,7 @@ var BelongsTo = class extends compose(relation_default, supports_default_models_
     return this.child.qualifyColumn(this.foreignKey);
   }
   getRelationExistenceQuery(query, parentQuery, columns = ["*"]) {
-    if (parentQuery.getQuery()._single.table == query.getQuery()._single.table) {
+    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));
@@ -614,21 +709,21 @@ var BelongsTo = class extends compose(relation_default, supports_default_models_
     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());
+    return query.whereColumn(`${hash}.${this.ownerKey}`, "=", this.getQualifiedForeignKeyName());
   }
   initRelation(models, relation) {
-    models.map((model) => {
+    models.forEach((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));
+    const key = `${this.related.getTable()}.${this.ownerKey}`;
+    this.query.whereIn(key, this.getEagerModelKeys(models));
   }
   getEagerModelKeys(models) {
     const keys = [];
-    models.map((model) => {
+    models.forEach((model) => {
       const value = model[this.foreignKey];
       if (value !== null && value !== void 0) {
         keys.push(value);
@@ -654,27 +749,34 @@ var BelongsTo = class extends compose(relation_default, supports_default_models_
   addConstraints() {
     if (this.constructor.constraints) {
       const table = this.related.getTable();
-      this.query.where(table + "." + this.ownerKey, "=", this.child[this.foreignKey]);
+      this.query.where(`${table}.${this.ownerKey}`, "=", this.child[this.foreignKey]);
     }
   }
-  newRelatedInstanceFor(parent) {
+  newRelatedInstanceFor(_parent) {
     return this.related.newInstance();
   }
 };
 var belongs_to_default = BelongsTo;
 
-// src/relations/belongs-to-many.js
-var import_radashi4 = require("radashi");
+// src/relations/belongs-to-many.ts
+var import_radashi5 = require("radashi");
 
-// src/collection.js
+// src/collection.ts
 var import_collect = require("collect.js");
 var import_radashi2 = require("radashi");
 var Collection = class _Collection extends import_collect.Collection {
+  newConstructor(...args) {
+    const constr = this.getConstructor();
+    return new constr(...args);
+  }
+  getConstructor() {
+    return this.constructor;
+  }
   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.newConstructor(items);
     }
     return this;
   }
@@ -686,7 +788,7 @@ var Collection = class _Collection extends import_collect.Collection {
     const attributes = (0, import_radashi2.diff)(Object.keys(models.first().getAttributes()), [models.first().getKeyName()]);
     this.each((model) => {
       const extraAttributes = (0, import_radashi2.pick)(models.get(model.getKey()).getAttributes(), attributes);
-      model.fill(extraAttributes).syncOriginalAttributes(attributes);
+      model.fill(extraAttributes).syncOriginalAttributes(...attributes);
     });
     return this;
   }
@@ -711,17 +813,17 @@ var Collection = class _Collection extends import_collect.Collection {
   modelKeys() {
     return this.all().map((item) => item.getKey());
   }
-  contains(key2, operator = null, value = null) {
+  contains(key, operator, value) {
     if (arguments.length > 1) {
-      return super.contains(key2, operator, value);
+      return super.contains(key, value ?? operator);
     }
-    if (key2 instanceof model_default) {
+    if (key instanceof model_default) {
       return super.contains((model) => {
-        return model.is(key2);
+        return model.is(key);
       });
     }
     return super.contains((model) => {
-      return model.getKey() == key2;
+      return model.getKey() == key;
     });
   }
   diff(items) {
@@ -744,34 +846,34 @@ var Collection = class _Collection extends import_collect.Collection {
       return intersect;
     }
     const dictionary = this.getDictionary(items);
-    for (let item of this.items) {
+    for (const 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);
+  unique(key, _strict = false) {
+    if (key) {
+      return super.unique(key);
     }
     return new this.constructor(Object.values(this.getDictionary()));
   }
-  find(key2, defaultValue = null) {
-    if (key2 instanceof model_default) {
-      key2 = key2.getKey();
+  find(key, defaultValue = null) {
+    if (key instanceof model_default) {
+      key = key.getKey();
     }
-    if ((0, import_radashi2.isArray)(key2)) {
+    if ((0, import_radashi2.isArray)(key)) {
       if (this.isEmpty()) {
         return new this.constructor();
       }
-      return this.whereIn(this.first().getKeyName(), key2);
+      return this.whereIn(this.first().getKeyName(), key);
     }
     (0, import_collect.collect)(this.items).first((model) => {
-      return model.getKey() == key2;
+      return model.getKey() == key;
     });
     return this.items.filter((model) => {
-      return model.getKey() == key2;
+      return model.getKey() == key;
     })[0] || defaultValue;
   }
   async fresh(...args) {
@@ -808,8 +910,8 @@ var Collection = class _Collection extends import_collect.Collection {
     const dictionary = (0, import_radashi2.pick)(this.getDictionary(), keys);
     return new this.constructor(Object.values(dictionary));
   }
-  getDictionary(items = null) {
-    items = items === null ? this.items : items;
+  getDictionary(items) {
+    items = !items ? this.items : items;
     const dictionary = {};
     items.map((value) => {
       dictionary[value.getKey()] = value;
@@ -838,9 +940,9 @@ var Collection = class _Collection extends import_collect.Collection {
   toJson(...args) {
     return JSON.stringify(this.toData(), ...args);
   }
-  [Symbol.iterator]() {
+  [Symbol.iterator] = () => {
     const items = this.items;
-    let length = this.items.length;
+    const length = this.items.length;
     let n = 0;
     return {
       next() {
@@ -852,11 +954,11 @@ var Collection = class _Collection extends import_collect.Collection {
         };
       }
     };
-  }
+  };
 };
 var collection_default = Collection;
 
-// src/relations/concerns/interacts-with-pivot-table.js
+// src/relations/concerns/interacts-with-pivot-table.ts
 var import_radashi3 = require("radashi");
 var import_collect2 = require("collect.js");
 var InteractsWithPivotTable = (Relation2) => {
@@ -868,14 +970,14 @@ var InteractsWithPivotTable = (Relation2) => {
       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) {
+    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) {
+    async detach(ids, _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);
@@ -906,7 +1008,7 @@ var InteractsWithPivotTable = (Relation2) => {
         await this.detach(detach);
         changes.detached = this.castKeys(detach);
       }
-      changes = (0, import_radashi3.merge)(changes, await this.attachNew(records, current, false));
+      changes = (0, import_radashi3.assign)(changes, await this.attachNew(records, current, false));
       return changes;
     }
     syncWithoutDetaching(ids) {
@@ -918,7 +1020,7 @@ var InteractsWithPivotTable = (Relation2) => {
       }), detaching);
     }
     withPivot(columns) {
-      this.pivotColumns = this.pivotColumns.concat((0, import_radashi3.isArray)(columns) ? columns : Array.prototype.slice.call(arguments));
+      this.pivotColumns = this.pivotColumns.concat((0, import_radashi3.isArray)(columns) ? columns : Array.prototype.slice.call(columns));
       return this;
     }
     async attachNew(records, current, touch = true) {
@@ -961,7 +1063,7 @@ var InteractsWithPivotTable = (Relation2) => {
       }
       return record;
     }
-    async updateExistingPivotUsingCustomClass(id, attributes, touch) {
+    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) {
@@ -991,8 +1093,8 @@ var InteractsWithPivotTable = (Relation2) => {
         return this.castKey(v);
       });
     }
-    castKey(key2) {
-      return this.getTypeSwapValue(this.related.getKeyType(), key2);
+    castKey(key) {
+      return this.getTypeSwapValue(this.related.getKeyType(), key);
     }
     getTypeSwapValue(type, value) {
       switch (type.toLowerCase()) {
@@ -1047,15 +1149,15 @@ var InteractsWithPivotTable = (Relation2) => {
     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));
+      for (const key in ids) {
+        const value = ids[key];
+        records.push(this.formatAttachRecord(key, value, attributes, hasTimestamps));
       }
       return records;
     }
-    formatAttachRecord(key2, value, attributes, hasTimestamps) {
-      const [id, newAttributes] = this.extractAttachIdAndAttributes(key2, value, attributes);
-      return (0, import_radashi3.merge)(this.baseAttachRecord(id, hasTimestamps), newAttributes);
+    formatAttachRecord(key, value, attributes, hasTimestamps) {
+      const [id, newAttributes] = this.extractAttachIdAndAttributes(key, value, attributes);
+      return (0, import_radashi3.assign)(this.baseAttachRecord(id, hasTimestamps), newAttributes);
     }
     baseAttachRecord(id, timed) {
       let record = {};
@@ -1069,12 +1171,12 @@ var InteractsWithPivotTable = (Relation2) => {
       });
       return record;
     }
-    extractAttachIdAndAttributes(key2, value, newAttributes) {
-      return (0, import_radashi3.isArray)(value) ? [key2, { ...value, ...newAttributes }] : [value, newAttributes];
+    extractAttachIdAndAttributes(key, value, newAttributes) {
+      return (0, import_radashi3.isArray)(value) ? [key, { ...value, ...newAttributes }] : [value, newAttributes];
     }
-    hasPivotColumn = function(column) {
+    hasPivotColumn(column) {
       return this.pivotColumns.includes(column);
-    };
+    }
     parseIds(value) {
       if (value instanceof Model) {
         return [value[this.relatedKey]];
@@ -1088,7 +1190,46 @@ var InteractsWithPivotTable = (Relation2) => {
 };
 var interacts_with_pivot_table_default = InteractsWithPivotTable;
 
-// src/relations/belongs-to-many.js
+// src/errors.ts
+var import_radashi4 = require("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 ModelNotFoundError = class extends BaseError {
+  model;
+  ids = [];
+  constructor() {
+    super("");
+  }
+  setModel(model, ids = []) {
+    this.model = model;
+    this.ids = (0, import_radashi4.isArray)(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/relations/belongs-to-many.ts
 var import_collect3 = require("collect.js");
 var BelongsToMany = class extends compose(relation_default, interacts_with_pivot_table_default) {
   table;
@@ -1102,7 +1243,6 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
   pivotWhereIns = [];
   pivotWhereNulls = [];
   accessor = "pivot";
-  // withTimestamps = false;
   using;
   pivotCreatedAt;
   pivotUpdatedAt;
@@ -1130,7 +1270,12 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
   }
   performJoin(query = null) {
     query = query || this.query;
-    query.join(this.getTable(), this.getQualifiedRelatedKeyName(), "=", this.qualifyPivotColumn(this.relatedPivotKey));
+    query.join(
+      this.getTable(),
+      this.getQualifiedRelatedKeyName(),
+      "=",
+      this.qualifyPivotColumn(this.relatedPivotKey)
+    );
     return this;
   }
   getTable() {
@@ -1143,10 +1288,14 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
     return this.parent[this.parentKey] !== null ? await this.get() : new collection_default([]);
   }
   addWhereConstraints() {
-    this.query.where(this.getQualifiedForeignPivotKeyName(), "=", this.parent[this.parentKey]);
+    this.query.where(
+      this.getQualifiedForeignPivotKeyName(),
+      "=",
+      this.parent[this.parentKey]
+    );
     return this;
   }
-  async get(columns = ["*"]) {
+  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();
@@ -1192,16 +1341,19 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
   }
   hydratePivotRelation(models) {
     models.map((model) => {
-      model.setRelation(this.accessor, this.newExistingPivot(this.migratePivotAttributes(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 = (0, import_radashi4.omit)(model.attributes, [key2]);
+    for (const key in model.attributes) {
+      const value = model.attributes[key];
+      if (key.startsWith("pivot_")) {
+        values[key.substring(6)] = value;
+        model.attributes = (0, import_radashi5.omit)(model.attributes, [key]);
       }
     }
     return values;
@@ -1212,7 +1364,7 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
     return this.withPivot(this.createdAt(), this.updatedAt());
   }
   shouldSelect(columns = ["*"]) {
-    if ((0, import_radashi4.isEqual)(columns, ["*"])) {
+    if ((0, import_radashi5.isEqual)(columns, ["*"])) {
       columns = [this.related.getTable() + ".*"];
     }
     return columns.concat(this.aliasedPivotColumns());
@@ -1229,9 +1381,9 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
   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]);
+      const key = model.getKey();
+      if (dictionary[key] !== void 0) {
+        model.setRelation(relation, dictionary[key]);
       }
     });
     return models;
@@ -1248,7 +1400,10 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
     return dictionary;
   }
   addEagerConstraints(models) {
-    this.query.whereIn(this.getQualifiedForeignPivotKeyName(), this.getKeys(models, this.parentKey));
+    this.query.whereIn(
+      this.getQualifiedForeignPivotKeyName(),
+      this.getKeys(models, this.parentKey)
+    );
   }
   getQualifiedForeignPivotKeyName() {
     return this.qualifyPivotColumn(this.foreignPivotKey);
@@ -1311,14 +1466,6 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
   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);
@@ -1336,68 +1483,35 @@ var BelongsToMany = class extends compose(relation_default, interacts_with_pivot
 };
 var belongs_to_many_default = BelongsToMany;
 
-// src/errors.js
-var import_radashi5 = require("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 = (0, import_radashi5.isArray)(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
+// src/builder.ts
 var import_radashi6 = require("radashi");
 var import_collect4 = require("collect.js");
 
-// src/paginator.js
+// src/paginator.ts
 var Paginator = class {
-  static formatter = null;
+  static formatter;
   _items;
   _total;
   _perPage;
   _lastPage;
   _currentPage;
+  hasMore = false;
+  options = {};
   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 = {}) {
+  constructor(items, total, perPage, currentPage = 1, options = {}) {
     this.options = options;
-    for (const key2 in options) {
-      const value = options[key2];
-      this[key2] = value;
+    for (const key in options) {
+      const value = options[key];
+      this[key] = value;
     }
+    this._items = new collection_default([]);
     this._total = total;
-    this._perPage = parseInt(perPage);
+    this._perPage = parseInt(String(perPage));
     this._lastPage = Math.max(Math.ceil(total / perPage), 1);
     this._currentPage = currentPage;
     this.setItems(items);
@@ -1411,7 +1525,7 @@ var Paginator = class {
     return this.count() > 0 ? (this._currentPage - 1) * this._perPage + 1 : null;
   }
   lastItem() {
-    return this.count() > 0 ? this.firstItem() + this.count() - 1 : null;
+    return this.count() > 0 ? (this.firstItem() ?? 0) + this.count() - 1 : null;
   }
   hasMorePages() {
     return this._currentPage < this._lastPage;
@@ -1465,21 +1579,23 @@ var Paginator = class {
 };
 var paginator_default = Paginator;
 
-// src/scope.js
+// src/scope.ts
 var Scope = class _Scope {
   constructor() {
     if (this.constructor === _Scope) {
       throw new Error("Scope cannot be instantiated");
     }
   }
-  apply(builder, model) {
+  apply(_builder, _model) {
     throw new Error("apply not implemented");
   }
 };
 var scope_default = Scope;
 
-// src/builder.js
-var Builder = class _Builder {
+// src/builder.ts
+var Inference = class {
+};
+var Builder = class _Builder extends Inference {
   query;
   connection;
   model;
@@ -1487,13 +1603,15 @@ var Builder = class _Builder {
   localMacros = {};
   eagerLoad = {};
   globalScopes = {};
+  onDeleteCallback;
   constructor(query) {
+    super();
     this.query = query;
     return this.asProxy();
   }
   asProxy() {
     const handler = {
-      get: function(target, prop) {
+      get(target, prop) {
         if (typeof target[prop] !== "undefined") {
           return target[prop];
         }
@@ -1719,7 +1837,7 @@ var Builder = class _Builder {
     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());
+      this.query = this.query.table(this.model.getTable());
     }
     return this;
   }
@@ -1734,16 +1852,15 @@ var Builder = class _Builder {
     if (!this.globalScopes) {
       return this;
     }
-    const builder = this;
-    for (const identifier in builder.globalScopes) {
-      const scope = builder.globalScopes[identifier];
+    for (const identifier in this.globalScopes) {
+      const scope = this.globalScopes[identifier];
       if (scope instanceof scope_default) {
-        scope.apply(builder, builder.getModel());
+        scope.apply(this, this.getModel());
       } else {
-        scope(builder);
+        scope(this);
       }
     }
-    return builder;
+    return this;
   }
   hasNamedScope(name) {
     return this.model && this.model.hasNamedScope(name);
@@ -1780,7 +1897,7 @@ var Builder = class _Builder {
   }
   macro(name, callback) {
     this.localMacros[name] = callback;
-    return;
+    return this;
   }
   hasMacro(name) {
     return name in this.localMacros;
@@ -1791,7 +1908,7 @@ var Builder = class _Builder {
   with(...args) {
     let eagerLoads = {};
     if (typeof args[1] === "function") {
-      let eagerLoad = this.parseWithRelations({
+      const eagerLoad = this.parseWithRelations({
         [args[0]]: args[1]
       });
       this.eagerLoad = (0, import_radashi6.assign)(this.eagerLoad, eagerLoad);
@@ -1872,7 +1989,12 @@ var Builder = class _Builder {
       count = 1;
     }
     const closure = (q) => {
-      relations.length > 1 ? q.whereHas(relations.shift(), closure) : q.has(relations.shift(), operator, count, "and", callback);
+      if (relations.length > 1) {
+        q.whereHas(relations.shift(), closure);
+      } else {
+        q.has(relations.shift(), operator, count, "and", callback);
+      }
+      return null;
     };
     return this.has(relations.shift(), doesntHave ? "<" : ">=", 1, boolean, closure);
   }
@@ -1948,11 +2070,8 @@ var Builder = class _Builder {
     query.applyScopes();
     return query.query.toSQL();
   }
-  mergeConstraintsFrom(from) {
+  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);
@@ -2032,20 +2151,20 @@ var Builder = class _Builder {
     if (prefix !== "") {
       prefix += ".";
     }
-    for (const key2 in relations) {
-      const value = relations[key2];
+    for (const key in relations) {
+      const value = relations[key];
       if ((0, import_radashi6.isString)(value) || Number.isFinite(parseInt(value))) {
         continue;
       }
-      const [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(key2, value);
-      preparedRelationships = (0, import_radashi6.assign)(preparedRelationships, {
+      const [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(key, value);
+      preparedRelationships = Object.assign({}, preparedRelationships, {
         [`${prefix}${attribute}`]: attributeSelectConstraint
       }, this.prepareNestedWithRelationships(value, `${prefix}${attribute}`));
-      relations = (0, import_radashi6.omit)(relations, [key2]);
+      relations = (0, import_radashi6.omit)(relations, [key]);
     }
-    for (const key2 in relations) {
-      const value = relations[key2];
-      let attribute = key2, attributeSelectConstraint = value;
+    for (const key in relations) {
+      const value = relations[key];
+      let attribute = key, attributeSelectConstraint = value;
       if ((0, import_radashi6.isString)(value)) {
         [attribute, attributeSelectConstraint] = this.parseNameAndAttributeSelectionConstraint(value);
       }
@@ -2103,20 +2222,20 @@ var Builder = class _Builder {
   async firstOrFail(...columns) {
     const data = await this.first(...columns);
     if (data === null) {
-      throw new ModelNotFoundError2().setModel(this.model.constructor.name);
+      throw new ModelNotFoundError().setModel(this.model.constructor.name);
     }
     return data;
   }
-  async findOrFail(ids, columns = "*") {
-    const data = await this.find(ids, columns);
-    if ((0, import_radashi6.isArray)(ids)) {
-      if (data.count() !== ids.length) {
-        throw new ModelNotFoundError2().setModel(this.model.constructor.name, (0, import_radashi6.diff)(ids, data.modelKeys()));
+  async findOrFail(...args) {
+    const data = await this.find(...args);
+    if ((0, import_radashi6.isArray)(args[0])) {
+      if (data.count() !== args[0].length) {
+        throw new ModelNotFoundError().setModel(this.model.constructor.name, (0, import_radashi6.diff)(args[0], data.modelKeys()));
       }
       return data;
     }
     if (data === null) {
-      throw new ModelNotFoundError2().setModel(this.model.constructor.name, ids);
+      throw new ModelNotFoundError().setModel(this.model.constructor.name, args[0]);
     }
     return data;
   }
@@ -2152,27 +2271,27 @@ var Builder = class _Builder {
       });
     });
   }
-  latest(column = null) {
+  latest(column = "id") {
     if (column === null) {
       column = this.model.getCreatedAtColumn() || "created_at";
     }
     this.query.orderBy(column, "desc");
     return this;
   }
-  oldest(column = null) {
+  oldest(column = "id") {
     if (column === null) {
       column = this.model.getCreatedAtColumn() || "created_at";
     }
     this.query.orderBy(column, "asc");
     return this;
   }
-  async find(id, columns = "*") {
+  async find(id, columns) {
     if ((0, import_radashi6.isArray)(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 = "*") {
+  async findMany(ids, columns = ["*"]) {
     if (ids instanceof collection_default) {
       ids = ids.modelKeys();
     }
@@ -2193,14 +2312,14 @@ var Builder = class _Builder {
     if (ids instanceof import_collect4.Collection) {
       ids = ids.all();
     }
-    ids = (0, import_radashi6.isArray)(ids) ? ids : Array.prototype.slice.call(arguments);
+    ids = (0, import_radashi6.isArray)(ids) ? ids : Array.prototype.slice.call(ids);
     if (ids.length === 0) {
       return 0;
     }
     const instance = this.model.newInstance();
-    const key2 = instance.getKeyName();
+    const key = instance.getKeyName();
     let count = 0;
-    const models = await this.model.newModelQuery().whereIn(key2, ids).get();
+    const models = await this.model.newModelQuery().whereIn(key, ids).get();
     for (const model of models) {
       if (await model.delete()) {
         count++;
@@ -2208,7 +2327,7 @@ var Builder = class _Builder {
     }
     return count;
   }
-  async get(columns = "*") {
+  async get(columns = ["*"]) {
     this.applyScopes();
     let models = await this.getModels(columns);
     if (models.length > 0) {
@@ -2216,18 +2335,18 @@ var Builder = class _Builder {
     }
     return new collection_default(models);
   }
-  async all(columns = "*") {
+  async all(columns = ["*"]) {
     return await this.model.newModelQuery().get(columns);
   }
-  async paginate(page, perPage) {
+  async paginate(page = 1, perPage = 10) {
     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;
+    let results = [];
     if (total > 0) {
-      const skip = (page - 1) * perPage;
+      const skip = (page - 1) * (perPage ?? 10);
       this.take(perPage).skip(skip);
       results = await this.getModels();
       if (results.length > 0) {
@@ -2299,26 +2418,26 @@ var Builder = class _Builder {
 };
 var builder_default = Builder;
 
-// src/concerns/has-attributes.js
+// src/concerns/has-attributes.ts
 var import_radashi7 = require("radashi");
 
-// src/casts-attributes.js
+// src/casts-attributes.ts
 var CastsAttributes = class _CastsAttributes {
   constructor() {
     if (this.constructor === _CastsAttributes) {
       throw new Error("CastsAttributes cannot be instantiated");
     }
   }
-  static get() {
+  static get(_model, _key, _value, _attributes) {
     throw new Error("get not implemented");
   }
-  static set() {
+  static set(_model, _key, _value, _attributes) {
     throw new Error("set not implemented");
   }
 };
 var casts_attributes_default = CastsAttributes;
 
-// src/concerns/has-attributes.js
+// src/concerns/has-attributes.ts
 var import_collect5 = __toESM(require("collect.js"), 1);
 var import_dayjs2 = __toESM(require("dayjs"), 1);
 var HasAttributes = (Model2) => {
@@ -2338,9 +2457,9 @@ var HasAttributes = (Model2) => {
       this.appends = [...this.appends, ...appends];
       return this;
     }
-    normalizeCastClassResponse(key2, value) {
+    normalizeCastClassResponse(key, value) {
       return value?.constructor?.name === "Object" ? value : {
-        [key2]: value
+        [key]: value
       };
     }
     syncOriginal() {
@@ -2378,20 +2497,20 @@ var HasAttributes = (Model2) => {
     getDirty() {
       const dirty = {};
       const attributes = this.getAttributes();
-      for (const key2 in attributes) {
-        const value = attributes[key2];
-        if (!this.originalIsEquivalent(key2)) {
-          dirty[key2] = value;
+      for (const key in attributes) {
+        const value = attributes[key];
+        if (!this.originalIsEquivalent(key)) {
+          dirty[key] = value;
         }
       }
       return dirty;
     }
-    originalIsEquivalent(key2) {
-      if (this.original[key2] === void 0) {
+    originalIsEquivalent(key) {
+      if (this.original[key] === void 0) {
         return false;
       }
-      const attribute = this.attributes[key2];
-      const original = this.original[key2];
+      const attribute = this.attributes[key];
+      const original = this.original[key];
       if (attribute === original) {
         return true;
       } else {
@@ -2411,28 +2530,28 @@ var HasAttributes = (Model2) => {
     getAttributes() {
       return { ...this.attributes };
     }
-    setAttribute(key2, value) {
-      const setterMethod = getSetterMethod(key2);
+    setAttribute(key, value) {
+      const setterMethod = getSetterMethod(key);
       if (typeof this[setterMethod] === "function") {
         this[setterMethod](value);
         return this;
       }
-      const attrMethod = getAttrMethod(key2);
+      const attrMethod = getAttrMethod(key);
       if (typeof this[attrMethod] === "function") {
         const attribute = this[attrMethod]();
         const callback = attribute.set || ((value2) => {
-          this.attributes[key2] = value2;
+          this.attributes[key] = value2;
         });
         this.attributes = {
           ...this.attributes,
-          ...this.normalizeCastClassResponse(key2, callback(value, this.attributes))
+          ...this.normalizeCastClassResponse(key, 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);
+      const castType = casts[key];
+      if (this.isCustomCast(castType) && typeof castType !== "string") {
+        value = castType.set(this, key, value, this.attributes) ?? "";
       }
       if (castType === "json") {
         value = JSON.stringify(value);
@@ -2440,41 +2559,41 @@ var HasAttributes = (Model2) => {
       if (castType === "collection") {
         value = JSON.stringify(value);
       }
-      if (value !== null && this.isDateAttribute(key2)) {
+      if (value !== null && this.isDateAttribute(key)) {
         value = this.fromDateTime(value);
       }
-      this.attributes[key2] = value;
+      this.attributes[key] = value;
       return this;
     }
-    getAttribute(key2) {
-      if (!key2) {
+    getAttribute(key) {
+      if (!key) {
         return;
       }
-      const getterMethod = getGetterMethod(key2);
+      const getterMethod = getGetterMethod(key);
       if (typeof this[getterMethod] === "function") {
-        return this[getterMethod](this.attributes[key2], this.attributes);
+        return this[getterMethod](this.attributes[key], this.attributes);
       }
-      const attrMethod = getAttrMethod(key2);
+      const attrMethod = getAttrMethod(key);
       if (typeof this[attrMethod] === "function") {
         const caster = this[attrMethod]();
-        return caster.get(this.attributes[key2], this.attributes);
+        return caster.get(this.attributes[key], this.attributes);
       }
-      if (key2 in this.attributes) {
-        if (this.hasCast(key2)) {
-          return this.castAttribute(key2, this.attributes[key2]);
+      if (key in this.attributes) {
+        if (this.hasCast(key)) {
+          return this.castAttribute(key, this.attributes[key]);
         }
-        if (this.getDates().includes(key2)) {
-          return this.asDateTime(this.attributes[key2]);
+        if (this.getDates().includes(key)) {
+          return this.asDateTime(this.attributes[key]);
         }
-        return this.attributes[key2];
+        return this.attributes[key];
       }
-      if (key2 in this.relations) {
-        return this.relations[key2];
+      if (key in this.relations) {
+        return this.relations[key];
       }
       return;
     }
-    castAttribute(key2, value) {
-      const castType = this.getCastType(key2);
+    castAttribute(key, value) {
+      const castType = this.getCastType(key);
       if (!castType) {
         return value;
       }
@@ -2500,13 +2619,13 @@ var HasAttributes = (Model2) => {
         case "json":
           try {
             return JSON.parse(value);
-          } catch (e) {
+          } catch {
             return null;
           }
         case "collection":
           try {
             return (0, import_collect5.default)(JSON.parse(value));
-          } catch (e) {
+          } catch {
             return (0, import_collect5.default)([]);
           }
         case "date":
@@ -2518,60 +2637,60 @@ var HasAttributes = (Model2) => {
           return this.asTimestamp(value);
       }
       if (this.isCustomCast(castType)) {
-        return castType.get(this, key2, value, this.attributes);
+        return castType.get(this, key, value, this.attributes);
       }
       return value;
     }
     attributesToData() {
       let attributes = { ...this.attributes };
-      for (const key2 in attributes) {
-        if (this.hidden.includes(key2)) {
-          attributes = (0, import_radashi7.omit)(attributes, [key2]);
+      for (const key in attributes) {
+        if (this.hidden.includes(key)) {
+          attributes = (0, import_radashi7.omit)(attributes, [key]);
         }
-        if (this.visible.length > 0 && this.visible.includes(key2) === false) {
-          attributes = (0, import_radashi7.omit)(attributes, [key2]);
+        if (this.visible.length > 0 && this.visible.includes(key) === false) {
+          attributes = (0, import_radashi7.omit)(attributes, [key]);
         }
       }
-      for (const key2 of this.getDates()) {
-        if (attributes[key2] === void 0) {
+      for (const key of this.getDates()) {
+        if (attributes[key] === void 0) {
           continue;
         }
-        attributes[key2] = this.serializeDate(this.asDateTime(attributes[key2]));
+        attributes[key] = this.serializeDate(this.asDateTime(attributes[key]));
       }
       const casts = this.getCasts();
-      for (const key2 in casts) {
-        const value = casts[key2];
-        if (key2 in attributes === false) {
+      for (const key in casts) {
+        const value = casts[key];
+        if (key 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]);
+        attributes[key] = this.castAttribute(key, attributes[key]);
+        if (key in attributes && ["date", "datetime"].includes(String(value))) {
+          attributes[key] = this.serializeDate(attributes[key]);
         }
-        if (key2 in attributes && this.isCustomDateTimeCast(value)) {
-          attributes[key2] = (0, import_dayjs2.default)(attributes[key2]).format(value.split(":")[1]);
+        if (key in attributes && this.isCustomDateTimeCast(value)) {
+          attributes[key] = (0, import_dayjs2.default)(attributes[key]).format(String(value).split(":")[1]);
         }
       }
-      for (const key2 of this.appends) {
-        attributes[key2] = this.mutateAttribute(key2, null);
+      for (const key of this.appends) {
+        attributes[key] = this.mutateAttribute(key, 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];
+    mutateAttribute(key, value) {
+      if (typeof this[getGetterMethod(key)] === "function") {
+        return this[getGetterMethod(key)](value);
+      } else if (typeof this[getAttrMethod(key)] === "function") {
+        const caster = this[getAttrMethod(key)]();
+        return caster.get(key, this.attributes);
+      } else if (key in this) {
+        return this[key];
       }
       return value;
     }
-    mutateAttributeForArray(key2, value) {
+    mutateAttributeForArray(_key, _value) {
     }
-    isDateAttribute(key2) {
-      return this.getDates().includes(key2) || this.isDateCastable(key2);
+    isDateAttribute(key) {
+      return this.getDates().includes(key) || this.isDateCastable(key);
     }
     serializeDate(date) {
       return date ? (0, import_dayjs2.default)(date).toISOString() : null;
@@ -2591,16 +2710,16 @@ var HasAttributes = (Model2) => {
       }
       return this.casts;
     }
-    getCastType(key2) {
-      const castType = this.getCasts()[key2];
+    getCastType(key) {
+      const castType = this.getCasts()[key];
       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];
+      if (castTypeCacheKey && this.getConstructor().castTypeCache[castTypeCacheKey] !== void 0) {
+        return this.getConstructor().castTypeCache[castTypeCacheKey];
       }
       let convertedCastType;
       if (this.isCustomDateTimeCast(castType)) {
@@ -2610,14 +2729,14 @@ var HasAttributes = (Model2) => {
       } else if (this.isCustomCast(castType)) {
         convertedCastType = castType;
       } else {
-        convertedCastType = castType.toLocaleLowerCase().trim();
+        convertedCastType = String(castType).toLocaleLowerCase().trim();
       }
-      return this.constructor.castTypeCache[castTypeCacheKey] = convertedCastType;
+      return this.getConstructor()[castTypeCacheKey] = convertedCastType;
     }
-    hasCast(key2, types = []) {
-      if (key2 in this.casts) {
+    hasCast(key, types = []) {
+      if (key in this.casts) {
         types = (0, import_radashi7.flat)(types);
-        return types.length > 0 ? types.includes(this.getCastType(key2)) : true;
+        return types.length > 0 ? types.includes(this.getCastType(key)) : true;
       }
       return false;
     }
@@ -2639,8 +2758,8 @@ var HasAttributes = (Model2) => {
       }
       return cast.startsWith("decimal:");
     }
-    isDateCastable(key2) {
-      return this.hasCast(key2, ["date", "datetime"]);
+    isDateCastable(key) {
+      return this.hasCast(key, ["date", "datetime"]);
     }
     fromDateTime(value) {
       return (0, import_dayjs2.default)(this.asDateTime(value)).format(this.getDateFormat());
@@ -2671,16 +2790,17 @@ var HasAttributes = (Model2) => {
 };
 var has_attributes_default = HasAttributes;
 
-// src/concerns/has-global-scopes.js
+// src/concerns/has-global-scopes.ts
 var import_radashi8 = require("radashi");
 var HasGlobalScopes = (Model2) => {
   return class extends Model2 {
+    static globalScopes;
     static addGlobalScope(scope, implementation = null) {
       if (typeof scope === "string" && implementation instanceof scope_default) {
-        this.globalScopes = (0, import_radashi8.set)(this.globalScopes, this.name + "." + scope, implementation);
+        this.globalScopes = (0, import_radashi8.set)(this.globalScopes ?? {}, this.name + "." + scope, implementation);
         return implementation;
       } else if (scope instanceof scope_default) {
-        this.globalScopes = (0, import_radashi8.set)(this.globalScopes, this.name + "." + scope.constructor.name, scope);
+        this.globalScopes = (0, import_radashi8.set)(this.globalScopes ?? {}, this.name + "." + scope.constructor.name, scope);
         return scope;
       }
       throw new InvalidArgumentError("Global scope must be an instance of Scope.");
@@ -2707,7 +2827,7 @@ var HasGlobalScopes = (Model2) => {
 };
 var has_global_scopes_default = HasGlobalScopes;
 
-// src/hooks.js
+// src/hooks.ts
 var Hooks = class {
   hooks = {
     creating: [],
@@ -2725,16 +2845,11 @@ var Hooks = class {
     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]) {
+    const callbacks = this.hooks[hook] ?? [];
+    for (const callback of callbacks) {
       await callback(...data);
     }
     return true;
@@ -2742,7 +2857,7 @@ var Hooks = class {
 };
 var hooks_default = Hooks;
 
-// src/concerns/has-hooks.js
+// src/concerns/has-hooks.ts
 var HasHooks = (Model2) => {
   return class extends Model2 {
     static hooks = null;
@@ -2798,20 +2913,20 @@ var HasHooks = (Model2) => {
 };
 var has_hooks_default = HasHooks;
 
-// src/relations/has-one-or-many.js
+// src/relations/has-one-or-many.ts
 var import_collect6 = __toESM(require("collect.js"), 1);
 var HasOneOrMany = (Relation2) => {
   return class extends Relation2 {
-    getRelationValue(dictionary, key2, type) {
-      const value = dictionary[key2];
+    getRelationValue(dictionary, key, type) {
+      const value = dictionary[key];
       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));
+        const key = model.attributes[this.localKey];
+        if (dictionary[key] !== void 0) {
+          model.setRelation(relation, this.getRelationValue(dictionary, key, type));
         }
       });
       return models;
@@ -2872,7 +2987,7 @@ var HasOneOrMany = (Relation2) => {
 };
 var has_one_or_many_default = HasOneOrMany;
 
-// src/relations/has-many.js
+// src/relations/has-many.ts
 var import_collect7 = require("collect.js");
 var HasMany = class extends compose(relation_default, has_one_or_many_default) {
   foreignKey;
@@ -2894,8 +3009,8 @@ var HasMany = class extends compose(relation_default, has_one_or_many_default) {
     return this.getParentKey() !== null ? await this.query.get() : new collection_default([]);
   }
   getForeignKeyName() {
-    const segments = this.foreignKey.split(".");
-    return segments.pop();
+    const segments = this.foreignKey?.split(".");
+    return segments?.pop();
   }
   buildDictionary(results) {
     const foreign = this.getForeignKeyName();
@@ -2913,8 +3028,12 @@ var HasMany = class extends compose(relation_default, has_one_or_many_default) {
 };
 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) {
+// src/relations/has-one.ts
+var HasOne = class extends compose(
+  relation_default,
+  has_one_or_many_default,
+  supports_default_models_default
+) {
   foreignKey;
   localKey;
   constructor(query, parent, foreignKey, localKey) {
@@ -2934,8 +3053,8 @@ var HasOne = class extends compose(relation_default, has_one_or_many_default, su
     return this.matchOneOrMany(models, results, relation, "one");
   }
   getForeignKeyName() {
-    const segments = this.foreignKey.split(".");
-    return segments.pop();
+    const segments = this.foreignKey?.split(".");
+    return segments?.pop();
   }
   async getResults() {
     if (this.getParentKey() === null) {
@@ -2956,7 +3075,7 @@ var HasOne = class extends compose(relation_default, has_one_or_many_default, su
 };
 var has_one_default = HasOne;
 
-// src/relations/has-many-through.js
+// src/relations/has-many-through.ts
 var import_radashi9 = require("radashi");
 var HasManyThrough = class extends relation_default {
   throughParent;
@@ -3015,7 +3134,8 @@ var HasManyThrough = class extends relation_default {
   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) {
+      const key = this.getDictionaryKey(model.getAttribute(this.localKey));
+      if (dictionary[key] !== void 0) {
         model.setRelation(relation, this.related.newCollection(dictionary[key]));
       }
     }
@@ -3032,7 +3152,7 @@ var HasManyThrough = class extends relation_default {
     return dictionary;
   }
   async firstOrNew(attributes) {
-    let instance = await this.where(attributes).first();
+    const instance = await this.where(attributes).first();
     return instance || this.related.newInstance(attributes);
   }
   async updateOrCreate(attributes, values = {}) {
@@ -3054,7 +3174,7 @@ var HasManyThrough = class extends relation_default {
     if (model) {
       return model;
     }
-    throw new ModelNotFoundError2().setModel(this.related.constructor);
+    throw new ModelNotFoundError().setModel(this.related.constructor);
   }
   async firstOr(columns = ["*"], callback = null) {
     if (typeof columns === "function") {
@@ -3065,7 +3185,7 @@ var HasManyThrough = class extends relation_default {
     if (model) {
       return model;
     }
-    return callback();
+    return callback?.();
   }
   async find(id, columns = ["*"]) {
     if ((0, import_radashi9.isArray)(id)) {
@@ -3081,14 +3201,14 @@ var HasManyThrough = class extends relation_default {
   }
   async findOrFail(id, columns = ["*"]) {
     const result = await this.find(id, columns);
-    if ((0, import_radashi9.isArray)(id)) {
+    if (Array.isArray(id)) {
       if (result.count() === id.length) {
         return result;
       }
     } else if (result) {
       return result;
     }
-    throw new ModelNotFoundError2().setModel(this.related.constructor, id);
+    throw new ModelNotFoundError().setModel(this.related.constructor, id);
   }
   async getResults() {
     return this.farParent[this.localKey] ? await this.get() : this.related.newCollection();
@@ -3106,7 +3226,7 @@ var HasManyThrough = class extends relation_default {
     return await this.query.paginate(perPage, columns, pageName, page);
   }
   shouldSelect(columns = ["*"]) {
-    if (columns == ["*"]) {
+    if (columns?.at(0) == "*") {
       columns = [this.related.getTable() + ".*"];
     }
     return [...columns, this.getQualifiedFirstKeyName() + " as laravel_through_key"];
@@ -3174,8 +3294,11 @@ var HasManyThrough = class extends relation_default {
 };
 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) {
+// src/relations/has-one-through.ts
+var HasOneThrough = class extends compose(
+  has_many_through_default,
+  supports_default_models_default
+) {
   async getResults() {
     return await this.first() || this.getDefaultFor(this.farParent);
   }
@@ -3188,21 +3311,21 @@ var HasOneThrough = class extends compose(has_many_through_default, supports_def
   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];
+      const key = this.getDictionaryKey(model.getAttribute(this.localKey));
+      if (dictionary[key] !== void 0) {
+        const value = dictionary[key];
         model.setRelation(relation, value[0]);
       }
     }
     return models;
   }
-  newRelatedInstanceFor(parent) {
+  newRelatedInstanceFor(_parent) {
     return this.related.newInstance();
   }
 };
 var has_one_through_default = HasOneThrough;
 
-// src/concerns/has-relations.js
+// src/concerns/has-relations.ts
 var import_radashi10 = require("radashi");
 var HasRelations = (Model2) => {
   return class extends Model2 {
@@ -3233,21 +3356,21 @@ var HasRelations = (Model2) => {
     }
     relationsToData() {
       const data = {};
-      for (const key2 in this.relations) {
-        if (this.hidden.includes(key2)) {
+      for (const key in this.relations) {
+        if (this.hidden.includes(key)) {
           continue;
         }
-        if (this.visible.length > 0 && this.visible.includes(key2) === false) {
+        if (this.visible.length > 0 && this.visible.includes(key) === 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();
+        data[key] = this.relations[key] instanceof Array ? this.relations[key].map((item) => item.toData()) : this.relations[key] === null ? null : this.relations[key].toData();
       }
       return data;
     }
     guessBelongsToRelation() {
-      let e = new Error();
-      let frame = e.stack.split("\n")[2];
-      let functionName = frame.split(" ")[5];
+      const e = new Error();
+      const frame = e.stack.split("\n")[2];
+      const functionName = frame.split(" ")[5];
       return getRelationName(functionName);
     }
     joiningTable(related, instance = null) {
@@ -3310,7 +3433,7 @@ var HasRelations = (Model2) => {
 };
 var has_relations_default = HasRelations;
 
-// src/concerns/has-timestamps.js
+// src/concerns/has-timestamps.ts
 var HasTimestamps = (Model2) => {
   return class extends Model2 {
     static CREATED_AT = "created_at";
@@ -3359,7 +3482,7 @@ var HasTimestamps = (Model2) => {
 };
 var has_timestamps_default = HasTimestamps;
 
-// src/concerns/hides-attributes.js
+// src/concerns/hides-attributes.ts
 var import_radashi11 = require("radashi");
 var HidesAttributes = (Model2) => {
   return class extends Model2 {
@@ -3373,8 +3496,8 @@ var HidesAttributes = (Model2) => {
       this.hidden = (0, import_radashi11.diff)(this.hidden, visible);
       return this;
     }
-    makeHidden(...keys) {
-      const hidden = flattenDeep(keys);
+    makeHidden(key, ...keys) {
+      const hidden = flattenDeep([...key, ...keys]);
       if (this.hidden.length > 0) {
         this.hidden = [...this.hidden, ...hidden];
       }
@@ -3398,7 +3521,7 @@ var HidesAttributes = (Model2) => {
 };
 var hides_attributes_default = HidesAttributes;
 
-// src/concerns/unique-ids.js
+// src/concerns/unique-ids.ts
 var UniqueIds = (Model2) => {
   return class extends Model2 {
     useUniqueIds = false;
@@ -3423,37 +3546,47 @@ var UniqueIds = (Model2) => {
 };
 var unique_ids_default = UniqueIds;
 
-// src/model.js
+// src/model.ts
 var import_collect8 = __toESM(require("collect.js"), 1);
 var import_radashi12 = require("radashi");
 var import_pluralize = __toESM(require("pluralize"), 1);
-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 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;
+  perPage = 15;
   static globalScopes = {};
   static pluginInitializers = {};
   static _booted = {};
-  static resolver = null;
+  static resolver;
+  connection = null;
+  eagerLoad = {};
+  exists = false;
+  with = [];
+  trx = null;
+  constructor(attributes = {}) {
+    super();
+    this.bootIfNotBooted();
+    this.initializePlugins();
+    this.syncOriginal();
+    this.fill(attributes);
+    return this.asProxy();
+  }
   static query(trx = null) {
     const instance = new this();
     return instance.newQuery(trx);
@@ -3471,7 +3604,7 @@ var Model = class _Model extends BaseModel {
   }
   static make(attributes = {}) {
     const instance = new this();
-    for (let attribute in attributes) {
+    for (const attribute in attributes) {
       if (typeof instance[getRelationMethod(attribute)] !== "function") {
         instance.setAttribute(attribute, attributes[attribute]);
       } else {
@@ -3486,13 +3619,8 @@ var Model = class _Model extends BaseModel {
     }
     return instance;
   }
-  constructor(attributes = {}) {
-    super();
-    this.bootIfNotBooted();
-    this.initializePlugins();
-    this.syncOriginal();
-    this.fill(attributes);
-    return this.asProxy();
+  getConstructor() {
+    return this.constructor;
   }
   bootIfNotBooted() {
     if (this.constructor._booted[this.constructor.name] === void 0) {
@@ -3632,6 +3760,7 @@ var Model = class _Model extends BaseModel {
     return this;
   }
   async loadAggregate(relations, column, callback = null) {
+    console.log(relations);
     await new collection_default([this]).loadAggregate(relations, column, callback);
     return this;
   }
@@ -3660,8 +3789,8 @@ var Model = class _Model extends BaseModel {
       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];
+    for (const key in extra) {
+      this.attributes[key] = extra[key];
     }
     await this.execHooks("updating", options);
     return await tap(await query.where(this.getKeyName(), this.getKey())[method](column, amount, extra), async () => {
@@ -3683,8 +3812,8 @@ var Model = class _Model extends BaseModel {
     return this.toJson();
   }
   fill(attributes) {
-    for (const key2 in attributes) {
-      this.setAttribute(key2, attributes[key2]);
+    for (const key in attributes) {
+      this.setAttribute(key, attributes[key]);
     }
     return this;
   }
@@ -3754,8 +3883,8 @@ var Model = class _Model extends BaseModel {
     if (!this.exists) {
       return false;
     }
-    for (let key2 in attributes) {
-      this[key2] = attributes[key2];
+    for (const key in attributes) {
+      this[key] = attributes[key];
     }
     return await this.save(options);
   }
@@ -3784,7 +3913,7 @@ var Model = class _Model extends BaseModel {
   }
   async refresh() {
     if (!this.exists) {
-      return;
+      return Promise.resolve(void 0);
     }
     const model = await this.constructor.query().where(this.getKeyName(), this.getKey()).first();
     this.attributes = { ...model.attributes };
@@ -3862,10 +3991,15 @@ var Pivot = class extends Model {
 };
 var model_default = Model;
 
-// src/query-builder.js
-var QueryBuilder = class _QueryBuilder {
-  connector = null;
+// src/query-builder.ts
+var Inference2 = class {
+};
+var QueryBuilder = class _QueryBuilder extends Inference2 {
+  model;
+  schema;
+  connector;
   constructor(config, connector) {
+    super();
     this.connector = connector(config);
     return this.asProxy();
   }
@@ -3961,8 +4095,7 @@ var QueryBuilder = class _QueryBuilder {
     return new Proxy(this, handler);
   }
   async beginTransaction() {
-    const trx = await this.connector.transaction();
-    return new _QueryBuilder(null, () => trx);
+    return await this.connector.transaction();
   }
   table(table) {
     const c = this.connector.table(table);
@@ -3979,7 +4112,7 @@ var QueryBuilder = class _QueryBuilder {
   async find(id, columns = ["*"]) {
     return await this.connector.where("id", id).first(...columns);
   }
-  async get(columns = ["*"]) {
+  async get(_columns = ["*"]) {
     return await this.connector;
   }
   async exists() {
@@ -4079,15 +4212,21 @@ var QueryBuilder = class _QueryBuilder {
 };
 var query_builder_default = QueryBuilder;
 
-// src/arquebus.js
+// src/arquebus.ts
 var arquebus = class _arquebus {
   static connectorFactory = null;
   static instance = null;
+  manager;
+  connections;
+  models;
   constructor() {
     this.manager = {};
     this.connections = {};
     this.models = {};
   }
+  getConstructor() {
+    return this.constructor;
+  }
   static getInstance() {
     if (this.instance === null) {
       this.instance = new _arquebus();
@@ -4101,7 +4240,7 @@ var arquebus = class _arquebus {
     this.connectorFactory = connectorFactory;
   }
   static getConnectorFactory() {
-    return this.connectorFactory || import_knex.default;
+    return this.connectorFactory ?? import_knex.default;
   }
   static addConnection(config, name = "default") {
     return this.getInstance().addConnection(config, name);
@@ -4130,7 +4269,7 @@ var arquebus = class _arquebus {
   getConnection(name = null) {
     name = name || "default";
     if (this.manager[name] === void 0) {
-      const queryBuilder = new query_builder_default(this.connections[name], this.constructor.getConnectorFactory());
+      const queryBuilder = new query_builder_default(this.connections[name], _arquebus.getConnectorFactory());
       this.manager[name] = queryBuilder;
     }
     return this.manager[name];
@@ -4151,7 +4290,7 @@ var arquebus = class _arquebus {
     };
   }
   beginTransaction(connection = null) {
-    return this.connection(connection).transaction();
+    return this.connection(connection).beginTransaction();
   }
   transaction(callback, connection = null) {
     return this.connection(connection).transaction(callback);
@@ -4170,7 +4309,7 @@ var arquebus = class _arquebus {
   createModel(name, options = {}) {
     let BaseModel2 = Model;
     if ("plugins" in options) {
-      BaseModel2 = compose(BaseModel2, ...options.plugins);
+      BaseModel2 = compose(BaseModel2, ...options.plugins ?? []);
     }
     this.models = {
       ...this.models,
@@ -4193,13 +4332,13 @@ var arquebus = class _arquebus {
         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];
+        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);
+          return options.relations?.[relation](this);
         };
       }
     }
@@ -4214,371 +4353,590 @@ var arquebus = class _arquebus {
 };
 var arquebus_default = arquebus;
 
-// bin/utils.js
-var color2 = __toESM(require("colorette"), 1);
-var import_sync = __toESM(require("escalade/sync"), 1);
-var import_path2 = __toESM(require("path"), 1);
-var import_resolve_from = __toESM(require("resolve-from"), 1);
-var join = import_path2.default.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;
+// src/migrate.ts
+var Migrate = class {
+  constructor(basePath, customStubPath, callback) {
+    this.basePath = basePath;
+    this.customStubPath = customStubPath;
+    this.callback = callback ?? ((_ = "") => {
     });
   }
-  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()];
+  callback;
+  /**
+   * Runs all pending migrations
+   * 
+   * @param config 
+   * @param options 
+   * @param destroyAll 
+   */
+  async run(config, options = {}, destroyAll = false) {
+    const { arquebus: arquebus2, migrator } = await this.setupConnection(config);
+    await this.prepareDatabase(migrator);
+    const paths = await Utils.getMigrationPaths(
+      this.basePath ?? 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();
+    }
+  }
+  /**
+   * Rollback the last migration
+   * 
+   * @param config 
+   * @param options 
+   * @param destroyAll 
+   */
+  async rollback(config, options = {}, destroyAll = false) {
+    const { arquebus: arquebus2, migrator } = await this.setupConnection(config);
+    const paths = await Utils.getMigrationPaths(
+      this.basePath ?? 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();
+    }
+  }
+  /**
+   * Prepares the database for migration
+   * 
+   * @param migrator 
+   */
+  async prepareDatabase(migrator) {
+    const exists = await migrator.repositoryExists();
+    if (!exists) {
+      this.callback("INFO: Preparing database.", "info");
+      this.callback("INFO: Creating migration table...", "info");
+      await migrator.repository.createRepository();
+      this.callback("SUCCESS: Migration table created successfully.", "success");
+    }
+  }
+  /**
+   * Check the status of available migrations
+   * 
+   * @param config 
+   * @param options 
+   * @param destroyAll 
+   * @returns 
+   */
+  async status(config, options = {}, destroyAll = false) {
+    const { arquebus: arquebus2, migrator } = await this.setupConnection(config);
+    const getAllMigrationFiles = async () => {
+      return await migrator.getMigrationFiles(
+        await Utils.getMigrationPaths(
+          this.basePath ?? process.cwd(),
+          migrator,
+          config.migrations.path,
+          options.path
+        )
+      );
+    };
+    async function getStatusFor(ran2, batches2) {
+      const files = await getAllMigrationFiles();
+      return Object.values(files).map((migration) => {
+        const migrationName = migrator.getMigrationName(migration);
+        return {
+          name: migrationName,
+          ran: ran2.includes(migrationName),
+          batch: ran2.includes(migrationName) ? batches2[migrationName] : null
+        };
+      });
     }
-    getKeyType() {
-      if (this.uniqueIds().includes(this.getKeyName())) {
-        return "string";
-      }
-      return this.keyType;
+    const exists = await migrator.repositoryExists();
+    if (!exists) {
+      this.callback("ERROR: Migration table does not exist.", "error");
     }
-    getIncrementing() {
-      if (this.uniqueIds().includes(this.getKeyName())) {
-        return false;
-      }
-      return this.incrementing;
+    const ran = await migrator.repository.getRan();
+    const batches = await migrator.getRepository().getMigrationBatches();
+    const migrations = await getStatusFor(ran, batches);
+    if (destroyAll) {
+      await arquebus2.destroyAll();
     }
-  };
-};
-var has_unique_ids_default = HasUniqueIds;
-
-// src/migrations/migration.js
-var Migration = class {
-  connection;
-  withinTransaction = true;
-  getConnection() {
-    return this.connection;
+    return migrations;
+  }
+  /**
+   * Setup the database connection
+   * 
+   * @param config 
+   * @returns 
+   */
+  async setupConnection(config) {
+    const table = config?.migrations?.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 };
   }
 };
-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;
+// src/migrations/migration-creator.ts
+var import_node_fs = require("fs");
+var import_dayjs3 = __toESM(require("dayjs"), 1);
+var import_node_path = require("path");
+var import_node_url = require("url");
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var import_meta = {};
+var MigrationCreator = class {
+  constructor(customStubPath, type = "js") {
+    this.customStubPath = customStubPath;
+    this.type = type;
+  }
+  postCreate = [];
+  /**
+   * Create a new migration file
+   * 
+   * @param name 
+   * @param dir 
+   * @param table 
+   * @param create 
+   * @returns 
+   */
+  async create(name, dir, table, create = false) {
+    const stub = this.getStub(table, create);
+    const filePath = this.getPath(name, dir);
+    await this.ensureDirectoryExists(import_path3.default.dirname(filePath));
+    await import_promises3.default.writeFile(filePath, this.populateStub(stub, table));
+    await this.firePostCreateHooks(table, filePath);
+    return filePath;
+  }
+  /**
+   * Publish migrations from third party vendors
+   * 
+   * @param dir 
+   * @param callback 
+   */
+  async publish(dir, callback) {
+    const migrationFiles = await import_promises3.default.readdir(this.customStubPath ?? "");
+    await this.ensureDirectoryExists(dir);
+    for (const migrationFile of migrationFiles) {
+      const sourceFilePath = import_path3.default.join(this.customStubPath ?? "", migrationFile);
+      const destinationFilePath = import_path3.default.join(dir, migrationFile);
+      await import_promises3.default.copyFile(sourceFilePath, destinationFilePath);
+      if (callback) callback(migrationFile, sourceFilePath, destinationFilePath);
+    }
+  }
+  getStub(table, create = false) {
+    let stub;
+    if (!table) {
+      const customPath = import_path3.default.join(this.customStubPath ?? "", `migration-${this.type}.stub`);
+      console.log("\n", customPath, "---");
+      stub = (0, import_node_fs.existsSync)(customPath) ? customPath : this.stubPath(`/migration-${this.type}.stub`);
+    } else if (create) {
+      const customPath = import_path3.default.join(this.customStubPath ?? "", `migration.create-${this.type}.stub`);
+      stub = (0, import_node_fs.existsSync)(customPath) ? customPath : this.stubPath(`/migration.create-${this.type}.stub`);
+    } else {
+      const customPath = import_path3.default.join(this.customStubPath ?? "", `migration.update-${this.type}.stub`);
+      stub = (0, import_node_fs.existsSync)(customPath) ? customPath : this.stubPath(`/migration.update-${this.type}.stub`);
     }
+    return (0, import_node_fs.readFileSync)(stub, "utf-8");
   }
-  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();
+  populateStub(stub, table) {
+    if (table !== null) {
+      stub = stub.replace(/DummyTable|{{\s*table\s*}}/g, table);
     }
-    return builder.getModel().getDeletedAtColumn();
+    return stub;
   }
-  addRestore(builder) {
-    builder.macro("restore", (builder2) => {
-      builder2.withTrashed();
-      return builder2.update({
-        [builder2.getModel().getDeletedAtColumn()]: null
-      });
-    });
+  getClassName(name) {
+    return name.replace(/_+([a-z])/g, (match, char) => char.toUpperCase());
   }
-  addRestoreOrCreate(builder) {
-    builder.macro("restoreOrCreate", async (builder2, attributes = {}, values = {}) => {
-      builder2.withTrashed();
-      return tap(await builder2.firstOrCreate(attributes, values), async (instance) => {
-        await instance.restore();
-      });
-    });
+  getPath(name, dir) {
+    const datePrefix = (0, import_dayjs3.default)().format("YYYY_MM_DD_HHmmss");
+    return import_path3.default.join(dir, `${datePrefix}_${name}.${this.type}`);
   }
-  addCreateOrRestore(builder) {
-    builder.macro("createOrRestore", async (builder2, attributes = {}, values = {}) => {
-      builder2.withTrashed();
-      return tap(await builder2.createOrFirst(attributes, values), async (instance) => {
-        await instance.restore();
-      });
-    });
+  async firePostCreateHooks(table, filePath) {
+    for (const callback of this.postCreate) {
+      await callback(table, filePath);
+    }
   }
-  addWithTrashed(builder) {
-    builder.macro("withTrashed", (builder2, withTrashed = true) => {
-      if (!withTrashed) {
-        return builder2.withoutTrashed();
-      }
-      return builder2.withoutGlobalScope(this);
-    });
+  afterCreate(callback) {
+    this.postCreate.push(callback);
   }
-  addWithoutTrashed(builder) {
-    builder.macro("withoutTrashed", (builder2) => {
-      const model = builder2.getModel();
-      builder2.withoutGlobalScope(this).whereNull(model.getQualifiedDeletedAtColumn());
-      return builder2;
-    });
+  async ensureDirectoryExists(dir) {
+    await import_promises3.default.mkdir(dir, { recursive: true });
   }
-  addOnlyTrashed(builder) {
-    builder.macro("onlyTrashed", (builder2) => {
-      const model = builder2.getModel();
-      builder2.withoutGlobalScope(this).whereNotNull(model.getQualifiedDeletedAtColumn());
-      return builder2;
-    });
+  stubPath(stub = "") {
+    const __dirname2 = this.getDirname(import_meta);
+    return import_path3.default.join(__dirname2, "stubs", stub);
+  }
+  getDirname(meta) {
+    if (typeof __dirname !== "undefined") {
+      return __dirname;
+    }
+    if (meta && meta.url) {
+      return (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(meta.url));
+    }
+    throw new Error("Unable to determine dirname");
   }
 };
-var soft_deleting_scope_default = SoftDeletingScope;
+var migration_creator_default = MigrationCreator;
+
+// src/cli/cli.ts
+var import_chalk3 = __toESM(require("chalk"), 1);
 
-// src/soft-deletes.js
+// package.json
+var package_default = {
+  name: "@h3ravel/arquebus",
+  version: "0.1.6",
+  packageManager: "pnpm@10.14.0",
+  description: "Arquebus ORM is a Beautiful, expressive ORM inspired by Laravel's Eloquent, designed for TypeScript applications and for the H3ravel Framework.",
+  homepage: "https://h3ravel.net/arquebus",
+  bin: {
+    arquebus: "./bin/cli.js"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  type: "module",
+  types: "./dist/index.d.ts",
+  files: [
+    "dist",
+    "bin",
+    "src/stubs",
+    "src/migrations/stubs"
+  ],
+  exports: {
+    ".": {
+      worker: {
+        import: {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        require: {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.cjs"
+        }
+      },
+      node: {
+        import: {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        require: {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.cjs"
+        }
+      },
+      browser: {
+        import: {
+          types: "./dist/browser/index.d.ts",
+          default: "./dist/browser/index.js"
+        },
+        require: {
+          types: "./dist/browser/index.d.ts",
+          default: "./dist/browser/index.cjs"
+        }
+      },
+      default: {
+        import: {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        require: {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.cjs"
+        }
+      }
+    },
+    "./browser": {
+      import: {
+        types: "./dist/browser/index.d.ts",
+        default: "./dist/browser/index.js"
+      },
+      require: {
+        types: "./dist/browser/index.d.ts",
+        default: "./dist/browser/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/h3ravel/arquebus.git"
+  },
+  engines: {
+    node: ">=14",
+    pnpm: ">=4"
+  },
+  scripts: {
+    build: "tsup",
+    lint: "eslint . --ext .ts",
+    cmd: "cross-env TEST=true tsx --experimental-specifier-resolution=node src/cli",
+    "cmd:watch": "cross-env TEST=true tsx watch --experimental-specifier-resolution=node src/cli",
+    "test:mysql": "cross-env DB=mysql vitest --project node",
+    "test:postgres": "cross-env DB=postgres vitest --project node",
+    "test:sqlite": "cross-env DB=sqlite vitest --project node",
+    "test:browser": "vitest --project browser"
+  },
+  husky: {
+    hooks: {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{js,json}": [
+      "prettier --write",
+      "git add"
+    ]
+  },
+  dependencies: {
+    chalk: "^5.6.0",
+    "collect.js": "^4.36.1",
+    commander: "^11.1.0",
+    dayjs: "^1.11.13",
+    dotenv: "^17.2.1",
+    escalade: "^3.2.0",
+    knex: "^3.1.0",
+    pluralize: "^8.0.0",
+    radashi: "^12.6.2",
+    "resolve-from": "^5.0.0"
+  },
+  devDependencies: {
+    "@eslint/js": "^9.33.0",
+    "@types/node": "^24.3.0",
+    "@types/pluralize": "^0.0.33",
+    "@typescript-eslint/eslint-plugin": "^8.40.0",
+    "@typescript-eslint/parser": "^8.40.0",
+    "cross-env": "^7.0.3",
+    eslint: "^9.33.0",
+    husky: "^8.0.3",
+    jsdom: "^26.1.0",
+    "lint-staged": "^13.3.0",
+    mysql2: "3.12.0",
+    pg: "8.8.0",
+    prettier: "2.6.2",
+    sqlite3: "5.1.7",
+    tedious: "15.1.0",
+    "ts-node": "^10.9.2",
+    tsup: "^8.5.0",
+    tsx: "^4.20.4",
+    typescript: "^5.9.2",
+    "typescript-eslint": "^8.40.0",
+    "vite-tsconfig-paths": "^5.1.4",
+    vitest: "^3.2.4"
+  },
+  keywords: [
+    "arquebus",
+    "ORM",
+    "mysql",
+    "mariadb",
+    "sqlite",
+    "postgresql",
+    "postgres",
+    "pg",
+    "mssql",
+    "active record"
+  ],
+  readmeFilename: "README.md",
+  license: "MIT"
+};
+
+// src/cli/cli.ts
+var import_dotenv = require("dotenv");
+var import_path4 = __toESM(require("path"), 1);
 var import_radashi13 = require("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");
+var Cli = class _Cli {
+  cwd;
+  output = Utils.output();
+  config = {};
+  basePath = "";
+  modulePath;
+  configPath;
+  modulePackage;
+  constructor(basePath) {
+    this.basePath = basePath ?? (process.env.TEST === "true" ? "test/cli" : "");
+  }
+  terminateNotFound() {
+    this.output.error(
+      `ERROR: Arquebus config not found. Run ${import_chalk3.default.italic.black.bgGray("arquebus init")} first.`
+    );
+  }
+  static init() {
+    (0, import_dotenv.config)({ quiet: true });
+    const instance = new _Cli();
+    Promise.all([instance.loadPaths(), instance.loadConfig()]).then(([_, e]) => e.run());
+  }
+  async loadPaths() {
+    this.cwd = import_path4.default.join(process.cwd(), this.basePath);
+    this.configPath = Utils.findUpConfig(this.cwd, "arquebus.config", ["js", "ts", "cjs"]) ?? void 0;
+    this.modulePath = Utils.findModulePkg("@h3ravel/arquebus", this.cwd) ?? "";
+    try {
+      this.modulePackage = await import(import_path4.default.join(this.modulePath, "package.json"));
+    } catch {
+      this.modulePackage = { version: "N/A" };
     }
-    initializeSoftDeletes() {
-      if (this.casts[this.getDeletedAtColumn()] === void 0) {
-        this.casts[this.getDeletedAtColumn()] = "datetime";
-      }
+    return this;
+  }
+  async loadConfig() {
+    try {
+      this.config = (await import(this.configPath ?? "----")).default;
+    } catch {
+      this.config = {};
     }
-    async forceDelete() {
-      if (this.execHooks("forceDeleting") === false) {
-        return false;
+    return this;
+  }
+  async run() {
+    const cliVersion = [
+      "Arquebus CLI version:",
+      import_chalk3.default.green(package_default.version)
+    ].join(" ");
+    const localVersion = [
+      "Arquebus Local version:",
+      import_chalk3.default.green(this.modulePackage.version || "None")
+    ].join(" ");
+    import_commander.program.name("arquebus").version(`${cliVersion}
+${localVersion}`);
+    import_commander.program.command("init").description("Create a fresh Arquebus config.").addArgument(
+      new import_commander.Argument("[type]", "Type of config to generate.").choices(["js", "ts"]).default("js", "generates a js config")
+    ).action(async (type) => {
+      if (!this.modulePath) this.output.error([
+        "ERROR: No local arquebus install found",
+        " Try running: npm install arquebus --save"
+      ]);
+      if (this.configPath) {
+        this.output.error(`ERROR: ${this.configPath} already exists`);
+      }
+      try {
+        const stubPath = `./arquebus.config.${type}`;
+        const code = await (0, import_promises4.readFile)(
+          import_path4.default.join(this.modulePath, `/src/stubs/arquebus.config-${type}.stub`),
+          { encoding: "utf8" }
+        );
+        await (0, import_promises4.writeFile)(import_path4.default.join(this.cwd, stubPath), code);
+        this.output.success(`Initialized: Arquebus has been initialized as ${stubPath}`);
+      } catch (e) {
+        this.output.error("ERROR: " + e);
       }
-      this.forceDeleting = true;
-      return tap(await this.delete(), (deleted) => {
-        this.forceDeleting = false;
-        if (deleted) {
-          this.execHooks("forceDeleted", false);
+    });
+    import_commander.program.command("migrate:make <name>").description("Create a new migration file.").addOption(
+      new import_commander.Option("-l, --type [string]", "Type of migration file to generate.").choices(["js", "ts"]).default("js", "generates a js migration file")
+    ).option("-t, --table [string]", "The table to migrate").option("-c, --create [string]", "The table to be created").option("-p, --path [path]", "The path to the migrations directory.").action(async (name, opts) => {
+      if (!this.configPath) this.terminateNotFound();
+      try {
+        name = (0, import_radashi13.snake)(name);
+        const migrationPath = import_path4.default.join(this.cwd, opts.path ?? this.config.migrations?.path ?? "./migrations");
+        let table = opts.table;
+        let create = opts.create || false;
+        if (!table && typeof create === "string") {
+          table = create;
+          create = true;
         }
-      });
-    }
-    forceDeleteQuietly() {
-      return this.withoutEvents(() => this.forceDelete());
-    }
-    async performDeleteOnModel(options = {}) {
-      if (this.forceDeleting) {
-        return tap(await this.setKeysForSaveQuery(this.newModelQuery()).forceDelete(), () => {
-          this.exists = false;
+        if (!table) {
+          const guessed = TableGuesser.guess(name);
+          table = guessed[0];
+          create = !!guessed[1];
+        }
+        this.output.info("INFO: Creating Migration");
+        const creator = new migration_creator_default(void 0, opts.type);
+        const fileName = await creator.create(name, migrationPath, table, create);
+        this.output.success(`INFO: Migration Created 
+ ${import_chalk3.default.gray(import_path4.default.basename(fileName))}`, true);
+      } catch (e) {
+        this.output.error("ERROR: " + e);
+      }
+    });
+    import_commander.program.command("migrate:publish <package>").description("Publish any migration files from packages.").option("-p, --path [path]", "The path to the migrations directory.").action(async (pkg, opts) => {
+      if (!this.configPath) {
+        this.terminateNotFound();
+      }
+      try {
+        const packagePath = Utils.findModulePkg(pkg) ?? "";
+        const basePath = import_path4.default.join(this.cwd, opts.path ?? this.config.migrations?.path ?? "./migrations");
+        const pkgJson = await import(import_path4.default.join(packagePath, "package.json"));
+        if (!packagePath) this.output.error(`ERROR: package ${pkg} not found`);
+        const creator = new migration_creator_default(import_path4.default.join(packagePath, pkgJson.migrations ?? "migrations"));
+        this.output.info(`INFO: Publishing migrations from ${import_chalk3.default.italic.gray(pkgJson.name + "@" + pkgJson.version)}`);
+        await creator.publish(basePath, (fileName) => {
+          Utils.twoColumnDetail(fileName, import_chalk3.default.green("PUBLISHED"));
         });
+      } catch (e) {
+        this.output.error("ERROR: " + e);
       }
-      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);
+    });
+    import_commander.program.command("migrate").description("Run all pending migrations.").option("-s, --step [number]", "Force the migrations to be run so they can be rolled back individually.").option("-p, --path [path]", "The path to the migrations directory.").action(async (opts) => {
+      if (!this.configPath) {
+        this.terminateNotFound();
       }
-      await query.update(columns);
-      this.syncOriginalAttributes(Object.keys(columns));
-      this.execHooks("trashed", options);
-    }
-    async restore(options = {}) {
-      if (this.execHooks("restoring", options) === false) {
-        return false;
+      const basePath = opts.path ? import_path4.default.join(this.cwd, opts.path) : this.cwd;
+      try {
+        await new Migrate(basePath).run(this.config, opts, true);
+      } catch (e) {
+        this.output.error("ERROR: " + e);
       }
-      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 !(0, import_radashi13.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)));
+    });
+    import_commander.program.command("migrate:rollback").description("Rollback the last database migration.").option("-s, --step [number]", "The number of migrations to be reverted.").option("-p, --path [path]", "The path to the migrations directory.").action(async (opts) => {
+      if (!this.configPath) this.terminateNotFound();
+      const basePath = opts.path ? import_path4.default.join(this.cwd, opts.path) : this.cwd;
+      try {
+        await new Migrate(basePath, void 0, (msg, sts) => {
+          if (sts) this.output[sts](msg);
+        }).rollback(this.config, opts, true);
+      } catch (e) {
+        this.output.error("ERROR: " + e);
+      }
+    });
+    import_commander.program.command("migrate:status").description("Show the status of each migration.").option("-p, --path [path]", "The path to the migrations directory.").action(async (opts) => {
+      if (!this.configPath) this.terminateNotFound();
+      const basePath = opts.path ? import_path4.default.join(this.cwd, opts.path) : this.cwd;
+      try {
+        const migrations = await new Migrate(basePath, void 0, (msg, sts) => {
+          if (sts) this.output[sts](msg);
+        }).status(this.config, opts, true);
+        if (migrations.length > 0) {
+          Utils.twoColumnDetail(import_chalk3.default.gray("Migration name"), import_chalk3.default.gray("Batch / Status"));
+          migrations.forEach((migration) => {
+            const status = migration.ran ? `[${migration.batch}] ${import_chalk3.default.green("Ran")}` : import_chalk3.default.yellow("Pending");
+            Utils.twoColumnDetail(migration.name, status);
+          });
+        } else {
+          console.log("No migrations found");
+        }
+      } catch (e) {
+        this.output.error("ERROR: " + e);
+      }
+    });
+    import_commander.program.command("model:make <name>").description("Create a new Model file.").addOption(
+      new import_commander.Option("-l, --type [string]", "Type of migration file to generate.").choices(["js", "ts"]).default("js", "generates a js migration file")
+    ).option("--force", "Force creation if model already exists.", false).option("-p, --path [path]", "The path to the models directory.").action(async (name, opts) => {
+      if (!this.configPath) this.terminateNotFound();
+      const modelPath = import_path4.default.join(this.cwd, opts.path ?? this.config.models?.path ?? "./models", name.toLowerCase() + "." + opts.type);
+      try {
+        if (!opts.force && await Utils.fileExists(modelPath)) {
+          this.output.error("ERROR: Model already exists.");
+        }
+        await (0, import_promises4.mkdir)(import_path4.default.dirname(modelPath), { recursive: true });
+        const stubPath = import_path4.default.join(this.modulePath, `src/stubs/model-${opts.type}.stub`);
+        let stub = await (0, import_promises4.readFile)(stubPath, "utf-8");
+        stub = stub.replace(/{{ name }}/g, name);
+        await (0, import_promises4.writeFile)(modelPath, stub);
+        this.output.success(`Created Model: ${modelPath}`);
+      } catch (e) {
+        this.output.error("ERROR: " + e);
+      }
+    });
+    await import_commander.program.parseAsync(process.argv);
+    process.exit(0);
   }
-  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
-);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Attribute,
-  Builder,
-  CastsAttributes,
-  Collection,
-  HasUniqueIds,
-  InvalidArgumentError,
-  Migration,
-  Model,
-  ModelNotFoundError,
-  Paginator,
-  Pivot,
-  QueryBuilder,
-  RelationNotFoundError,
-  Scope,
-  SoftDeletes,
-  arquebus,
-  compose,
-  flattenDeep,
-  getAttrMethod,
-  getAttrName,
-  getGetterMethod,
-  getRelationMethod,
-  getRelationName,
-  getScopeMethod,
-  getScopeName,
-  getSetterMethod,
-  kebabCase,
-  make,
-  makeCollection,
-  makePaginator,
-  migrateRollback,
-  migrateRun,
-  migrateStatus,
-  now,
-  snakeCase,
-  tap
+  Cli
 });