@bjnstnkvc/db 1.0.0 → 2.0.1

package/README.md

@@ -16,7 +16,8 @@ The method names and their semantics follow Laravel closely enough that the docs
 - [Grouping](#grouping)
 - [Query plans](#query-plans)
 - [Transactions](#transactions)
-- [Events and the query log](#events-and-the-query-log)
+- [Events](#events)
+- [Query log](#query-log)
 - [Multiple tabs](#multiple-tabs)
 - [Connections](#connections)
 - [Storage quota](#storage-quota)
@@ -94,13 +95,13 @@ await DB.migrate('app');
 and every example below passes it as `DB.table<User>('users')` so the builder can type its
 constraints, its return values and its aggregate keys.
 
-| Option | Meaning |
-| --- | --- |
-| `default` | The connection used when none is named |
-| `connections[name].database` | The IndexedDB database name |
-| `connections[name].migrations` | Ordered migration classes. Their order **is** the schema version. |
-| `connections[name].seeders` | Ordered seeder classes, run by `DB.seed(name)`. See [Seeding](#seeding). |
-| `connections[name].strict` | Defaults to `true`. Nullability violations and uncoercible values throw. `false` writes `null` instead. |
+| Option                         | Meaning                                                                                                 |
+|--------------------------------|---------------------------------------------------------------------------------------------------------|
+| `default`                      | The connection used when none is named                                                                  |
+| `connections[name].database`   | The IndexedDB database name                                                                             |
+| `connections[name].migrations` | Ordered migration classes. Their order **is** the schema version.                                       |
+| `connections[name].seeders`    | Ordered seeder classes, run by `DB.seed(name)`. See [Seeding](#seeding).                                |
+| `connections[name].strict`     | Defaults to `true`. Nullability violations and uncoercible values throw. `false` writes `null` instead. |
 
 `DB.migrate(name)` is idempotent. It opens the database at the version your migrations ask for, and
 when that already matches, nothing runs. Calling it on every boot is the intended usage, and there
@@ -144,8 +145,10 @@ start over, `DB.fresh(name)` deletes the database and replays every migration.
 Migrations may only ever be **appended**. Reordering them, or removing one that already ran, throws
 `MigrationMismatchException` rather than corrupting the schema.
 
-The recorded name defaults to the class name, so a bundler that mangles class names will look like a
-reordered list. If you minify with class-name mangling, override `name()`:
+The recorded name defaults to the class name in snake case, the way Laravel names a migration file,
+so `CreateUsersTable` is recorded as `create_users_table`. Because it is derived from the class name,
+a bundler that mangles class names will look like a reordered list. If you minify with class-name
+mangling, override `name()`:
 
 ```ts
 class CreateUsersTable extends Migration {
@@ -184,15 +187,15 @@ Resolves to one entry per registered migration:
 
 ```
 [
-    { migration: 'CreateUsersTable', ran: true, at: '2026-08-27T21:00:00.000Z' },
-    { migration: 'AddRoleToUsersTable', ran: false, at: null }
+    { migration: 'create_users_table', ran: true, at: '2026-08-27T21:00:00.000Z' },
+    { migration: 'add_role_to_users_table', ran: false, at: null }
 ]
 ```
 
 `DB.status(name)` never migrates as a side effect, so you can call it before `DB.migrate(name)` to
 see what is pending.
 
-> modeled on Laravel's [Migrations](https://laravel.com/docs/12.x/migrations). These only run
+> Modeled on Laravel's [Migrations](https://laravel.com/docs/12.x/migrations). These only run
 > forward, and they are registered in the connection config rather than discovered from a directory.
 
 ### Seeding
@@ -478,7 +481,7 @@ await DB.fresh('app');
 await DB.fresh('app', { seed: true });
 ```
 
-> modeled on Laravel's [Database: Seeding](https://laravel.com/docs/12.x/seeding), down to the
+> Modeled on Laravel's [Database: Seeding](https://laravel.com/docs/12.x/seeding), down to the
 > seeded connection standing in as the default for the duration of the run.
 
 ### Defining a schema
@@ -486,21 +489,21 @@ await DB.fresh('app', { seed: true });
 IndexedDB stores whole objects and enforces only a key path, `autoIncrement` and indexes. Column
 types are recorded as metadata and enforced by this package at write time.
 
-| Blueprint | Effect |
-| --- | --- |
-| `table.id()` | `keyPath: 'id'`, `autoIncrement: true` |
-| `table.uuid('id').primary()` | `keyPath: 'id'`, no autoIncrement |
-| `table.string` / `integer` / `float` / `boolean` / `date` / `datetime` / `json` | Column metadata |
-| `table.decimal('price', 2)` | Column metadata, stored as a whole number of the smallest unit |
-| `table.enum('role', Role)` | Column metadata, checked at write time. Takes a list, an enum or a constant object |
-| `.nullable()` | Metadata, enforced at write time |
-| `.default(value)` | Applied at write time, and backfilled when added to an existing table |
-| `.primary()` | Makes the column the key path. At most one per table. |
-| `.index()` | `createIndex('users_name_index', 'name')` |
-| `.unique()` | `createIndex('users_email_unique', 'email', { unique: true })` |
-| `table.index(['a', 'b'])` | Compound index |
-| `.multiEntry()` | One index entry per array element |
-| `table.timestamps()` | Nullable `created_at` / `updated_at`, filled automatically |
+| Blueprint                                                                       | Effect                                                                             |
+|---------------------------------------------------------------------------------|------------------------------------------------------------------------------------|
+| `table.id()`                                                                    | `keyPath: 'id'`, `autoIncrement: true`                                             |
+| `table.uuid('id').primary()`                                                    | `keyPath: 'id'`, no autoIncrement                                                  |
+| `table.string` / `integer` / `float` / `boolean` / `date` / `datetime` / `json` | Column metadata                                                                    |
+| `table.decimal('price', 2)`                                                     | Column metadata, stored as a whole number of the smallest unit                     |
+| `table.enum('role', Role)`                                                      | Column metadata, checked at write time. Takes a list, an enum or a constant object |
+| `.nullable()`                                                                   | Metadata, enforced at write time                                                   |
+| `.default(value)`                                                               | Applied at write time, and backfilled when added to an existing table              |
+| `.primary()`                                                                    | Makes the column the key path. At most one per table.                              |
+| `.index()`                                                                      | `createIndex('users_name_index', 'name')`                                          |
+| `.unique()`                                                                     | `createIndex('users_email_unique', 'email', { unique: true })`                     |
+| `table.index(['a', 'b'])`                                                       | Compound index                                                                     |
+| `.multiEntry()`                                                                 | One index entry per array element                                                  |
+| `table.timestamps()`                                                            | Nullable `created_at` / `updated_at`, filled automatically                         |
 
 Altering a table also supports `dropColumn`, `renameColumn`, `dropIndex` and `Schema.rename`. The key
 path may not be dropped or renamed, because IndexedDB fixes it when the store is created.
@@ -665,7 +668,7 @@ await Schema.getIndexes('users');
 await Schema.connection('reporting').hasTable('reports');
 ```
 
-> modeled on Laravel's [Migrations: Tables](https://laravel.com/docs/12.x/migrations#tables).
+> Modeled on Laravel's [Migrations: Tables](https://laravel.com/docs/12.x/migrations#tables).
 > Column types are metadata this package enforces at write time, since IndexedDB stores whole objects
 > and checks nothing itself.
 
@@ -771,22 +774,22 @@ await DB.table<User>('users').min('age');
 await DB.table<User>('users').max('age');
 ```
 
-| Terminal | Resolves to |
-| --- | --- |
-| `get()` | `T[]` |
-| `first()` | `T` or `null` |
-| `firstOrFail()` | `T`, or throws `RecordsNotFoundException` |
-| `find(key)` | `T` or `null`, by point lookup on the key path |
-| `findOrFail(key)` | `T`, or throws `RecordsNotFoundException` |
-| `value(column)` | The column of the first matching record, or `null` |
-| `pluck(column)` | `V[]` in result order |
-| `pluck(column, key)` | `Record<string, V>`, keyed by a second column |
-| `exists()` / `doesntExist()` | `boolean` |
-| `count()` | `number` |
-| `sum(column)` | `number` |
-| `avg(column)` / `min(column)` / `max(column)` | `number` or `null` when nothing matched |
-| `sole()` | `T`, or throws `RecordsNotFoundException` / `MultipleRecordsFoundException` |
-| `paginate(page?, perPage?)` | `{ data, total, perPage, currentPage, lastPage }` |
+| Terminal                                      | Resolves to                                                                 |
+|-----------------------------------------------|-----------------------------------------------------------------------------|
+| `get()`                                       | `T[]`                                                                       |
+| `first()`                                     | `T` or `null`                                                               |
+| `firstOrFail()`                               | `T`, or throws `RecordsNotFoundException`                                   |
+| `find(key)`                                   | `T` or `null`, by point lookup on the key path                              |
+| `findOrFail(key)`                             | `T`, or throws `RecordsNotFoundException`                                   |
+| `value(column)`                               | The column of the first matching record, or `null`                          |
+| `pluck(column)`                               | `V[]` in result order                                                       |
+| `pluck(column, key)`                          | `Record<string, V>`, keyed by a second column                               |
+| `exists()` / `doesntExist()`                  | `boolean`                                                                   |
+| `count()`                                     | `number`                                                                    |
+| `sum(column)`                                 | `number`                                                                    |
+| `avg(column)` / `min(column)` / `max(column)` | `number` or `null` when nothing matched                                     |
+| `sole()`                                      | `T`, or throws `RecordsNotFoundException` / `MultipleRecordsFoundException` |
+| `paginate(page?, perPage?)`                   | `{ data, total, perPage, currentPage, lastPage }`                           |
 
 `min` and `max` read the answer straight off the index when the column has one and the query is
 unconstrained, so they cost one cursor rather than a full scan.
@@ -852,7 +855,7 @@ The key path may not be updated, so `update`, `upsert` and `increment` all refus
 when an index drives the query and key order otherwise. Pair them with an indexed `orderBy` if you
 need a defined order.
 
-> modeled on Laravel's [Database: Query Builder](https://laravel.com/docs/12.x/queries). The method
+> Modeled on Laravel's [Database: Query Builder](https://laravel.com/docs/12.x/queries). The method
 > names and their semantics match, and every terminal is asynchronous because IndexedDB is.
 
 ### Joins
@@ -959,7 +962,7 @@ covers it, and `chunk` slices the materialised result rather than walking keys.
 await DB.table('users').whereColumn('updated_at', '>', 'created_at').get();
 ```
 
-> modeled on Laravel's [Query Builder: Joins](https://laravel.com/docs/12.x/queries#joins). Rows
+> Modeled on Laravel's [Query Builder: Joins](https://laravel.com/docs/12.x/queries#joins). Rows
 > stay flat as they do in Laravel, and the join itself runs in memory because IndexedDB has none.
 
 ### Grouping
@@ -994,13 +997,13 @@ Because the alias is an object key rather than a string inside an expression, th
 inferred rather than cast. That row is typed `{ role: string; total: number; oldest: number | null }`,
 and reading a column you did not group or aggregate is a compile error.
 
-| Aggregate | Meaning |
-| --- | --- |
-| `{ count: '*' }` | The number of records in the group, always a `number` |
-| `{ count: 'column' }` | The number of records whose column is not null |
-| `{ sum: 'column' }` | The total, `0` for a group with no values |
-| `{ avg: 'column' }` | The mean, `null` for a group with no values |
-| `{ min: 'column' }` / `{ max: 'column' }` | The extreme, `null` for a group with no values |
+| Aggregate                                 | Meaning                                               |
+|-------------------------------------------|-------------------------------------------------------|
+| `{ count: '*' }`                          | The number of records in the group, always a `number` |
+| `{ count: 'column' }`                     | The number of records whose column is not null        |
+| `{ sum: 'column' }`                       | The total, `0` for a group with no values             |
+| `{ avg: 'column' }`                       | The mean, `null` for a group with no values           |
+| `{ min: 'column' }` / `{ max: 'column' }` | The extreme, `null` for a group with no values        |
 
 Group by several columns by passing several names:
 
@@ -1032,7 +1035,7 @@ await DB.table<User>('users')
 Grouping happens in memory after the records are fetched, so the planner still applies to the
 `where` clauses that select them, and a grouped query reports the plan of that underlying fetch.
 
-> modeled on Laravel's [Query Builder: Grouping](https://laravel.com/docs/12.x/queries#groupby-having),
+> Modeled on Laravel's [Query Builder: Grouping](https://laravel.com/docs/12.x/queries#groupby-having),
 > with the aggregates named in a typed object instead of raw SQL.
 
 ### Query plans
@@ -1092,32 +1095,52 @@ commits behind your back the first time you await anything outside it, so offeri
 offering a trap. The same rule as migrations applies here: the callback may only await operations
 from this package.
 
-> modeled on Laravel's [Database: Transactions](https://laravel.com/docs/12.x/database#database-transactions).
+> Modeled on Laravel's [Database: Transactions](https://laravel.com/docs/12.x/database#database-transactions).
 > The tables have to be declared up front, because an IndexedDB transaction fixes its scope when it
 > opens.
 
-### Events and the query log
+### Events
 
-```ts
-DB.onQueryExecuted((event: QueryExecuted): void => {
-    console.log(event.plan, event.duration, event.records);
-});
+Listen for an event by its key, and the listener receives an instance of the class it maps to:
 
+```ts
 DB.listen('migration-started', (event: MigrationStarted): void => console.log(event.migration));
 DB.listen('query', listener, { once: true });
 DB.forget('query', listener);
 ```
 
-Available events: `query`, `transaction-beginning`, `transaction-committed`,
-`transaction-rolled-back`, `migrations-started`, `migration-started`, `migration-ended`,
-`migrations-ended`, `no-pending-migrations`, `seeding-started`, `seeder-started`, `seeder-ended`,
-`seeding-ended`, `database-blocked`.
+Every event also has a shortcut named after its class, which takes the same options:
+
+```ts
+DB.onQueryExecuted((event: QueryExecuted): void => {
+    console.log(event.plan, event.duration, event.records);
+});
+```
+
+| Key                       | Class                   | Carries                                                                                |
+|---------------------------|-------------------------|----------------------------------------------------------------------------------------|
+| `query`                   | `QueryExecuted`         | `connection`, `table`, `plan`, `constraints`, `orders`, `limit`, `duration`, `records` |
+| `transaction-beginning`   | `TransactionBeginning`  | `connection`                                                                           |
+| `transaction-committed`   | `TransactionCommitted`  | `connection`                                                                           |
+| `transaction-rolled-back` | `TransactionRolledBack` | `connection`, `reason`                                                                 |
+| `migrations-started`      | `MigrationsStarted`     | `connection`, `migrations`                                                             |
+| `migration-started`       | `MigrationStarted`      | `migration`                                                                            |
+| `migration-ended`         | `MigrationEnded`        | `migration`                                                                            |
+| `migrations-ended`        | `MigrationsEnded`       | `connection`, `migrations`                                                             |
+| `no-pending-migrations`   | `NoPendingMigrations`   | `connection`                                                                           |
+| `seeding-started`         | `SeedingStarted`        | `connection`, `seeders`                                                                |
+| `seeder-started`          | `SeederStarted`         | `seeder`                                                                               |
+| `seeder-ended`            | `SeederEnded`           | `seeder`                                                                               |
+| `seeding-ended`           | `SeedingEnded`          | `connection`, `seeders`                                                                |
+| `database-blocked`        | `DatabaseBlocked`       | `database`                                                                             |
 
 A connection with no seeders announces nothing, so `seeding-started` firing always means at least
 one seeder is about to run.
 
-Listeners are **persistent by default**, with an opt-in `{ once: true }`. This is a deliberate
-departure from `@bjnstnkvc/local-storage`, where every listener fires exactly once.
+> Modeled on Laravel's [Migrations: Events](https://laravel.com/docs/12.x/migrations#events), with
+> each event dispatched as a browser event and listened for by key.
+
+### Query log
 
 ```ts
 DB.enableQueryLog();
@@ -1127,7 +1150,7 @@ await DB.table<User>('users').where('role', 'admin').get();
 DB.getQueryLog();
 ```
 
-Resolves to one entry per query that ran while the log was enabled:
+Resolves to one entry per `query` event dispatched while the log was enabled:
 
 ```
 [
@@ -1148,7 +1171,7 @@ DB.disableQueryLog();
 
 `DB.logging()` then returns `false`, and `DB.getQueryLog()` an empty array.
 
-> modeled on Laravel's [Database: Listening for Query Events](https://laravel.com/docs/12.x/database#listening-for-query-events),
+> Modeled on Laravel's [Database: Listening for Query Events](https://laravel.com/docs/12.x/database#listening-for-query-events),
 > with the same enable, get and flush surface, dispatched as a browser event.
 
 ### Multiple tabs
@@ -1171,14 +1194,14 @@ DB.disconnect('app');
 DB.purge('app');
 ```
 
-| Call | Effect |
-| --- | --- |
-| `connection()` | The default connection |
-| `connection(name)` | A named connection, cached after the first resolve |
+| Call               | Effect                                                                           |
+|--------------------|----------------------------------------------------------------------------------|
+| `connection()`     | The default connection                                                           |
+| `connection(name)` | A named connection, cached after the first resolve                               |
 | `disconnect(name)` | Close the handle, leaving the connection registered so the next query reopens it |
-| `purge(name)` | Close it and drop it, so the next resolve rebuilds it from configuration |
+| `purge(name)`      | Close it and drop it, so the next resolve rebuilds it from configuration         |
 
-> modeled on Laravel's [Database: Multiple Connections](https://laravel.com/docs/12.x/database#using-multiple-database-connections),
+> Modeled on Laravel's [Database: Multiple Connections](https://laravel.com/docs/12.x/database#using-multiple-database-connections),
 > resolved by name and cached, with one IndexedDB database behind each.
 
 ### Storage quota
@@ -1233,21 +1256,21 @@ memory, so writes inside a narrowed transaction still get their defaults.
 Every exception extends `Error` and sets its own `name`, so `instanceof` and the stack both read
 true. All of them are exported from the package root.
 
-| Exception | Thrown when |
-| --- | --- |
-| `CheckConstraintViolationException` | A write gives an enumerated column a value it does not accept |
-| `ConnectionNotConfiguredException` | A connection is resolved under a name `DB.configure` never declared |
-| `DatabaseBlockedException` | Another tab holds the database open at an older version, so the upgrade cannot start |
-| `MigrationMismatchException` | The recorded migration list is not a prefix of the registered one, so one was removed, renamed or reordered |
-| `MigrationTransactionClosedException` | A migration awaited something outside this package, letting the versionchange transaction commit early |
-| `MultipleRecordsFoundException` | `sole()` matched more than one record |
-| `NotNullConstraintViolationException` | A non-nullable column is written as null, or is absent with no default |
-| `QuotaExceededException` | The origin's storage quota stopped the operation |
-| `RecordsNotFoundException` | `firstOrFail()`, `sole()` or `findOrFail()` matched nothing |
-| `ReservedTableException` | A migration tries to create `migrations` or `schema` |
-| `SchemaException` | A schema or query call the shape of the database cannot support |
-| `TableNotFoundException` | A query or schema read names a table the database does not have |
-| `UniqueConstraintViolationException` | A write collides with a unique index, named in the message |
+| Exception                             | Thrown when                                                                                                 |
+|---------------------------------------|-------------------------------------------------------------------------------------------------------------|
+| `CheckConstraintViolationException`   | A write gives an enumerated column a value it does not accept                                               |
+| `ConnectionNotConfiguredException`    | A connection is resolved under a name `DB.configure` never declared                                         |
+| `DatabaseBlockedException`            | Another tab holds the database open at an older version, so the upgrade cannot start                        |
+| `MigrationMismatchException`          | The recorded migration list is not a prefix of the registered one, so one was removed, renamed or reordered |
+| `MigrationTransactionClosedException` | A migration awaited something outside this package, letting the versionchange transaction commit early      |
+| `MultipleRecordsFoundException`       | `sole()` matched more than one record                                                                       |
+| `NotNullConstraintViolationException` | A non-nullable column is written as null, or is absent with no default                                      |
+| `QuotaExceededException`              | The origin's storage quota stopped the operation                                                            |
+| `RecordsNotFoundException`            | `firstOrFail()`, `sole()` or `findOrFail()` matched nothing                                                 |
+| `ReservedTableException`              | A migration tries to create `migrations` or `schema`                                                        |
+| `SchemaException`                     | A schema or query call the shape of the database cannot support                                             |
+| `TableNotFoundException`              | A query or schema read names a table the database does not have                                             |
+| `UniqueConstraintViolationException`  | A write collides with a unique index, named in the message                                                  |
 
 `SchemaException` is the broad one, so here is every case that raises it:
 

package/dist/main.cjs

@@ -1170,7 +1170,7 @@ var Request = class {
 };
 
 // src/schema/Coercer.ts
-var FALSY = ["false", "0"];
+var FALSY = /* @__PURE__ */ new Set(["false", "0"]);
 var Coercer = class {
   /**
    * Coerce a value into its declared column type.
@@ -1187,7 +1187,7 @@ var Coercer = class {
       case "float":
         return this.#numeric(value, strict, false);
       case "boolean":
-        return typeof value === "string" && FALSY.includes(value) ? false : Boolean(value);
+        return typeof value === "string" && FALSY.has(value) ? false : Boolean(value);
       case "decimal":
         return this.#scaled(value, strict);
       case "enum":
@@ -1435,15 +1435,9 @@ var Join = class {
    * The conditions the tables are joined on.
    */
   #conditions = [];
-  /**
-   * Join on a pair of columns.
-   */
   on(first, operator, second) {
     return this.#condition("and", first, operator, second);
   }
-  /**
-   * Join on a pair of columns, disjunctively.
-   */
   orOn(first, operator, second) {
     return this.#condition("or", first, operator, second);
   }
@@ -1488,7 +1482,7 @@ var Predicate = class {
       if (index === 0 || constraint.conjunction === "or") {
         groups.push([]);
       }
-      groups[groups.length - 1]?.push(constraint);
+      groups.at(-1)?.push(constraint);
     }
     return groups;
   }
@@ -1748,7 +1742,7 @@ var Joiner = class {
 };
 
 // src/query/Planner.ts
-var RANGEABLE = ["=", "==", "===", ">", ">=", "<", "<="];
+var RANGEABLE = /* @__PURE__ */ new Set(["=", "==", "===", ">", ">=", "<", "<="]);
 var Planner = class {
   /**
    * Compile the constraints and orders into an execution plan.
@@ -1838,7 +1832,7 @@ var Planner = class {
       }
       return { constraint, ...target, range: IDBKeyRange.bound(constraint.from, constraint.to, false, false), values: null };
     }
-    if (!RANGEABLE.includes(constraint.operator) || !this.#keyable(constraint.value)) {
+    if (!RANGEABLE.has(constraint.operator) || !this.#keyable(constraint.value)) {
       return null;
     }
     return { constraint, ...target, range: this.#range(constraint.operator, constraint.value), values: null };
@@ -1914,7 +1908,7 @@ var Signature = class {
    * Build a signature identifying a record by every column it holds.
    */
   static of(record) {
-    return Object.keys(record).sort().map((column) => this.#segment(column) + this.#segment(this.value(record[column]))).join("");
+    return Object.keys(record).sort((a, b) => a < b ? -1 : 1).map((column) => this.#segment(column) + this.#segment(this.value(record[column]))).join("");
   }
   /**
    * Build a signature identifying an ordered list of values.
@@ -1997,17 +1991,11 @@ var Grouping = class _Grouping {
     grouping.#offset = this.#offset;
     return grouping;
   }
-  /**
-   * Constrain the groups the query returns.
-   */
-  having(column, operator, value) {
-    return this.#constrain("and", column, operator, value);
+  having(column, ...parameters) {
+    return this.#constrain("and", column, parameters);
   }
-  /**
-   * Add a disjunctive constraint on the groups the query returns.
-   */
-  orHaving(column, operator, value) {
-    return this.#constrain("or", column, operator, value);
+  orHaving(column, ...parameters) {
+    return this.#constrain("or", column, parameters);
   }
   /**
    * Sort the groups by a column or an aggregate.
@@ -2117,8 +2105,8 @@ var Grouping = class _Grouping {
   /**
    * Add a constraint on the groups the query returns.
    */
-  #constrain(conjunction, column, operator, value) {
-    const resolved = value === void 0 ? { operator: "=", value: operator } : { operator, value };
+  #constrain(conjunction, column, parameters) {
+    const resolved = parameters.length < 2 ? { operator: "=", value: parameters[0] } : { operator: parameters[0], value: parameters[1] };
     this.#constraints.push({ type: "basic", column, operator: resolved.operator, value: resolved.value, conjunction, not: false });
     return this;
   }
@@ -2186,23 +2174,14 @@ var Builder = class _Builder {
   get table() {
     return this.#table;
   }
-  /**
-   * Add a constraint to the query.
-   */
-  where(column, operator, value) {
-    return this.#constrain("and", false, column, operator, value);
+  where(column, ...parameters) {
+    return this.#constrain("and", false, column, parameters);
   }
-  /**
-   * Add a disjunctive constraint to the query.
-   */
-  orWhere(column, operator, value) {
-    return this.#constrain("or", false, column, operator, value);
+  orWhere(column, ...parameters) {
+    return this.#constrain("or", false, column, parameters);
   }
-  /**
-   * Add a negated constraint to the query.
-   */
-  whereNot(column, operator, value) {
-    return this.#constrain("and", true, column, operator, value);
+  whereNot(column, ...parameters) {
+    return this.#constrain("and", true, column, parameters);
   }
   /**
    * Constrain a column to one of the given values.
@@ -2327,21 +2306,12 @@ var Builder = class _Builder {
   whereDay(column, value) {
     return this.#part("and", column, "day", value);
   }
-  /**
-   * Join another table, keeping only the rows that match.
-   */
   join(table, first, operator, second) {
     return this.#join("inner", table, first, operator, second);
   }
-  /**
-   * Join another table, keeping every row of this one.
-   */
   leftJoin(table, first, operator, second) {
     return this.#join("left", table, first, operator, second);
   }
-  /**
-   * Join another table, keeping every row of it.
-   */
   rightJoin(table, first, operator, second) {
     return this.#join("right", table, first, operator, second);
   }
@@ -2352,15 +2322,9 @@ var Builder = class _Builder {
     this.#joins.push({ table, type: "cross", conditions: [] });
     return this;
   }
-  /**
-   * Constrain a column against another column of the same row.
-   */
   whereColumn(column, operator, other) {
     return this.#compared("and", column, operator, other);
   }
-  /**
-   * Constrain a column against another column of the same row, disjunctively.
-   */
   orWhereColumn(column, operator, other) {
     return this.#compared("or", column, operator, other);
   }
@@ -2983,7 +2947,7 @@ var Builder = class _Builder {
   /**
    * Add a constraint of the given shape to the query.
    */
-  #constrain(conjunction, not, column, operator, value) {
+  #constrain(conjunction, not, column, parameters) {
     if (typeof column === "function") {
       const nested = new _Builder(this.#connection, this.#table, this.#transaction);
       column(nested);
@@ -3000,7 +2964,7 @@ var Builder = class _Builder {
       }));
       return this.#push({ type: "nested", constraints, conjunction, not });
     }
-    const resolved = value === void 0 ? { operator: "=", value: operator } : { operator, value };
+    const resolved = parameters.length < 2 ? { operator: "=", value: parameters[0] } : { operator: parameters[0], value: parameters[1] };
     return this.#push({ type: "basic", column, operator: resolved.operator, value: resolved.value, conjunction, not });
   }
   /**
@@ -3060,6 +3024,8 @@ var Builder = class _Builder {
     const clause = new Join();
     if (typeof first === "function") {
       first(clause);
+    } else if (second === void 0) {
+      clause.on(first, operator);
     } else {
       clause.on(first, operator, second);
     }
@@ -4141,7 +4107,7 @@ var Migration = class {
    * Get the name of the migration.
    */
   name() {
-    return this.constructor.name;
+    return this.constructor.name.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
   }
 };
 

package/dist/main.d.cts

@@ -302,11 +302,13 @@ declare class Join {
     /**
      * Join on a pair of columns.
      */
-    on(first: string, operator: Operator | string, second?: string): this;
+    on(first: string, second: string): this;
+    on(first: string, operator: Operator, second: string): this;
     /**
      * Join on a pair of columns, disjunctively.
      */
-    orOn(first: string, operator: Operator | string, second?: string): this;
+    orOn(first: string, second: string): this;
+    orOn(first: string, operator: Operator, second: string): this;
     /**
      * Get the conditions the tables are joined on.
      */
@@ -327,11 +329,13 @@ declare class Grouping<T, G extends (keyof T & string)[], A extends Aggregations
     /**
      * Constrain the groups the query returns.
      */
-    having(column: Key<Grouped<T, G, A>>, operator?: Operator | unknown, value?: unknown): this;
+    having(column: Key<Grouped<T, G, A>>, value: unknown): this;
+    having(column: Key<Grouped<T, G, A>>, operator: Operator, value: unknown): this;
     /**
      * Add a disjunctive constraint on the groups the query returns.
      */
-    orHaving(column: Key<Grouped<T, G, A>>, operator?: Operator | unknown, value?: unknown): this;
+    orHaving(column: Key<Grouped<T, G, A>>, value: unknown): this;
+    orHaving(column: Key<Grouped<T, G, A>>, operator: Operator, value: unknown): this;
     /**
      * Sort the groups by a column or an aggregate.
      */
@@ -518,7 +522,6 @@ declare class Connection {
 
 type Nested<T> = (query: Builder<T>) => void;
 type Joining = (join: Join) => void;
-type Column<T> = Key<T> | Partial<T> | Nested<T>;
 declare class Builder<T = Record<string, unknown>> {
     #private;
     /**
@@ -532,15 +535,21 @@ declare class Builder<T = Record<string, unknown>> {
     /**
      * Add a constraint to the query.
      */
-    where(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    where(column: Partial<T> | Nested<T>): this;
+    where(column: Key<T>, value: unknown): this;
+    where(column: Key<T>, operator: Operator, value: unknown): this;
     /**
      * Add a disjunctive constraint to the query.
      */
-    orWhere(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    orWhere(column: Partial<T> | Nested<T>): this;
+    orWhere(column: Key<T>, value: unknown): this;
+    orWhere(column: Key<T>, operator: Operator, value: unknown): this;
     /**
      * Add a negated constraint to the query.
      */
-    whereNot(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    whereNot(column: Partial<T> | Nested<T>): this;
+    whereNot(column: Key<T>, value: unknown): this;
+    whereNot(column: Key<T>, operator: Operator, value: unknown): this;
     /**
      * Constrain a column to one of the given values.
      */
@@ -624,15 +633,21 @@ declare class Builder<T = Record<string, unknown>> {
     /**
      * Join another table, keeping only the rows that match.
      */
-    join<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    join<R = Record<string, unknown>>(table: string, first: Joining): Builder<R>;
+    join<R = Record<string, unknown>>(table: string, first: string, second: string): Builder<R>;
+    join<R = Record<string, unknown>>(table: string, first: string, operator: Operator, second: string): Builder<R>;
     /**
      * Join another table, keeping every row of this one.
      */
-    leftJoin<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    leftJoin<R = Record<string, unknown>>(table: string, first: Joining): Builder<R>;
+    leftJoin<R = Record<string, unknown>>(table: string, first: string, second: string): Builder<R>;
+    leftJoin<R = Record<string, unknown>>(table: string, first: string, operator: Operator, second: string): Builder<R>;
     /**
      * Join another table, keeping every row of it.
      */
-    rightJoin<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    rightJoin<R = Record<string, unknown>>(table: string, first: Joining): Builder<R>;
+    rightJoin<R = Record<string, unknown>>(table: string, first: string, second: string): Builder<R>;
+    rightJoin<R = Record<string, unknown>>(table: string, first: string, operator: Operator, second: string): Builder<R>;
     /**
      * Pair every row of this table with every row of another.
      */
@@ -640,11 +655,13 @@ declare class Builder<T = Record<string, unknown>> {
     /**
      * Constrain a column against another column of the same row.
      */
-    whereColumn(column: Key<T>, operator: Operator | string, other?: string): this;
+    whereColumn(column: Key<T>, other: string): this;
+    whereColumn(column: Key<T>, operator: Operator, other: string): this;
     /**
      * Constrain a column against another column of the same row, disjunctively.
      */
-    orWhereColumn(column: Key<T>, operator: Operator | string, other?: string): this;
+    orWhereColumn(column: Key<T>, other: string): this;
+    orWhereColumn(column: Key<T>, operator: Operator, other: string): this;
     /**
      * Project only the given columns, which may alias what they select.
      */

package/dist/main.d.ts

@@ -302,11 +302,13 @@ declare class Join {
     /**
      * Join on a pair of columns.
      */
-    on(first: string, operator: Operator | string, second?: string): this;
+    on(first: string, second: string): this;
+    on(first: string, operator: Operator, second: string): this;
     /**
      * Join on a pair of columns, disjunctively.
      */
-    orOn(first: string, operator: Operator | string, second?: string): this;
+    orOn(first: string, second: string): this;
+    orOn(first: string, operator: Operator, second: string): this;
     /**
      * Get the conditions the tables are joined on.
      */
@@ -327,11 +329,13 @@ declare class Grouping<T, G extends (keyof T & string)[], A extends Aggregations
     /**
      * Constrain the groups the query returns.
      */
-    having(column: Key<Grouped<T, G, A>>, operator?: Operator | unknown, value?: unknown): this;
+    having(column: Key<Grouped<T, G, A>>, value: unknown): this;
+    having(column: Key<Grouped<T, G, A>>, operator: Operator, value: unknown): this;
     /**
      * Add a disjunctive constraint on the groups the query returns.
      */
-    orHaving(column: Key<Grouped<T, G, A>>, operator?: Operator | unknown, value?: unknown): this;
+    orHaving(column: Key<Grouped<T, G, A>>, value: unknown): this;
+    orHaving(column: Key<Grouped<T, G, A>>, operator: Operator, value: unknown): this;
     /**
      * Sort the groups by a column or an aggregate.
      */
@@ -518,7 +522,6 @@ declare class Connection {
 
 type Nested<T> = (query: Builder<T>) => void;
 type Joining = (join: Join) => void;
-type Column<T> = Key<T> | Partial<T> | Nested<T>;
 declare class Builder<T = Record<string, unknown>> {
     #private;
     /**
@@ -532,15 +535,21 @@ declare class Builder<T = Record<string, unknown>> {
     /**
      * Add a constraint to the query.
      */
-    where(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    where(column: Partial<T> | Nested<T>): this;
+    where(column: Key<T>, value: unknown): this;
+    where(column: Key<T>, operator: Operator, value: unknown): this;
     /**
      * Add a disjunctive constraint to the query.
      */
-    orWhere(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    orWhere(column: Partial<T> | Nested<T>): this;
+    orWhere(column: Key<T>, value: unknown): this;
+    orWhere(column: Key<T>, operator: Operator, value: unknown): this;
     /**
      * Add a negated constraint to the query.
      */
-    whereNot(column: Column<T>, operator?: Operator | unknown, value?: unknown): this;
+    whereNot(column: Partial<T> | Nested<T>): this;
+    whereNot(column: Key<T>, value: unknown): this;
+    whereNot(column: Key<T>, operator: Operator, value: unknown): this;
     /**
      * Constrain a column to one of the given values.
      */
@@ -624,15 +633,21 @@ declare class Builder<T = Record<string, unknown>> {
     /**
      * Join another table, keeping only the rows that match.
      */
-    join<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    join<R = Record<string, unknown>>(table: string, first: Joining): Builder<R>;
+    join<R = Record<string, unknown>>(table: string, first: string, second: string): Builder<R>;
+    join<R = Record<string, unknown>>(table: string, first: string, operator: Operator, second: string): Builder<R>;
     /**
      * Join another table, keeping every row of this one.
      */
-    leftJoin<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    leftJoin<R = Record<string, unknown>>(table: string, first: Joining): Builder<R>;
+    leftJoin<R = Record<string, unknown>>(table: string, first: string, second: string): Builder<R>;
+    leftJoin<R = Record<string, unknown>>(table: string, first: string, operator: Operator, second: string): Builder<R>;
     /**
      * Join another table, keeping every row of it.
      */
-    rightJoin<R = Record<string, unknown>>(table: string, first: string | Joining, operator?: Operator | string, second?: string): Builder<R>;
+    rightJoin<R = Record<string, unknown>>(table: string, first: Joining): Builder<R>;
+    rightJoin<R = Record<string, unknown>>(table: string, first: string, second: string): Builder<R>;
+    rightJoin<R = Record<string, unknown>>(table: string, first: string, operator: Operator, second: string): Builder<R>;
     /**
      * Pair every row of this table with every row of another.
      */
@@ -640,11 +655,13 @@ declare class Builder<T = Record<string, unknown>> {
     /**
      * Constrain a column against another column of the same row.
      */
-    whereColumn(column: Key<T>, operator: Operator | string, other?: string): this;
+    whereColumn(column: Key<T>, other: string): this;
+    whereColumn(column: Key<T>, operator: Operator, other: string): this;
     /**
      * Constrain a column against another column of the same row, disjunctively.
      */
-    orWhereColumn(column: Key<T>, operator: Operator | string, other?: string): this;
+    orWhereColumn(column: Key<T>, other: string): this;
+    orWhereColumn(column: Key<T>, operator: Operator, other: string): this;
     /**
      * Project only the given columns, which may alias what they select.
      */

package/dist/main.js

@@ -1106,7 +1106,7 @@ var Request = class {
 };
 
 // src/schema/Coercer.ts
-var FALSY = ["false", "0"];
+var FALSY = /* @__PURE__ */ new Set(["false", "0"]);
 var Coercer = class {
   /**
    * Coerce a value into its declared column type.
@@ -1123,7 +1123,7 @@ var Coercer = class {
       case "float":
         return this.#numeric(value, strict, false);
       case "boolean":
-        return typeof value === "string" && FALSY.includes(value) ? false : Boolean(value);
+        return typeof value === "string" && FALSY.has(value) ? false : Boolean(value);
       case "decimal":
         return this.#scaled(value, strict);
       case "enum":
@@ -1371,15 +1371,9 @@ var Join = class {
    * The conditions the tables are joined on.
    */
   #conditions = [];
-  /**
-   * Join on a pair of columns.
-   */
   on(first, operator, second) {
     return this.#condition("and", first, operator, second);
   }
-  /**
-   * Join on a pair of columns, disjunctively.
-   */
   orOn(first, operator, second) {
     return this.#condition("or", first, operator, second);
   }
@@ -1424,7 +1418,7 @@ var Predicate = class {
       if (index === 0 || constraint.conjunction === "or") {
         groups.push([]);
       }
-      groups[groups.length - 1]?.push(constraint);
+      groups.at(-1)?.push(constraint);
     }
     return groups;
   }
@@ -1684,7 +1678,7 @@ var Joiner = class {
 };
 
 // src/query/Planner.ts
-var RANGEABLE = ["=", "==", "===", ">", ">=", "<", "<="];
+var RANGEABLE = /* @__PURE__ */ new Set(["=", "==", "===", ">", ">=", "<", "<="]);
 var Planner = class {
   /**
    * Compile the constraints and orders into an execution plan.
@@ -1774,7 +1768,7 @@ var Planner = class {
       }
       return { constraint, ...target, range: IDBKeyRange.bound(constraint.from, constraint.to, false, false), values: null };
     }
-    if (!RANGEABLE.includes(constraint.operator) || !this.#keyable(constraint.value)) {
+    if (!RANGEABLE.has(constraint.operator) || !this.#keyable(constraint.value)) {
       return null;
     }
     return { constraint, ...target, range: this.#range(constraint.operator, constraint.value), values: null };
@@ -1850,7 +1844,7 @@ var Signature = class {
    * Build a signature identifying a record by every column it holds.
    */
   static of(record) {
-    return Object.keys(record).sort().map((column) => this.#segment(column) + this.#segment(this.value(record[column]))).join("");
+    return Object.keys(record).sort((a, b) => a < b ? -1 : 1).map((column) => this.#segment(column) + this.#segment(this.value(record[column]))).join("");
   }
   /**
    * Build a signature identifying an ordered list of values.
@@ -1933,17 +1927,11 @@ var Grouping = class _Grouping {
     grouping.#offset = this.#offset;
     return grouping;
   }
-  /**
-   * Constrain the groups the query returns.
-   */
-  having(column, operator, value) {
-    return this.#constrain("and", column, operator, value);
+  having(column, ...parameters) {
+    return this.#constrain("and", column, parameters);
   }
-  /**
-   * Add a disjunctive constraint on the groups the query returns.
-   */
-  orHaving(column, operator, value) {
-    return this.#constrain("or", column, operator, value);
+  orHaving(column, ...parameters) {
+    return this.#constrain("or", column, parameters);
   }
   /**
    * Sort the groups by a column or an aggregate.
@@ -2053,8 +2041,8 @@ var Grouping = class _Grouping {
   /**
    * Add a constraint on the groups the query returns.
    */
-  #constrain(conjunction, column, operator, value) {
-    const resolved = value === void 0 ? { operator: "=", value: operator } : { operator, value };
+  #constrain(conjunction, column, parameters) {
+    const resolved = parameters.length < 2 ? { operator: "=", value: parameters[0] } : { operator: parameters[0], value: parameters[1] };
     this.#constraints.push({ type: "basic", column, operator: resolved.operator, value: resolved.value, conjunction, not: false });
     return this;
   }
@@ -2122,23 +2110,14 @@ var Builder = class _Builder {
   get table() {
     return this.#table;
   }
-  /**
-   * Add a constraint to the query.
-   */
-  where(column, operator, value) {
-    return this.#constrain("and", false, column, operator, value);
+  where(column, ...parameters) {
+    return this.#constrain("and", false, column, parameters);
   }
-  /**
-   * Add a disjunctive constraint to the query.
-   */
-  orWhere(column, operator, value) {
-    return this.#constrain("or", false, column, operator, value);
+  orWhere(column, ...parameters) {
+    return this.#constrain("or", false, column, parameters);
   }
-  /**
-   * Add a negated constraint to the query.
-   */
-  whereNot(column, operator, value) {
-    return this.#constrain("and", true, column, operator, value);
+  whereNot(column, ...parameters) {
+    return this.#constrain("and", true, column, parameters);
   }
   /**
    * Constrain a column to one of the given values.
@@ -2263,21 +2242,12 @@ var Builder = class _Builder {
   whereDay(column, value) {
     return this.#part("and", column, "day", value);
   }
-  /**
-   * Join another table, keeping only the rows that match.
-   */
   join(table, first, operator, second) {
     return this.#join("inner", table, first, operator, second);
   }
-  /**
-   * Join another table, keeping every row of this one.
-   */
   leftJoin(table, first, operator, second) {
     return this.#join("left", table, first, operator, second);
   }
-  /**
-   * Join another table, keeping every row of it.
-   */
   rightJoin(table, first, operator, second) {
     return this.#join("right", table, first, operator, second);
   }
@@ -2288,15 +2258,9 @@ var Builder = class _Builder {
     this.#joins.push({ table, type: "cross", conditions: [] });
     return this;
   }
-  /**
-   * Constrain a column against another column of the same row.
-   */
   whereColumn(column, operator, other) {
     return this.#compared("and", column, operator, other);
   }
-  /**
-   * Constrain a column against another column of the same row, disjunctively.
-   */
   orWhereColumn(column, operator, other) {
     return this.#compared("or", column, operator, other);
   }
@@ -2919,7 +2883,7 @@ var Builder = class _Builder {
   /**
    * Add a constraint of the given shape to the query.
    */
-  #constrain(conjunction, not, column, operator, value) {
+  #constrain(conjunction, not, column, parameters) {
     if (typeof column === "function") {
       const nested = new _Builder(this.#connection, this.#table, this.#transaction);
       column(nested);
@@ -2936,7 +2900,7 @@ var Builder = class _Builder {
       }));
       return this.#push({ type: "nested", constraints, conjunction, not });
     }
-    const resolved = value === void 0 ? { operator: "=", value: operator } : { operator, value };
+    const resolved = parameters.length < 2 ? { operator: "=", value: parameters[0] } : { operator: parameters[0], value: parameters[1] };
     return this.#push({ type: "basic", column, operator: resolved.operator, value: resolved.value, conjunction, not });
   }
   /**
@@ -2996,6 +2960,8 @@ var Builder = class _Builder {
     const clause = new Join();
     if (typeof first === "function") {
       first(clause);
+    } else if (second === void 0) {
+      clause.on(first, operator);
     } else {
       clause.on(first, operator, second);
     }
@@ -4077,7 +4043,7 @@ var Migration = class {
    * Get the name of the migration.
    */
   name() {
-    return this.constructor.name;
+    return this.constructor.name.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase();
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bjnstnkvc/db",
-  "version": "1.0.0",
+  "version": "2.0.1",
   "description": "TypeScript database layer for IndexedDB with an API modeled on Laravel.",
   "type": "module",
   "main": "./dist/main.cjs",
@@ -8,8 +8,14 @@
   "types": "./dist/main.d.ts",
   "exports": {
     ".": {
-      "import": { "types": "./dist/main.d.ts", "default": "./dist/main.js" },
-      "require": { "types": "./dist/main.d.cts", "default": "./dist/main.cjs" }
+      "import": {
+        "types": "./dist/main.d.ts",
+        "default": "./dist/main.js"
+      },
+      "require": {
+        "types": "./dist/main.d.cts",
+        "default": "./dist/main.cjs"
+      }
     }
   },
   "files": [