uql-orm 0.85.0 → 0.87.0

package/README.md

@@ -185,7 +185,7 @@ Only the entities in `include` are served: a `$populate: { author: true }` here
 - **Type-safe to the leaf, nothing to generate.** Every key is checked against your entity, down into populated relations and [JSON/JSONB](https://uql-orm.dev/querying/json) dot-paths, so `$like` on a numeric column is a compile error. No `.prisma` file, no generated client.
 - **Relations without N+1.** [`$populate`](https://uql-orm.dev/querying/relations) reads a to-many inside the parent's statement, so a read is one round trip. Nothing is lazy, so nothing fires behind your back in a serializer.
 - **Light.** Zero runtime dependencies and every dialect in one package, yet `uql-orm/postgres` is about 27 kB gzipped. See [what we deleted to get there](https://uql-orm.dev/blog/zero-dependencies).
-- **The hard things are built in.** [Semantic and vector search](https://uql-orm.dev/ai-semantic-search), [multi-tenant filters you cannot bypass by accident](https://uql-orm.dev/multi-tenancy), [soft-delete with restore](https://uql-orm.dev/entities/soft-delete), [streaming](https://uql-orm.dev/querying/streaming), [drift checks](https://uql-orm.dev/migrations) that catch a database that no longer matches, and [Better Auth](https://uql-orm.dev/better-auth) on every engine.
+- **The hard things are built in.** [Semantic and vector search](https://uql-orm.dev/ai-semantic-search), [multi-tenant filters you cannot bypass by accident](https://uql-orm.dev/multi-tenancy), [soft-delete with restore](https://uql-orm.dev/entities/soft-delete), [streaming](https://uql-orm.dev/querying/streaming), and [drift checks](https://uql-orm.dev/migrations) that catch a database that no longer matches.
 - **The fastest ORM.** On a full PostgreSQL round trip it adds the least over hand-written driver code of any ORM in our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), on Bun, Node and Deno alike. The same benchmark [scores the types](https://github.com/rogerpadilla/ts-orm-benchmark#type-safety) by compiling ordinary mistakes in each ORM's API: UQL is the only one that catches them all.
 
 ## Get started

package/dist/d1/d1SqliteDialect.js

@@ -7,7 +7,7 @@ import { UqlUsageError } from '../util/uqlError.js';
  */
 export class D1SqliteDialect extends SqliteDialect {
     /** A vector stays text: D1 answers a BLOB as an array of its byte values, which reads like a vector. */
-    features = { ...SQLITE_FEATURES, vectorBytes: false, transactions: false };
+    features = { ...SQLITE_FEATURES, vectorBytes: false };
     // Cloudflare D1 caps bound parameters at 100 per query.
     maxBindValues = 100;
     // And a function call at 32 arguments.

package/dist/dialect/mysqlLikeSqlDialect.js

@@ -32,7 +32,6 @@ export const MYSQL_FEATURES = {
     serverSideCursors: false,
     correlatedWrites: true,
     rowLocks: MYSQL_ROW_LOCKS,
-    transactions: true,
     nullsOrdering: 'expression',
     textScoreIndexes: true,
     orderedUpsertReturning: true,

package/dist/dialect/pgLikeSqlDialect.js

@@ -34,7 +34,6 @@ export const PG_FEATURES = {
     serverSideCursors: true,
     correlatedWrites: true,
     rowLocks: { of: true, withWindow: false, placement: 'suffix' },
-    transactions: true,
     nullsOrdering: 'clause',
     textScoreIndexes: false,
     orderedUpsertReturning: true,

package/dist/migrate/ddl/tableDdl.js

@@ -47,9 +47,11 @@ export class TableDdl {
         if (this.dialect.alterColumnStrategy !== 'separate-clauses') {
             return [`ALTER TABLE ${target} ${this.dialect.alterColumnSyntax} ${definition};`];
         }
-        const alter = `ALTER TABLE ${target} ALTER COLUMN ${this.dialect.escapeId(column.name)}`;
+        const name = this.dialect.escapeId(column.name);
+        const alter = `ALTER TABLE ${target} ALTER COLUMN ${name}`;
         return [
-            (!from || from.type !== column.type) && `${alter} TYPE ${column.type};`,
+            // Cast, since the engine converts only between types it deems compatible: text to integer needs saying.
+            (!from || from.type !== column.type) && `${alter} TYPE ${column.type} USING ${name}::${column.type};`,
             (!from || from.nullable !== column.nullable) && `${alter} ${column.nullable ? 'DROP NOT NULL' : 'SET NOT NULL'};`,
             (!from || !sameDefault(column.defaultValue, from.defaultValue, this.dialect)) &&
                 (column.defaultValue === undefined ? `${alter} DROP DEFAULT;` : `${alter} SET${this.defaultClause(column)};`),

package/dist/migrate/introspection/baseSqlIntrospector.d.ts

@@ -1,7 +1,7 @@
 import type { AbstractSqlDialect } from '../../dialect/index.js';
 import type { IndexFacet } from '../../schema/indexDifferences.js';
 import { SchemaAST } from '../../schema/schemaAST.js';
-import type { TableSchema } from '../../type/migration.js';
+import type { ColumnRenames, TableSchema } from '../../type/migration.js';
 /**
  * Base class for SQL introspectors with shared AST building logic.
  */
@@ -22,7 +22,9 @@ export declare abstract class BaseSqlIntrospector {
      * rather than raised: the point of naming them is to read a database other things are still
      * changing, where scanning every table is both wasted work and a relation that can vanish mid-scan.
      */
-    introspect(tables?: readonly string[]): Promise<SchemaAST>;
+    introspect(tables?: readonly string[], renames?: ColumnRenames): Promise<SchemaAST>;
+    /** `table` with each column `renames` names under its new name, wherever the table names it. */
+    private renamed;
     abstract getTableNames(): Promise<string[]>;
     abstract getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     /**

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -1,7 +1,7 @@
 import { canonicalColumnType } from '../../schema/canonicalType.js';
 import { createTableNode, keyOfColumns, SchemaAST } from '../../schema/schemaAST.js';
 import { escapeSqlId } from '../../util/index.js';
-import { derivedForeignKeyName } from '../../util/sql.util.js';
+import { derivedForeignKeyName, qualifyName } from '../../util/sql.util.js';
 /**
  * Base class for SQL introspectors with shared AST building logic.
  */
@@ -27,17 +27,39 @@ export class BaseSqlIntrospector {
      * rather than raised: the point of naming them is to read a database other things are still
      * changing, where scanning every table is both wasted work and a relation that can vanish mid-scan.
      */
-    async introspect(tables) {
+    async introspect(tables, renames) {
         const tableNames = tables ?? (await this.getTableNames());
         const tableSchemas = [];
         for (const tableName of tableNames) {
             const schema = await this.getTableSchema(tableName);
             if (schema) {
-                tableSchemas.push(schema);
+                tableSchemas.push(renames ? this.renamed(schema, renames) : schema);
             }
         }
         return this.buildAST(tableSchemas);
     }
+    /** `table` with each column `renames` names under its new name, wherever the table names it. */
+    renamed(table, renames) {
+        const nameIn = (tableName) => (column) => renames.get(qualifyName(tableName, this.schema))?.find((rename) => rename.from === column)?.to ?? column;
+        const own = nameIn(table.name);
+        return {
+            ...table,
+            columns: table.columns.map((column) => ({ ...column, name: own(column.name) })),
+            primaryKey: table.primaryKey && { ...table.primaryKey, columns: table.primaryKey.columns.map(own) },
+            indexes: table.indexes?.map((index) => ({
+                ...index,
+                entries: index.entries.map((entry) => (entry.expression ? entry : { ...entry, column: own(entry.column) })),
+            })),
+            foreignKeys: table.foreignKeys?.map((foreignKey) => ({
+                ...foreignKey,
+                columns: foreignKey.columns.map(own),
+                references: {
+                    ...foreignKey.references,
+                    columns: foreignKey.references.columns.map(nameIn(foreignKey.references.table)),
+                },
+            })),
+        };
+    }
     /**
      * Build SchemaAST from table schemas.
      */

package/dist/migrate/migrator.d.ts

@@ -86,14 +86,25 @@ export declare class Migrator {
      * it. Read off the catalogue rather than recorded by uql, and exactly right for restoring one.
      */
     private revertedTriggers;
+    /**
+     * What a generated migration does that its reader must not miss: each column it drops or retypes, which
+     * can lose data, and each table it creates empty while the database holds one no entity names with the
+     * same columns, which may be the table renamed. That one is never renamed here: it may be another's.
+     */
+    private noteChanges;
+    /** The tables the database holds that no entity names, each paired with a new one it is identical to. */
+    private renamedTables;
     /** The entities whose tables are among `created`. */
     private createdEntities;
     /** The table `entity` maps to, as a diff names it. */
     private tableOf;
     /**
-     * Get all schema differences between entities and database
+     * The differences between the entities and the database. With `renames`, a column identical to one the
+     * entity no longer names is renamed in place rather than dropped and added, as a generated migration wants.
      */
-    getDiffs(): Promise<SchemaDiff[]>;
+    getDiffs(options?: {
+        renames?: boolean;
+    }): Promise<SchemaDiff[]>;
     /**
      * The tables `entities` name, read a schema at a time so each is keyed as its entity spells it. Those
      * alone: nothing else is diffed, and another table can be dropped mid-scan by whatever else is running.

package/dist/migrate/migrator.js

@@ -3,6 +3,7 @@ import { basename, extname, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { getEntities, getMeta } from '../entity/index.js';
 import { SchemaAST } from '../schema/index.js';
+import { columnRenames, tableRenameCandidates } from '../schema/schemaASTDiffer.js';
 import { hasTriggers } from '../util/field.util.js';
 import { LoggerWrapper } from '../util/index.js';
 import { UqlUsageError } from '../util/uqlError.js';
@@ -183,8 +184,9 @@ export class Migrator {
      */
     async generateFromEntities(name) {
         const generator = await this.getSchemaGenerator();
-        const { created, altered } = await this.pendingChanges();
+        const { created, altered } = await this.pendingChanges({ renames: true });
         const plan = this.alterPlan(generator, altered, await this.installedTriggers(created));
+        await this.noteChanges(generator, created, altered);
         const up = [...this.createSchema(generator, created), ...plan.up];
         if (up.length === 0) {
             this.logger.logInfo('No schema changes detected.');
@@ -234,18 +236,23 @@ export class Migrator {
      * its entity declares goes back on after. `down` is lazy: SQLite cannot express every alter's inverse.
      */
     alterPlan(generator, altered, state) {
-        const changing = new Set(altered.filter((diff) => sides(diff.columns, 'from').length).map((diff) => diff.tableName));
+        const changing = new Set(altered
+            .filter((diff) => sides(diff.columns, 'from').length || diff.renamedColumns?.length)
+            .map((diff) => diff.tableName));
         const cleared = state.filter(({ entity }) => changing.has(this.tableOf(entity)));
         const after = state.map((it) => (cleared.includes(it) ? { entity: it.entity, installed: new Map() } : it));
         return {
             up: [
                 ...cleared.flatMap(({ entity, installed }) => generator.generateTriggerDrops(entity, [...installed.keys()])),
-                ...altered.flatMap((diff) => generator.generateAlterTable(diff)),
+                ...altered.flatMap((diff) => [...renameStatements(generator, diff), ...generator.generateAlterTable(diff)]),
                 ...this.reconcileTriggers(generator, after),
             ],
             down: () => [
                 ...this.revertedTriggers(generator, after),
-                ...altered.toReversed().flatMap((diff) => generator.generateAlterTable(reverseDiff(diff))),
+                ...altered.toReversed().flatMap((diff) => {
+                    const reversed = reverseDiff(diff);
+                    return [...generator.generateAlterTable(reversed), ...renameStatements(generator, reversed)];
+                }),
                 ...cleared.flatMap(({ installed }) => [...installed.values()].flat().map((sql) => `${sql};`)),
             ],
         };
@@ -265,6 +272,36 @@ export class Migrator {
     revertedTriggers(generator, state) {
         return state.flatMap(({ entity, installed }) => generator.generateTriggersDown(entity, installed));
     }
+    /**
+     * What a generated migration does that its reader must not miss: each column it drops or retypes, which
+     * can lose data, and each table it creates empty while the database holds one no entity names with the
+     * same columns, which may be the table renamed. That one is never renamed here: it may be another's.
+     */
+    async noteChanges(generator, created, altered) {
+        for (const { tableName, columns = [] } of altered) {
+            for (const { from, to } of columns.filter((change) => change.isBreaking)) {
+                this.logger.logWarn(to
+                    ? `Retypes "${tableName}"."${to.name}" from ${from?.type} to ${to.type}: a value that does not fit is lost or refused.`
+                    : `Drops "${tableName}"."${from?.name}", losing what it holds.`);
+            }
+        }
+        for (const { from, to } of await this.renamedTables(generator, created)) {
+            this.logger.logWarn(`Creates "${to}" empty, while "${from}", which no entity names, holds the same columns. If it was ` +
+                `renamed, replace its creation in this migration with \`renameTable('${from}', '${to}')\`.`);
+        }
+    }
+    /** The tables the database holds that no entity names, each paired with a new one it is identical to. */
+    async renamedTables(generator, created) {
+        const createdEntities = this.createdEntities(created);
+        const diffOptions = generator.diffOptions?.();
+        if (!createdEntities.length || !generator.buildAST || !diffOptions) {
+            return [];
+        }
+        const owned = new Set(this.entities.map((entity) => this.tableOf(entity)));
+        const unowned = (await this.schemaIntrospector.getTableNames()).filter((table) => !owned.has(table));
+        const current = await this.schemaIntrospector.introspect(unowned);
+        return tableRenameCandidates(generator.buildAST(createdEntities), current, diffOptions);
+    }
     /** The entities whose tables are among `created`. */
     createdEntities(created) {
         const fresh = new Set(created);
@@ -275,18 +312,25 @@ export class Migrator {
         return this.pool.dialect.resolveTableName(getMeta(entity));
     }
     /**
-     * Get all schema differences between entities and database
+     * The differences between the entities and the database. With `renames`, a column identical to one the
+     * entity no longer names is renamed in place rather than dropped and added, as a generated migration wants.
      */
-    async getDiffs() {
+    async getDiffs(options = {}) {
         const generator = await this.getSchemaGenerator();
-        const ast = await this.introspectEntities(this.entities);
-        // Both sides built once: the database's above, the entities' here. Left to `diffSchema`, each
+        // Both sides built once: the database's here, the entities' below. Left to `diffSchema`, each
         // entity would rebuild the whole AST, which is quadratic in the number of entities. Absent on a
         // generator that compares no schema of its own - MongoDB, which reads only indexes.
         const desiredAst = generator.buildAST?.(this.entities);
+        let ast = await this.introspectEntities(this.entities);
+        const diffOptions = generator.diffOptions?.();
+        const renames = options.renames && desiredAst && diffOptions ? columnRenames(desiredAst, ast, diffOptions) : new Map();
+        if (renames.size) {
+            // Read again under the names the entities give them, so the rest compares as the columns they become.
+            ast = await this.introspectEntities(this.entities, renames);
+        }
         return this.entities.flatMap((entity) => {
-            const table = ast.getTable(generator.resolveTableName(getMeta(entity)));
-            const diff = generator.diffSchema(entity, table, desiredAst);
+            const tableName = generator.resolveTableName(getMeta(entity));
+            const diff = generator.diffSchema(entity, ast.getTable(tableName), desiredAst, renames.get(tableName));
             return diff ? [diff] : [];
         });
     }
@@ -294,13 +338,13 @@ export class Migrator {
      * The tables `entities` name, read a schema at a time so each is keyed as its entity spells it. Those
      * alone: nothing else is diffed, and another table can be dropped mid-scan by whatever else is running.
      */
-    async introspectEntities(entities) {
+    async introspectEntities(entities, renames) {
         const { dialect } = this.pool;
         const bySchema = Map.groupBy(new Set(entities), (entity) => dialect.resolveSchema(getMeta(entity)));
         const merged = new SchemaAST();
         for (const [schema, members] of bySchema) {
             const tables = members.map((entity) => dialect.resolveTableAlias(getMeta(entity)));
-            for (const table of (await this.schemaIntrospectorFor(schema).introspect(tables)).getTables()) {
+            for (const table of (await this.schemaIntrospectorFor(schema).introspect(tables, renames)).getTables()) {
                 merged.addTable(table);
             }
         }
@@ -388,8 +432,8 @@ export class Migrator {
      * alter. What to emit for each stays with the caller: a sync narrows an alter to what it allows and
      * never asks for the rollback, which on SQLite cannot even be expressed (no `ALTER COLUMN`).
      */
-    async pendingChanges() {
-        const diffs = await this.getDiffs();
+    async pendingChanges(options = {}) {
+        const diffs = await this.getDiffs(options);
         return {
             created: diffs.filter((diff) => diff.type === 'create').map((diff) => diff.tableName),
             altered: diffs.filter((diff) => diff.type === 'alter'),
@@ -554,3 +598,7 @@ function referencedEntities(meta) {
     const relations = Object.values(meta.relations).flatMap((relation) => relation?.entity?.() ?? []);
     return [...fields, ...relations];
 }
+/** A diff's column renames, through the builder operation every SQL generator already renders. */
+function renameStatements(generator, { tableName, renamedColumns = [] }) {
+    return renamedColumns.flatMap(({ from, to }) => generator.generateOperation({ type: 'renameColumn', tableName, oldName: from, newName: to }));
+}

package/dist/migrate/schemaChange.js

@@ -33,5 +33,6 @@ export function reverseDiff(diff) {
         columns: diff.columns?.map(swap),
         indexes: diff.indexes?.map(swap),
         foreignKeys: diff.foreignKeys?.map(swap),
+        renamedColumns: diff.renamedColumns?.map(({ from, to }) => ({ from: to, to: from })),
     };
 }

package/dist/migrate/schemaGenerator.d.ts

@@ -3,7 +3,7 @@ import type { SchemaAST } from '../schema/schemaAST.js';
 import { type BuildSchemaASTOptions } from '../schema/schemaASTBuilder.js';
 import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
-import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, InstalledTriggers, EntityWhereMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../type/index.js';
+import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, InstalledTriggers, EntityWhereMeta, FieldMeta, FieldOptions, ForeignKeySchema, IndexSchema, Rename, NamingStrategy, SchemaDiff, SchemaGenerator, Type } from '../type/index.js';
 import type { AnyMigrationOperation, FullColumnDefinition, IndexDefinition, TableDefinition } from './builder/types.js';
 import { type IndexDdl, type TableDdl } from './ddl/index.js';
 /**
@@ -106,8 +106,6 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * one column of a composite key, which its table never makes serial.
      */
     getSqlType(field: FieldMeta): string;
-    /** The statements that alter `column` in place, as this dialect spells them. */
-    generateAlterColumnStatements(tableName: string, column: ColumnSchema, newDefinition: string): string[];
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment: string): string;
     /** The `COMMENT ON` statements a table and its columns need, after the `CREATE TABLE`, where the engine uses them. */
@@ -121,8 +119,8 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * How the entity differs from the table the database reported, compared by {@link diffTable}, the one
      * drift detection runs, with types normalized as the engine stores them.
      */
-    diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST): SchemaDiff | undefined;
-    protected diffOptions(): DiffOptions;
+    diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST, renamedColumns?: readonly Rename[]): SchemaDiff | undefined;
+    diffOptions(): DiffOptions;
     /** Spread, not copied field by field, so a field the node gains cannot go missing here. */
     private columnNodeToSchema;
     /** Whether a column's stored default is the one the entity declares, as this engine reprints it. */

package/dist/migrate/schemaGenerator.js

@@ -270,10 +270,6 @@ export class SqlSchemaGenerator {
             ? this.serialType(canonical)
             : this.canonicalTypeToSql(canonical);
     }
-    /** The statements that alter `column` in place, as this dialect spells them. */
-    generateAlterColumnStatements(tableName, column, newDefinition) {
-        return this.tableDdl.alterColumn(tableName, column, newDefinition);
-    }
     /** The inline ` COMMENT '...'` a column declaration carries, where the engine takes one there. */
     generateColumnComment(comment) {
         return this.features.commentSyntax === 'inline' ? ` COMMENT ${this.dialect.escape(comment)}` : '';
@@ -302,7 +298,7 @@ export class SqlSchemaGenerator {
      * How the entity differs from the table the database reported, compared by {@link diffTable}, the one
      * drift detection runs, with types normalized as the engine stores them.
      */
-    diffSchema(entity, currentTable, desiredAst) {
+    diffSchema(entity, currentTable, desiredAst, renamedColumns) {
         const meta = getMeta(entity);
         const tableName = this.resolveTableName(meta);
         const schema = this.resolveSchema(meta);
@@ -326,11 +322,12 @@ export class SqlSchemaGenerator {
                 return { to: this.columnNodeToSchema(it.expected) };
             }
             if (it.type === 'drop') {
-                return { from: this.columnNodeToSchema(it.actual) };
+                return { from: this.columnNodeToSchema(it.actual), isBreaking: true };
             }
             return {
                 from: this.columnNodeToSchema(it.actual),
                 to: { ...this.columnNodeToSchema(it.expected), enum: undefined },
+                isBreaking: it.isBreaking,
             };
         });
         const keyDiff = tableDiff?.primaryKeyDiff;
@@ -363,8 +360,11 @@ export class SqlSchemaGenerator {
                 ...indexes.toAlter.map(({ from, to }) => ({ from: indexNodeToSchema(from), to: indexNodeToSchema(to) })),
             ]),
             foreignKeys: nonEmpty(foreignKeys),
+            renamedColumns: nonEmpty(renamedColumns ?? []),
         };
-        return alter.primaryKey || alter.columns || alter.indexes || alter.foreignKeys ? alter : undefined;
+        return alter.primaryKey || alter.columns || alter.indexes || alter.foreignKeys || alter.renamedColumns
+            ? alter
+            : undefined;
     }
     diffOptions() {
         return {
@@ -513,7 +513,7 @@ export class SqlSchemaGenerator {
     }
     generateAlterColumnSql(tableName, columnName, column) {
         const node = fullColumnDefinitionToNode(column, tableName);
-        return this.generateAlterColumnStatements(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node));
+        return this.tableDdl.alterColumn(tableName, { ...this.columnNodeToSchema(node), name: columnName }, this.generateColumnFromNode(node));
     }
     generateDropColumnSql(tableName, columnName) {
         return this.tableDdl.dropColumn(tableName, columnName);

package/dist/mongo/mongoDialect.js

@@ -32,7 +32,6 @@ export const mongoDialectFeatures = {
     serverSideCursors: false,
     correlatedWrites: false,
     rowLocks: false, // its concurrency control is the transaction plus atomic document updates
-    transactions: true,
 };
 /** What `toWireId` converts: the hex spelling of an `ObjectId`, and nothing looser. */
 const HEX_24 = /^[0-9a-f]{24}$/i;

package/dist/mssql/mssqlDialect.js

@@ -31,7 +31,6 @@ const MSSQL_FEATURES = {
     serverSideCursors: false,
     correlatedWrites: true,
     rowLocks: { of: true, withWindow: true, placement: 'tableHint' },
-    transactions: true,
     nullsOrdering: 'case',
     textScoreIndexes: false,
     orderedUpsertReturning: false,

package/dist/schema/matchByKey.d.ts

@@ -8,3 +8,12 @@ export declare function matchByKey<S, T>(source: Iterable<S>, target: Iterable<T
     dropped: T[];
     matched: (readonly [S, T])[];
 };
+/**
+ * What {@link matchByKey} left unpaired, paired where `same` finds exactly one counterpart on each side:
+ * an item two others could be is ambiguous, so it stays created or dropped.
+ */
+export declare function pairUnique<S, T>(created: readonly S[], dropped: readonly T[], same: (source: S, target: T) => boolean): {
+    created: S[];
+    dropped: T[];
+    matched: (readonly [S, T & ({} | null)])[];
+};

package/dist/schema/matchByKey.js

@@ -16,3 +16,21 @@ export function matchByKey(source, target, key) {
     }
     return { created, dropped: [...unpaired.values()].flat(), matched };
 }
+/**
+ * What {@link matchByKey} left unpaired, paired where `same` finds exactly one counterpart on each side:
+ * an item two others could be is ambiguous, so it stays created or dropped.
+ */
+export function pairUnique(created, dropped, same) {
+    const matched = created.flatMap((source) => {
+        const [target, ...others] = dropped.filter((candidate) => same(source, candidate));
+        return target !== undefined && !others.length && created.filter((other) => same(other, target)).length === 1
+            ? [[source, target]]
+            : [];
+    });
+    const paired = new Set(matched.flat());
+    return {
+        created: created.filter((item) => !paired.has(item)),
+        dropped: dropped.filter((item) => !paired.has(item)),
+        matched,
+    };
+}

package/dist/schema/schemaASTDiffer.d.ts

@@ -1,3 +1,4 @@
+import type { ColumnRenames, Rename } from '../type/migration.js';
 import type { SchemaAST } from './schemaAST.js';
 import type { CanonicalType } from './types.js';
 import type { ColumnDiff, ForeignKeyAction, IndexDiff, RelationshipDiff, RelationshipNode, SchemaDiffResult, TableDiff, TableNode } from './types.js';
@@ -28,6 +29,18 @@ export declare function diffTable(source: TableNode, target: TableNode, options?
     readonly columnDiffs: ColumnDiff[];
     readonly indexDiffs: IndexDiff[];
 }) | undefined;
+/**
+ * The columns renamed in the tables both sides name, by qualified table:
+ * a new column identical to exactly one the entity no longer names, and to no other. The dropped side is
+ * always the entity's own table, so a wrong guess renames, keeping the data, and never drops it.
+ */
+export declare function columnRenames(desired: SchemaAST, actual: SchemaAST, options?: DiffOptions): ColumnRenames;
+/**
+ * Tables the database holds that a new one is identical to but for its name, each only where it is the one
+ * match on both sides. Suggested, never applied: the database's side is a table no entity names, which may
+ * be another application's rather than one this schema renamed.
+ */
+export declare function tableRenameCandidates(desired: SchemaAST, actual: SchemaAST, options?: DiffOptions): Rename[];
 /** The differences between two lists of foreign keys, matched by their columns and never by the name the engine gave them. */
 export declare function diffRelationshipNodes(source: readonly RelationshipNode[], target: readonly RelationshipNode[], opts?: DiffOptions): RelationshipDiff[];
 /** A relationship's `ON DELETE` and `ON UPDATE`, an unstated one read as the action the database applies. */

package/dist/schema/schemaASTDiffer.js

@@ -1,6 +1,7 @@
+import { qualifyName } from '../util/sql.util.js';
 import { areTypesEqual, isBreakingTypeChange } from './canonicalType.js';
 import { describeIndexDifferences, pairIndexes } from './indexDifferences.js';
-import { matchByKey } from './matchByKey.js';
+import { matchByKey, pairUnique } from './matchByKey.js';
 import { DEFAULT_FOREIGN_KEY_ACTION } from './types.js';
 /**
  * Default diff options.
@@ -23,9 +24,7 @@ function relationEnds(relation) {
 /** The differences between the expected schema (the entities) and the actual one (the database). */
 export function diffSchemas(source, target, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
-    const normalizeName = nameNormalizer(opts);
-    const included = (tables) => [...tables].filter((table) => !opts.excludeTables.includes(table.name));
-    const { created: tablesToCreate, dropped: tablesToDrop, matched, } = matchByKey(included(source.tables.values()), included(target.tables.values()), (table) => normalizeName(table.name));
+    const { created: tablesToCreate, dropped: tablesToDrop, matched } = matchTables(source, target, opts);
     const tablesToAlter = matched
         .map(([sourceTable, targetTable]) => diffTable(sourceTable, targetTable, opts))
         .filter((tableDiff) => tableDiff !== undefined);
@@ -104,6 +103,38 @@ function diffTableColumns(source, target, opts) {
             .filter((diff) => diff !== undefined),
     ];
 }
+/**
+ * The columns renamed in the tables both sides name, by qualified table:
+ * a new column identical to exactly one the entity no longer names, and to no other. The dropped side is
+ * always the entity's own table, so a wrong guess renames, keeping the data, and never drops it.
+ */
+export function columnRenames(desired, actual, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const normalizeName = nameNormalizer(opts);
+    return new Map(matchTables(desired, actual, opts).matched.flatMap(([expected, current]) => {
+        const { created, dropped } = matchByKey(expected.columns.values(), current.columns.values(), (column) => normalizeName(column.name));
+        const { matched } = pairUnique(created, dropped, (to, from) => !diffColumn(expected.name, to, from, opts));
+        const table = qualifyName(current.name, current.schema);
+        return matched.length ? [[table, matched.map(([to, from]) => ({ from: from.name, to: to.name }))]] : [];
+    }));
+}
+/**
+ * Tables the database holds that a new one is identical to but for its name, each only where it is the one
+ * match on both sides. Suggested, never applied: the database's side is a table no entity names, which may
+ * be another application's rather than one this schema renamed.
+ */
+export function tableRenameCandidates(desired, actual, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const { created, dropped } = matchTables(desired, actual, opts);
+    const same = (to, from) => to.schema === from.schema && !diffTable(to, from, { ...opts, compareIndexes: false });
+    return pairUnique(created, dropped, same).matched.map(([to, from]) => ({ from: from.name, to: to.name }));
+}
+/** The two sides' tables paired by name, those `excludeTables` names left out of both. */
+function matchTables(desired, actual, opts) {
+    const normalizeName = nameNormalizer(opts);
+    const included = (tables) => [...tables].filter((table) => !opts.excludeTables.includes(table.name));
+    return matchByKey(included(desired.tables.values()), included(actual.tables.values()), (table) => normalizeName(table.name));
+}
 /** Compare indexes between two tables, paired by {@link pairIndexes}, in what the target's reader reports. */
 function diffTableIndexes(source, target, opts) {
     const { created, dropped, matched } = pairIndexes(source.indexes, target.indexes, nameNormalizer(opts));

package/dist/sqlite/sqliteDialect.js

@@ -34,7 +34,6 @@ export const SQLITE_FEATURES = {
     serverSideCursors: false,
     correlatedWrites: true,
     rowLocks: false,
-    transactions: true,
     nullsOrdering: 'clause',
     textScoreIndexes: false,
     orderedUpsertReturning: true,

package/dist/type/dialect.d.ts

@@ -141,11 +141,6 @@ export interface DialectFeatures {
      * value rather than a flag each, since the details mean nothing without a lock.
      */
     readonly rowLocks: RowLockFeatures | false;
-    /**
-     * Whether the engine runs a transaction across statements: false on D1, which refuses one, so what
-     * would open one can run its steps in order instead. MongoDB has them as a replica set alone.
-     */
-    readonly transactions: boolean;
 }
 /** How a dialect spells a row lock, once {@link DialectFeatures.rowLocks} says it has one. */
 export interface RowLockFeatures {

package/dist/type/migration.d.ts

@@ -1,6 +1,7 @@
 import type { AnyMigrationOperation } from '../migrate/builder/types.js';
 import type { IndexFacet } from '../schema/indexDifferences.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
+import type { DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { ColumnNode, ForeignKeyAction, IndexType, TableNode } from '../schema/types.js';
 import type { EntityMeta, EntityWhereMeta, FieldOptions, IndexColumnSchema, IndexedVectorField, LoggingOptions, Querier, SqlQuerier, Type, VectorIndexOptions } from './index.js';
 /**
@@ -173,6 +174,17 @@ export interface ForeignKeySchema {
  * change is undone by swapping its ends. No engine alters an index, a key or a foreign key in place, so
  * an alter of one is its drop and its add, which safe mode holds back together.
  */
+/** A column's change, and whether it can lose what the column holds: a drop, or a retype that narrows it. */
+export type ColumnChange = Change<ColumnSchema> & {
+    readonly isBreaking?: boolean;
+};
+/** A name changed, `from` the database's `to` the entity's. */
+export type Rename = {
+    readonly from: string;
+    readonly to: string;
+};
+/** Renamed columns by qualified table name. */
+export type ColumnRenames = ReadonlyMap<string, readonly Rename[]>;
 export interface Change<T> {
     readonly from?: T;
     readonly to?: T;
@@ -199,9 +211,11 @@ export interface SchemaDiff {
     readonly schema?: string;
     readonly type: 'create' | 'alter' | 'drop';
     readonly primaryKey?: Change<PrimaryKeySchema>;
-    readonly columns?: readonly Change<ColumnSchema>[];
+    readonly columns?: readonly ColumnChange[];
     readonly indexes?: readonly Change<IndexSchema>[];
     readonly foreignKeys?: readonly Change<ForeignKeySchema>[];
+    /** Columns renamed in place, `from` the database's name `to` the entity's, which the other changes already use. */
+    readonly renamedColumns?: readonly Rename[];
 }
 /**
  * What every sync entry point takes: `safe` keeps it additive, `drop` lets it remove a column, and
@@ -288,10 +302,13 @@ export interface SchemaGenerator {
     /**
      * An entity's differences from its table. `desiredAst`, from {@link buildAST}, has to span every entity
      * a foreign key here points at, or those keys read as matching.
+     * `renamedColumns` are columns `currentTable` already holds under their new names.
      */
-    diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST): SchemaDiff | undefined;
+    diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST, renamedColumns?: readonly Rename[]): SchemaDiff | undefined;
     /** The entities as one AST, built once per run for every {@link diffSchema}. Absent on MongoDB, which diffs only indexes. */
     buildAST?(entities: readonly Type<object>[]): SchemaAST;
+    /** How this engine's diff compares types and defaults. Absent where {@link buildAST} is. */
+    diffOptions?(): DiffOptions;
     /**
      * The table's key: {@link resolveTableAlias} behind {@link resolveSchema}, which is how a
      * `SchemaAST` stores it and how a diff finds it again.
@@ -326,8 +343,11 @@ export interface SchemaIntrospector {
      * the database side never reports it, and no migration can close the gap.
      */
     readonly indexFacets: ReadonlySet<IndexFacet>;
-    /** The whole database, or just the tables named. Names nothing matches are left out. */
-    introspect(tables?: readonly string[]): Promise<SchemaAST>;
+    /**
+     * The whole database, or just the tables named. Names nothing matches are left out. `renames` reads
+     * each column under the name it is being renamed to, so a diff compares it as the column it becomes.
+     */
+    introspect(tables?: readonly string[], renames?: ColumnRenames): Promise<SchemaAST>;
     /**
      * Get all table names in the database
      */

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.85.0",
+  "version": "0.87.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -35,7 +35,6 @@
     "./http": "./dist/http/index.js",
     "./express": "./dist/express/index.js",
     "./nestjs": "./dist/nestjs/index.js",
-    "./betterAuth": "./dist/betterAuth/index.js",
     "./browser": {
       "types": "./dist/browser/index.d.ts",
       "import": "./dist/browser/index.js",
@@ -72,7 +71,6 @@
     "@nestjs/core": ">=10.0.0",
     "@tursodatabase/database": ">=0.7.0",
     "@tursodatabase/serverless": ">=1.3.0",
-    "better-auth": ">=1.7.0",
     "better-sqlite3": ">=9.0.0",
     "express": ">=5.0.0",
     "mariadb": ">=3.0.0",
@@ -105,9 +103,6 @@
     "@tursodatabase/serverless": {
       "optional": true
     },
-    "better-auth": {
-      "optional": true
-    },
     "better-sqlite3": {
       "optional": true
     },
@@ -137,7 +132,6 @@
     }
   },
   "devDependencies": {
-    "@better-auth/test-utils": "^1.7.6",
     "@electric-sql/pglite": "0.5.8",
     "@electric-sql/pglite-pgvector": "0.0.9",
     "@libsql/client": "^0.18.0",
@@ -152,7 +146,6 @@
     "@types/mssql": "^12.3.0",
     "@types/pg": "^8.23.1",
     "@types/ws": "^8.18.1",
-    "better-auth": "^1.7.6",
     "better-sqlite3": "^13.0.3",
     "express": "^5.2.1",
     "mariadb": "^3.5.4",

package/skills/uql-orm/SKILL.md

@@ -154,17 +154,10 @@ transaction. A querier from `pool.getQuerier()` is yours to release: bind it wit
 ## Migrations
 
 `npx uql-migrate` reads `uql.config.ts`. `sync` creates what the entities imply (development only);
-`generate:entities` writes the diff as a migration file to review; `up` applies migrations; `generate:from-db`
+`generate:entities` writes the diff as a migration file to review, renaming a column its field was renamed from and printing `renameTable` for a table that may have been; `up` applies migrations; `generate:from-db`
 writes entity classes from an existing database; `drift:check` fails when the database no longer matches.
 Triggers are part of the diff: uql installs its own under `_uql_`-prefixed names and never touches another.
 
-## Better Auth
-
-`betterAuth({ ...authOptions, database: uqlAdapter(pool) })`, from `uql-orm/betterAuth`, runs Better Auth on any
-pool; `...authEntities(authOptions)` in the config's `entities` has `uql-migrate` create its tables. Keep
-`authOptions` (plugins, table and field names, `rateLimit.storage`) in a module of its own, since the config imports
-it, and never put those entities in an HTTP handler's `include`: a session row holds its token.
-
 ## Where to read more
 
 - Operators, per-dialect SQL: https://uql-orm.dev/querying/comparison-operators.md
@@ -173,5 +166,4 @@ it, and never put those entities in an HTTP handler's `include`: a session row h
 - Triggers: https://uql-orm.dev/entities/triggers.md
 - Every method's signature: https://uql-orm.dev/querying/methods.md
 - Coming from Prisma, Drizzle, TypeORM or MikroORM: https://uql-orm.dev/switching-to-uql.md
-- Better Auth: https://uql-orm.dev/better-auth.md
 - Breaking changes by version: https://uql-orm.dev/upgrade-guide.md

package/dist/betterAuth/authEntities.d.ts

@@ -1,7 +0,0 @@
-import type { BetterAuthOptions } from 'better-auth';
-import type { Type } from '../type/index.js';
-/**
- * The entities Better Auth's tables are for these options, its core tables and every plugin's: list them
- * in `uql.config.ts` so `uql-migrate` creates and migrates them with the rest.
- */
-export declare function authEntities(options: BetterAuthOptions): Type<object>[];

package/dist/betterAuth/authEntities.js

@@ -1,154 +0,0 @@
-import { getAuthTables } from 'better-auth/db';
-import { defineEntity, defineField, defineId, defineIndex, defineRelation } from '../entity/index.js';
-import { UqlUsageError } from '../util/uqlError.js';
-/**
- * The entities Better Auth's tables are for these options, its core tables and every plugin's: list them
- * in `uql.config.ts` so `uql-migrate` creates and migrates them with the rest.
- */
-export function authEntities(options) {
-    const shapes = shapesOf(options);
-    // A field type that is a constructor keyed by its name, which JSON would drop.
-    const key = JSON.stringify(shapes, (_, value) => (typeof value === 'function' ? value.name : value));
-    let entities = defined.get(key);
-    if (!entities) {
-        entities = defineTables(shapes);
-        defined.set(key, entities);
-    }
-    return [...entities];
-}
-/**
- * Each set of tables defined so far, by its shapes: kept, since an adapter built on it may still be
- * reading, and a table defined twice for one shape would be two entities over one table.
- */
-const defined = new Map();
-/** Defines every table at once, since each one's foreign keys point at the others. */
-function defineTables(shapes) {
-    const byName = Object.fromEntries(shapes.map(({ name }) => [
-        name,
-        {
-            [name]: class {
-            },
-        }[name],
-    ]));
-    for (const { name, id, fields, indexes } of shapes) {
-        const entity = byName[name];
-        defineId(entity, 'id', id);
-        for (const field of fields) {
-            defineField(entity, field.name, field.options);
-            const { references } = field;
-            if (references) {
-                defineRelation(entity, `${field.name}Ref`, {
-                    entity: () => byName[references.table],
-                    cardinality: 'm1',
-                    references: (local, foreign) => [{ local: local[field.name], foreign: foreign[references.column] }],
-                    onDelete: references.onDelete,
-                });
-            }
-        }
-        for (const index of indexes) {
-            defineIndex(entity, { ...index, columns: (refs) => index.columns.map((column) => refs[column]) });
-        }
-        defineEntity(entity, { name });
-    }
-    return Object.values(byName);
-}
-/** Better Auth's schema as the tables UQL defines, every reference resolved to the column it points at. */
-function shapesOf(options) {
-    const schema = getAuthTables(options);
-    const id = keyOf(options);
-    const columnOf = (fields, key) => fields[key]?.fieldName ?? key;
-    // Refused rather than left for the schema build, which drops a foreign key whose column it cannot find.
-    const referenceOf = ({ model, field, onDelete = 'cascade' }) => {
-        const table = schema[model] ?? Object.values(schema).find(({ modelName }) => modelName === model);
-        const column = table?.fields[field];
-        if (!table || (field !== 'id' && !column)) {
-            throw new UqlUsageError(`a Better Auth field references '${model}.${field}', which its schema does not have`);
-        }
-        return {
-            // Every foreign key is indexed, so it takes the type an indexed copy of the column it points at would.
-            type: column ? typeOf({ ...column, index: true }) : id.type,
-            references: {
-                table: table.modelName,
-                column: column ? columnOf(table.fields, field) : 'id',
-                onDelete: ON_DELETE[onDelete],
-            },
-        };
-    };
-    return Object.values(schema).map((table) => ({
-        name: table.modelName,
-        id,
-        fields: Object.entries(table.fields).map(([key, field]) => {
-            const name = columnOf(table.fields, key);
-            const reference = field.references && referenceOf(field.references);
-            return {
-                name,
-                options: {
-                    name,
-                    type: reference?.type ?? typeOf(field),
-                    nullable: field.required === false,
-                    unique: field.unique,
-                    index: field.index,
-                    defaultValue: staticDefault(field),
-                },
-                references: reference?.references,
-            };
-        }),
-        indexes: (table.indexes ?? []).map(({ fields, unique, name }) => ({
-            columns: fields.map((key) => columnOf(table.fields, key)),
-            unique,
-            name,
-        })),
-    }));
-}
-/** The key: Better Auth's own string, its UUID, or the database's number; a key left to the database otherwise is refused. */
-function keyOf(options) {
-    const generateId = options.advanced?.database?.generateId;
-    if (generateId === false) {
-        throw new UqlUsageError("Better Auth's 'generateId: false' leaves the key to the database, which it can generate in more than one " +
-            "way: set 'serial' for a number or 'uuid' for a UUID");
-    }
-    if (generateId === 'serial') {
-        return { type: Number, autoIncrement: true };
-    }
-    return { type: generateId === 'uuid' ? 'uuid' : String };
-}
-/**
- * A field's column type. Text is `text` unless something indexes it, which a column of unbounded length
- * cannot be on MySQL; a list of allowed values is text too, since Better Auth checks them itself and a
- * database check on them would need a migration each time one is added.
- */
-function typeOf(field) {
-    const { type } = field;
-    if (type === 'string' || Array.isArray(type)) {
-        return field.unique || field.index || field.sortable ? String : 'text';
-    }
-    switch (type) {
-        case 'number':
-            return field.bigint ? BigInt : Number;
-        case 'boolean':
-            return Boolean;
-        case 'date':
-            return Date;
-        case 'json':
-        case 'string[]':
-        case 'number[]':
-            return 'json';
-    }
-}
-/**
- * The default a column takes in the database, as Better Auth's own migrator gives one: a plain value on a
- * text, number or boolean field, so a required column added to a populated table has one to backfill. A
- * nullable unique column gets none, `NULL` being its only backfill two rows can share.
- */
-function staticDefault({ type, defaultValue, unique, required }) {
-    const plain = typeof defaultValue === 'string' || typeof defaultValue === 'number' || typeof defaultValue === 'boolean';
-    const typed = type === 'string' || type === 'number' || type === 'boolean';
-    return plain && typed && !(unique && required === false) ? defaultValue : undefined;
-}
-const ON_DELETE = {
-    cascade: 'CASCADE',
-    'no action': 'NO ACTION',
-    restrict: 'RESTRICT',
-    'set null': 'SET NULL',
-    'set default': 'SET DEFAULT',
-};

package/dist/betterAuth/index.d.ts

@@ -1,2 +0,0 @@
-export * from './authEntities.js';
-export * from './uqlAdapter.js';

package/dist/betterAuth/index.js

@@ -1,2 +0,0 @@
-export * from './authEntities.js';
-export * from './uqlAdapter.js';

package/dist/betterAuth/uqlAdapter.d.ts

@@ -1,16 +0,0 @@
-import type { BetterAuthOptions } from 'better-auth';
-import { type DBAdapter, type DBAdapterDebugLogOption } from 'better-auth/adapters';
-import type { QuerierPool } from '../type/index.js';
-export type UqlAdapterOptions = {
-    readonly debugLogs?: DBAdapterDebugLogOption;
-    /**
-     * Whether Better Auth runs its multi-step writes in one transaction: on wherever the engine has them,
-     * so off on D1. A standalone MongoDB, which has them only as a replica set, needs `false`.
-     */
-    readonly transaction?: boolean;
-};
-/**
- * Better Auth on a UQL pool, on every engine UQL runs on: `betterAuth({ database: uqlAdapter(pool) })`.
- * Its tables are the entities {@link authEntities} returns, which `uql-migrate` creates like any other.
- */
-export declare function uqlAdapter(pool: QuerierPool, opts?: UqlAdapterOptions): (options: BetterAuthOptions) => DBAdapter<BetterAuthOptions>;

package/dist/betterAuth/uqlAdapter.js

@@ -1,155 +0,0 @@
-import { createAdapterFactory, } from 'better-auth/adapters';
-import { likeLiteral } from '../dialect/operators.js';
-import { getMeta, idOf } from '../entity/index.js';
-import { whereIds } from '../util/dialect.util.js';
-import { entityName } from '../util/object.util.js';
-import { UqlUsageError } from '../util/uqlError.js';
-import { authEntities } from './authEntities.js';
-/**
- * Better Auth on a UQL pool, on every engine UQL runs on: `betterAuth({ database: uqlAdapter(pool) })`.
- * Its tables are the entities {@link authEntities} returns, which `uql-migrate` creates like any other.
- */
-export function uqlAdapter(pool, opts = {}) {
-    const transactions = opts.transaction ?? pool.dialect.features.transactions;
-    return (options) => {
-        const entities = Object.fromEntries(authEntities(options).map((entity) => [entityName(getMeta(entity)), entity]));
-        const on = (querier, inTransaction) => createAdapterFactory({
-            config: {
-                adapterId: 'uql',
-                adapterName: 'UQL',
-                debugLogs: opts.debugLogs,
-                supportsJSON: true,
-                supportsDates: true,
-                supportsBooleans: true,
-                supportsNumericIds: true,
-                supportsArrays: true,
-                // The same adapter over the transaction's querier, as Better Auth's own adapters rebuild theirs.
-                transaction: transactions && !inTransaction ? (callback) => pool.transaction((trx) => callback(on(trx, true))) : false,
-            },
-            adapter: ({ getFieldName }) => methodsOf(querier, entities, getFieldName),
-        })(options);
-        return on(pool, false);
-    };
-}
-/**
- * Better Auth's database methods over `querier`, its tables by the names its factory checked each `model`
- * against. Only `where` arrives in database names; the rest are mapped here.
- */
-function methodsOf(querier, entities, getFieldName) {
-    const select = (model, fields) => fields?.length ? Object.fromEntries(fields.map((field) => [getFieldName({ model, field }), true])) : undefined;
-    const filter = (where) => ({ $where: whereOf(where) });
-    /**
-     * Writes `payload` to the first row `where` finds, pinned to that row while it still matches `where`,
-     * and reads it back: `null` where none matched, or a concurrent write moved the row past the guard first.
-     */
-    const updateOne = async (model, where, payload) => {
-        const entity = entities[model];
-        const row = await querier.findOne(entity, filter(where));
-        if (!row) {
-            return null;
-        }
-        const meta = getMeta(entity);
-        const id = idOf(meta, row);
-        const pinned = { $where: { $and: [whereOf(where), whereIds(meta, id)] } };
-        const changed = await querier.updateMany(entity, pinned, payload);
-        return changed ? asRow(await querier.findOneById(entity, id)) : null;
-    };
-    return {
-        async create({ model, data }) {
-            const entity = entities[model];
-            const id = await querier.insertOne(entity, data);
-            // The row as stored, which Better Auth's SQL adapters return too: a column left out reads its default.
-            const row = id === undefined ? undefined : await querier.findOneById(entity, id);
-            if (!row) {
-                throw new UqlUsageError(`Better Auth inserted a '${model}' row it cannot read back: does a filter hide it?`);
-            }
-            return asRow(row);
-        },
-        async findOne({ model, modelKey = model, where, select: fields }) {
-            return asRow(await querier.findOne(entities[model], { ...filter(where), $select: select(modelKey, fields) }));
-        },
-        async findMany({ model, modelKey = model, where = [], select: fields, sortBy, offset, limit }) {
-            const rows = await querier.findMany(entities[model], {
-                ...filter(where),
-                $select: select(modelKey, fields),
-                $sort: sortBy && { [getFieldName({ model: modelKey, field: sortBy.field })]: sortBy.direction },
-                $skip: offset,
-                $limit: limit,
-            });
-            return rows.map((row) => asRow(row));
-        },
-        count({ model, where = [] }) {
-            return querier.count(entities[model], filter(where));
-        },
-        update({ model, where, update }) {
-            return updateOne(model, where, payloadOf(update));
-        },
-        // `$inc` adds in the statement, so racing increments all land, where a read-then-write would retry.
-        incrementOne({ model, where, increment, set }) {
-            const steps = Object.fromEntries(Object.entries(increment).map(([field, $inc]) => [field, { $inc }]));
-            return updateOne(model, where, { ...set, ...steps });
-        },
-        updateMany({ model, where, update }) {
-            return querier.updateMany(entities[model], filter(where), update, { unfiltered: !where.length });
-        },
-        async delete({ model, where }) {
-            // Unlike `deleteMany`, never unfiltered: UQL refuses one naming no row.
-            await querier.deleteMany(entities[model], filter(where));
-        },
-        deleteMany({ model, where }) {
-            return querier.deleteMany(entities[model], filter(where), { unfiltered: !where.length });
-        },
-    };
-}
-/**
- * A row as the type Better Auth asks for, `null` for none: each method lets its caller name the shape of
- * its own table, which no query can check, so this is the one place UQL takes that on trust.
- */
-function asRow(row) {
-    return (row ?? null);
-}
-/** An update's payload, which Better Auth types as anything and always sends as a row of fields. */
-function payloadOf(update) {
-    if (typeof update !== 'object' || update === null) {
-        throw new UqlUsageError('Better Auth sent an update that is not a row of fields');
-    }
-    return update;
-}
-/**
- * Better Auth's clauses as one `$where`: all of those joined by `AND`, and any of those joined by `OR`.
- * Each clause is an entry of its own, since two on one field would overwrite each other in one map.
- */
-function whereOf(where) {
-    const all = where.filter((clause) => clause.connector === 'AND').map(clauseOf);
-    const any = where.filter((clause) => clause.connector === 'OR').map(clauseOf);
-    const $where = {};
-    if (all.length)
-        $where['$and'] = all;
-    if (any.length)
-        $where['$or'] = any;
-    return $where;
-}
-/** One clause; ignoring case applies where every value is text, as Better Auth's own adapters hold. */
-function clauseOf({ field, operator, value, mode }) {
-    const values = [value].flat();
-    const texts = mode === 'insensitive' && values.length && values.every((it) => typeof it === 'string') ? values : undefined;
-    return CLAUSES[operator](field, value, texts);
-}
-/** A literal case-insensitive match, which reads the same on every engine. */
-const ilike = (field, text) => ({ [field]: { $ilike: likeLiteral(text) } });
-/** An `in` list without `null`, which no `IN` matches and which makes every `NOT IN` match nothing. */
-const listOf = (value) => [value].flat().filter((it) => it !== null);
-/** Every Better Auth operator as the clause it is; `satisfies` fails the build on one it adds. */
-const CLAUSES = {
-    eq: (field, value, texts) => (texts ? ilike(field, texts[0]) : { [field]: { $eq: value } }),
-    ne: (field, value, texts) => (texts ? { $not: [ilike(field, texts[0])] } : { [field]: { $ne: value } }),
-    lt: (field, value) => ({ [field]: { $lt: value } }),
-    lte: (field, value) => ({ [field]: { $lte: value } }),
-    gt: (field, value) => ({ [field]: { $gt: value } }),
-    gte: (field, value) => ({ [field]: { $gte: value } }),
-    in: (field, value, texts) => texts ? { $or: texts.map((text) => ilike(field, text)) } : { [field]: { $in: listOf(value) } },
-    not_in: (field, value, texts) => texts ? { $nor: texts.map((text) => ilike(field, text)) } : { [field]: { $nin: listOf(value) } },
-    contains: (field, value, texts) => ({ [field]: { [texts ? '$iincludes' : '$includes']: value } }),
-    starts_with: (field, value, texts) => ({ [field]: { [texts ? '$istartsWith' : '$startsWith']: value } }),
-    ends_with: (field, value, texts) => ({ [field]: { [texts ? '$iendsWith' : '$endsWith']: value } }),
-};