uql-orm 0.64.0 → 0.65.0

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -20,6 +20,13 @@ export type LocalSqliteDatabase = {
     loadExtension(path: string): void;
     close(): unknown;
 };
+/**
+ * A `node:sqlite` or `bun:sqlite` handle as a {@link LocalSqliteDatabase}. Neither says whether a statement
+ * reads, so `reads` does: taken by `run()`, a RETURNING statement's rows would be lost, and its ids with them.
+ */
+export declare function adaptSqlite<S extends Omit<SqlitePreparedStatement, 'reader'>>(db: Omit<LocalSqliteDatabase, 'prepare'> & {
+    prepare(sql: string): S;
+}, reads: (stmt: S) => boolean): LocalSqliteDatabase;
 /**
  * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
  * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.

package/dist/sqlite/localSqliteQuerierPool.js

@@ -3,6 +3,25 @@ import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandle
 import { SqliteDialect } from './sqliteDialect.js';
 import { applySqlitePragmas } from './sqlitePragmas.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
+/**
+ * A `node:sqlite` or `bun:sqlite` handle as a {@link LocalSqliteDatabase}. Neither says whether a statement
+ * reads, so `reads` does: taken by `run()`, a RETURNING statement's rows would be lost, and its ids with them.
+ */
+export function adaptSqlite(db, reads) {
+    return {
+        prepare: (sql) => {
+            const stmt = db.prepare(sql);
+            return {
+                reader: reads(stmt),
+                all: (...values) => stmt.all(...values),
+                run: (...values) => stmt.run(...values),
+                iterate: (...values) => stmt.iterate(...values),
+            };
+        },
+        loadExtension: (path) => db.loadExtension(path),
+        close: () => db.close(),
+    };
+}
 /**
  * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
  * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.

package/dist/sqlite/nodeSqliteQuerierPool.js

@@ -1,5 +1,4 @@
-import { AbstractLocalSqliteQuerierPool, } from './localSqliteQuerierPool.js';
-import { adaptNodeSqlite } from './nodeSqliteAdapter.js';
+import { AbstractLocalSqliteQuerierPool, adaptSqlite, } from './localSqliteQuerierPool.js';
 /**
  * Pool backed by Node's built-in `node:sqlite`, so SQLite works with **no dependency at all** rather
  * than requiring the `better-sqlite3` native build. Use {@link Sqlite3QuerierPool} instead when you
@@ -25,6 +24,6 @@ export class NodeSqliteQuerierPool extends AbstractLocalSqliteQuerierPool {
             // `node:sqlite` refuses `loadExtension` unless the database was opened with this on.
             ...(extensions?.length ? { allowExtension: true } : undefined),
         });
-        return adaptNodeSqlite(nodeDb);
+        return adaptSqlite(nodeDb, (stmt) => stmt.columns().length > 0);
     }
 }

package/dist/sqlite/sqliteDialect.js

@@ -7,9 +7,6 @@ import { columnFamily, isIntegerColumn } from '../util/field.util.js';
 export class SqliteDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for SQLite and SQLite-derived dialects. */
     featureDefaults = {
-        explicitJsonCast: false,
-        nativeArrays: false,
-        supportsJsonb: false,
         ifNotExists: true,
         indexIfNotExists: true,
         schemas: false, // SQLite's namespaces are attached database files, not declared objects

package/dist/sqlite/sqliteQuerier.d.ts

@@ -1,9 +1,12 @@
 import type { ExtraOptions, RawRow } from '../type/index.js';
 import { AbstractSqliteQuerier, type SqliteBindValue } from './abstractSqliteQuerier.js';
 import type { SqliteDialect } from './sqliteDialect.js';
-/** What uql reads of a driver's `run()`: the row count. An inserted id comes back through `RETURNING`. */
+/**
+ * What uql reads of a driver's `run()`: the row count, which `node:sqlite` answers as a `bigint` once it
+ * reads integers as ones. An inserted id comes back through `RETURNING`.
+ */
 export type SqliteRunResult = {
-    changes: number;
+    changes: number | bigint;
 };
 /** A prepared statement with better-sqlite3 semantics, answering at once or with a promise. */
 export type SqlitePreparedStatement = {
@@ -15,7 +18,7 @@ export type SqlitePreparedStatement = {
 };
 /**
  * A SQLite driver that prepares statements. `better-sqlite3` and the embedded Turso engine satisfy it
- * as they are, `bun:sqlite` and `node:sqlite` through their adapters.
+ * as they are, `bun:sqlite` and `node:sqlite` through `adaptSqlite`.
  */
 export type SqliteDatabase = {
     prepare(sql: string): SqlitePreparedStatement | Promise<SqlitePreparedStatement>;
@@ -31,9 +34,9 @@ export declare class SqliteQuerier extends AbstractSqliteQuerier {
     readonly extra?: ExtraOptions | undefined;
     constructor(db: SqliteDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
     /** `reader` picks the call: `run()` would discard the rows of a statement that reads, RETURNING included. */
-    protected execute(query: string, values?: unknown[]): Promise<{
+    protected execute(query: string, values: SqliteBindValue[]): Promise<{
         rows: RawRow[];
         changes: number;
     }>;
-    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    protected iterate(query: string, values: SqliteBindValue[]): Promise<AsyncIterable<RawRow> | Iterable<RawRow>>;
 }

package/dist/sqlite/sqliteQuerier.js

@@ -1,4 +1,3 @@
-import { decodeBigInts } from '../util/wideNumber.js';
 import { AbstractSqliteQuerier } from './abstractSqliteQuerier.js';
 /**
  * Querier for the SQLite drivers that prepare statements: `better-sqlite3`, `bun:sqlite`, `node:sqlite`
@@ -16,20 +15,12 @@ export class SqliteQuerier extends AbstractSqliteQuerier {
     /** `reader` picks the call: `run()` would discard the rows of a statement that reads, RETURNING included. */
     async execute(query, values) {
         const stmt = await this.db.prepare(query);
-        const bound = toBindValues(values);
         if (stmt.reader) {
-            return { rows: (await stmt.all(...bound)), changes: 0 };
+            return { rows: (await stmt.all(...values)), changes: 0 };
         }
-        return { rows: [], changes: (await stmt.run(...bound)).changes };
+        return { rows: [], changes: Number((await stmt.run(...values)).changes) };
     }
-    async *internalStream(query, values) {
-        const stmt = await this.db.prepare(query);
-        for await (const row of stmt.iterate(...toBindValues(values))) {
-            yield decodeBigInts(row);
-        }
+    async iterate(query, values) {
+        return (await this.db.prepare(query)).iterate(...values);
     }
 }
-/** Bound parameters reach a driver as `unknown[]` from the compiler; every driver types them narrowly. */
-function toBindValues(values) {
-    return (values ?? []);
-}

package/dist/sqlite/sqliteQuerierPool.js

@@ -1,4 +1,4 @@
-import { AbstractLocalSqliteQuerierPool, } from './localSqliteQuerierPool.js';
+import { AbstractLocalSqliteQuerierPool, adaptSqlite, } from './localSqliteQuerierPool.js';
 /**
  * Pool for `better-sqlite3`, or `bun:sqlite` when running under Bun - the same file, through whichever
  * driver the runtime provides.
@@ -18,11 +18,11 @@ export class Sqlite3QuerierPool extends AbstractLocalSqliteQuerierPool {
         const { extensions, ...driverOpts } = this.opts ?? {};
         if (typeof Bun !== 'undefined') {
             const { Database } = await import('bun:sqlite');
-            const { adaptBunSqlite } = await import('./bunSqliteAdapter.bun.js');
             const bunOpts = { ...driverOpts, safeIntegers: true };
-            return adaptBunSqlite(typeof this.filename === 'string'
+            const bunDb = typeof this.filename === 'string'
                 ? new Database(this.filename, bunOpts)
-                : Database.deserialize(this.filename, bunOpts));
+                : Database.deserialize(this.filename, bunOpts);
+            return adaptSqlite(bunDb, (stmt) => stmt.columnNames.length > 0);
         }
         const { default: BetterSqlite3 } = await import('better-sqlite3');
         return new BetterSqlite3(this.filename, driverOpts).defaultSafeIntegers(true);

package/dist/turso/tursoSessionQuerier.d.ts

@@ -47,11 +47,11 @@ export declare class TursoSessionQuerier extends AbstractSqliteQuerier {
     readonly session: TursoSession;
     readonly extra?: ExtraOptions | undefined;
     constructor(session: TursoSession, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    protected execute(query: string, values?: unknown[]): Promise<{
+    protected execute(query: string, values: SqliteBindValue[]): Promise<{
         rows: RawRow[];
         changes: number;
     }>;
     /** Row by row off the statement's cursor, as the server steps it, each decoded as `execute` decodes one. */
-    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
+    protected iterate(query: string, values: SqliteBindValue[]): Promise<AsyncGenerator<RawRow, void, unknown>>;
     internalRelease(): Promise<void>;
 }

package/dist/turso/tursoSessionQuerier.js

@@ -1,5 +1,4 @@
 import { AbstractSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
-import { decodeBigInts } from '../util/wideNumber.js';
 /**
  * Querier for Turso Cloud on a session of its own.
  *
@@ -16,25 +15,28 @@ export class TursoSessionQuerier extends AbstractSqliteQuerier {
         this.extra = extra;
     }
     async execute(query, values) {
-        const { columns, rows, rowsAffected } = await this.session.execute(query, toBindValues(values), true);
+        const { columns, rows, rowsAffected } = await this.session.execute(query, values, true);
         return { rows: rows.map((row) => toRow(columns, row)), changes: rowsAffected };
     }
     /** Row by row off the statement's cursor, as the server steps it, each decoded as `execute` decodes one. */
-    async *internalStream(query, values) {
+    async iterate(query, values) {
         const { DatabaseError, decodeValue } = await import('@tursodatabase/serverless');
-        const { entries } = await this.session.executeRaw(query, toBindValues(values));
-        let columns = [];
-        for await (const entry of entries) {
-            if (entry.type === 'step_error' || entry.type === 'error') {
-                throw new DatabaseError(entry.error?.message ?? 'SQL execution failed', entry.error?.code);
-            }
-            if (entry.cols) {
-                columns = entry.cols.map(({ name }) => name);
-            }
-            if (entry.row) {
-                yield decodeBigInts(toRow(columns, entry.row.map((value) => decodeValue(value, true))));
+        const { entries } = await this.session.executeRaw(query, values);
+        async function* rows() {
+            let columns = [];
+            for await (const entry of entries) {
+                if (entry.type === 'step_error' || entry.type === 'error') {
+                    throw new DatabaseError(entry.error?.message ?? 'SQL execution failed', entry.error?.code);
+                }
+                if (entry.cols) {
+                    columns = entry.cols.map(({ name }) => name);
+                }
+                if (entry.row) {
+                    yield toRow(columns, entry.row.map((value) => decodeValue(value, true)));
+                }
             }
         }
+        return rows();
     }
     async internalRelease() {
         await this.session.close();
@@ -44,7 +46,3 @@ export class TursoSessionQuerier extends AbstractSqliteQuerier {
 function toRow(columns, values) {
     return Object.fromEntries(columns.map((column, at) => [column, values[at]]));
 }
-/** Bound parameters reach a driver as `unknown[]` from the compiler; a session binds them as they are. */
-function toBindValues(values) {
-    return (values ?? []);
-}

package/dist/type/dialect.d.ts

@@ -54,7 +54,8 @@ export type QueryContextOptions = {
     readonly inlineValues?: boolean;
 };
 /**
- * Capabilities of the database driver (transport layer).
+ * How a Postgres-wire driver binds a parameter, which is all its dialect's `driverCapabilities` option may
+ * change: what the engine has is the dialect's own to state.
  */
 export interface DriverCapabilities {
     /**
@@ -68,8 +69,6 @@ export interface DriverCapabilities {
      * `toPgArray` string literals instead.
      */
     readonly nativeArrays: boolean;
-    /** Whether the dialect natively supports the JSONB binary JSON type (Postgres/CockroachDB). */
-    readonly supportsJsonb: boolean;
 }
 /**
  * How a dialect surfaces the IDs generated by an INSERT statement:
@@ -77,14 +76,12 @@ export interface DriverCapabilities {
  *   or MongoDB's `insertedIds`), so IDs are exact for every row.
  * - `'firstId'`: the driver header only exposes the first generated ID (MySQL `insertId`);
  *   the remaining IDs are inferred by incrementing it.
- * - `'lastId'`: the driver header only exposes the last generated ID (SQLite `lastInsertRowid`);
- *   the remaining IDs are inferred backwards from it.
  */
-export type InsertIdSource = 'returning' | 'firstId' | 'lastId';
+export type InsertIdSource = 'returning' | 'firstId';
 /**
  * Features of the database engine (SQL syntax layer).
  */
-export interface EngineFeatures {
+export interface DialectFeatures {
     readonly ifNotExists: boolean;
     readonly indexIfNotExists: boolean;
     /**
@@ -110,7 +107,7 @@ export interface EngineFeatures {
      * A boolean rather than a mode: SQLite would accept a `VIRTUAL` column here, but emitting one where
      * the entity said `stored` makes the same entity a stored column on a new database and a virtual one
      * on an old, which nothing diffs and no one can see. Refusal has one form; only what UQL *emits*
-     * earns a mode, which is what makes {@link EngineFeatures.commentSyntax} three-way.
+     * earns a mode, which is what makes {@link DialectFeatures.commentSyntax} three-way.
      */
     readonly generatedColumnAdd: boolean;
     /**
@@ -145,19 +142,25 @@ export interface EngineFeatures {
     /** Whether the engine has unsigned integers, so `@Field({ unsigned: true })` reaches the column. */
     readonly supportsUnsigned: boolean;
     /**
-     * Whether the engine has SQL-level cursors (`DECLARE`/`FETCH FORWARD`/`CLOSE`), which is how a
-     * driver with no cursor API of its own still streams a result set instead of buffering it - see
-     * `postgres/pgCursorStream.ts`. True across the Postgres wire family, whose spelling that helper
-     * speaks; SQL Server and Oracle have cursors of their own but not this syntax.
-     *
-     * The node-`pg` family reports `true` and goes on using `pg-query-stream`: the flag says the engine
-     * has cursors, not that the driver needs them.
+     * Whether the engine has `DECLARE`/`FETCH FORWARD`/`CLOSE` cursors, which a querier with no stream of
+     * its own pages a read through (`querier/cursorStream.ts`) instead of reading it whole. The engine's
+     * answer, not the driver's: node-`pg` streams on its own and keeps doing so.
      */
     readonly serverSideCursors: boolean;
 }
-export interface DialectFeatures extends EngineFeatures, DriverCapabilities {
-}
-export interface QueryDialect {
+/**
+ * What a SQL statement is rendered through, as a `raw` callback and a query context see it:
+ * `AbstractSqlDialect` is the one implementation.
+ */
+export interface SqlQueryDialect {
+    /**
+     * The SQL dialect name.
+     */
+    readonly dialectName: SqlDialectName;
+    /**
+     * the escape character for identifiers.
+     */
+    readonly escapeIdChar: '"' | '`';
     /**
      * The dialect features.
      */
@@ -242,23 +245,6 @@ export interface QueryDialect {
      * The column a field of `meta` is stored in, named the way this dialect names columns.
      */
     columnOf<E>(meta: EntityMeta<E>, key: string): string;
-}
-/**
- * Supported SQL dialect identifiers.
- */
-export type SqlDialectName = 'postgres' | 'cockroachdb' | 'mysql' | 'mariadb' | 'sqlite' | 'mssql';
-/**
- * Minimal dialect interface exposing escapeIdChar for SQL operations
- */
-export interface SqlQueryDialect extends QueryDialect {
-    /**
-     * The SQL dialect name (postgres, mysql, mariadb, sqlite, mssql).
-     */
-    readonly dialectName: SqlDialectName;
-    /**
-     * the escape character for identifiers.
-     */
-    readonly escapeIdChar: '"' | '`';
     /**
      * Build an aggregate query.
      */
@@ -269,6 +255,10 @@ export interface SqlQueryDialect extends QueryDialect {
      */
     placeholder(index: number): string;
 }
+/**
+ * Supported SQL dialect identifiers.
+ */
+export type SqlDialectName = 'postgres' | 'cockroachdb' | 'mysql' | 'mariadb' | 'sqlite' | 'mssql';
 /**
  * An index capability that some engines have and others reject outright. Verified live: expression
  * indexes exist everywhere but MariaDB 12.3 (which needs a generated column); prefix lengths are

package/dist/type/entity.d.ts

@@ -481,23 +481,21 @@ export type FieldOptionsFor<V, E = unknown> = (FieldOptions<NonNullable<V>, E> &
  */
 export type RelationTarget<V> = Extract<Unpacked<V>, object>;
 /**
- * {@link RelationOptions} for a relation field declared as `V`, with `entity` required and pinned to
- * `V`'s own type, and the cardinality restricted to the ones that field shape can hold. Together those
- * reject `@ManyToOne({ entity: () => Other })` on a `Company` field, and any to-many cardinality on a
- * field that is not an array. A to-many additionally needs a {@link RelationJoin}.
- *
- * The join is required through the `cardinality` written rather than through `IsMany<V>`: a conditional
- * member of the intersection leaves a `mappedBy` callback without a contextual type inside a generic
- * call (`defineEntity`), where a union keyed on a property does not.
+ * {@link RelationOptions} for a relation field declared as `V`: what each cardinality's decorator takes,
+ * keyed on the `cardinality` written and restricted to the ones the field's shape holds. A key, not a
+ * conditional on `IsMany<V>`, which left a `mappedBy` callback untyped inside `defineEntity`.
  */
-export type RelationOptionsFor<V, O = unknown> = Omit<RelationOptions<RelationTarget<V>, O>, 'entity' | 'cardinality'> & {
-    readonly entity: EntityGetter<RelationTarget<V>>;
+export type RelationOptionsFor<V, O = unknown> = {
     readonly cardinality: IsMany<V> extends true ? '1m' | 'mm' : '11' | 'm1';
 } & (({
-    readonly cardinality: '1m' | 'mm';
-} & RelationJoin<RelationTarget<V>, O>) | {
-    readonly cardinality: '11' | 'm1';
-});
+    readonly cardinality: '11';
+} & RelationOneToOneOptions<RelationTarget<V>, O>) | ({
+    readonly cardinality: 'm1';
+} & RelationManyToOneOptions<RelationTarget<V>, O>) | ({
+    readonly cardinality: '1m';
+} & RelationOneToManyOptions<RelationTarget<V>, O>) | ({
+    readonly cardinality: 'mm';
+} & RelationManyToManyOptions<RelationTarget<V>, O>));
 /**
  * The method names of an entity, so hook registrations name a method that exists.
  */
@@ -540,17 +538,20 @@ export type RelationOptions<E, O = unknown> = {
      */
     through?: EntityGetter;
     /**
-     * The join columns where no convention fits: each pairs a field of the declaring entity with one of
-     * the target, `(order, customer) => [{ local: order.customerCode, foreign: customer.code }]`. A
-     * `through` relation takes none: its junction's columns follow the convention.
+     * The join columns: the foreign key a to-one declares, `(post) => post.authorId`, which points at the
+     * target's primary key, or pairs where no key fits, `(order, customer) => [{ local: order.customerCode,
+     * foreign: customer.code }]`. A `through` relation takes none: it joins by the junction's column
+     * referencing each side.
      */
-    references?: (local: KeyMap<O>, foreign: KeyMap<E>) => readonly RelationReference<O, E>[];
+    references?: (local: KeyMap<O>, foreign: KeyMap<E>) => FieldKey<O> | readonly RelationReference<O, E>[];
 };
 /** One pair of join columns, each a field read off its entity's key map. */
 export type RelationReference<O, E> = {
     readonly local: FieldKey<O>;
     readonly foreign: FieldKey<E>;
 };
+/** {@link RelationOptions.references} as pairs alone, for a to-many, which holds no foreign key of its own to name. */
+type RelationReferencePairs<E, O> = (local: KeyMap<O>, foreign: KeyMap<E>) => readonly RelationReference<O, E>[];
 /**
  * A relation once `getMeta` has resolved it: `references` is filled in and `mappedBy` is the key its
  * callback named. Consumers read this shape rather than {@link RelationOptions}, so they need no
@@ -562,28 +563,25 @@ export type RelationReference<O, E> = {
  * from "declared, but an inverse side too, so neither owns the foreign key" needs the unresolved shape
  * still there to find. A phase-split metadata map costs more than the call parentheses it saves.
  */
-export type RelationMeta = RelationRegistration & {
+export type RelationMeta = Omit<RelationRegistration, 'references'> & {
     references: RelationReferences;
 };
 /**
  * A relation as the registry takes it, whichever entity it targets: `mappedBy` and `references` read
- * off their key maps down to the names they give, `references` unset until `getMeta` settles it.
+ * off their key maps down to the names they give. `references` stays unset, or the one column a to-one
+ * names, until `getMeta` pairs it with the target's key, which registration may run before the target has.
  */
 export type RelationRegistration = Omit<RelationOptions<object>, 'mappedBy' | 'references'> & {
     mappedBy?: string;
-    references?: RelationReferences;
+    references?: RelationReferences | string;
 };
 /** How a to-many owner reaches its children: a junction entity or the join columns, never both. */
 type RelationOwnerJoin<E, O> = (Required<Pick<RelationOptions<E, O>, 'through'>> & {
     readonly references?: never;
-}) | (Required<Pick<RelationOptions<E, O>, 'references'>> & {
+}) | {
+    readonly references: RelationReferencePairs<E, O>;
     readonly through?: never;
-});
-/**
- * Every way a to-many can say where its rows are. Required because nothing about the field implies it:
- * without one of the three, resolution has no columns to join on and throws.
- */
-type RelationJoin<E, O> = RelationOwnerJoin<E, O> | Required<Pick<RelationOptions<E>, 'mappedBy'>>;
+};
 type RelationOptionsOwner<E, O> = Pick<RelationOptions<E, O>, 'entity' | 'references' | 'cascade' | 'onDelete' | 'onUpdate'>;
 type RelationOptionsInverseSide<E> = Pick<RelationOptions<E>, 'entity' | 'cascade'> & Required<Pick<RelationOptions<E>, 'mappedBy'>>;
 type RelationOptionsThroughOwner<E, O> = Pick<RelationOptions<E, O>, 'entity' | 'cascade'> & RelationOwnerJoin<E, O>;

package/dist/type/migratorDialect.d.ts

@@ -1,13 +1,4 @@
 import type { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
 import type { MongoDialect } from '../mongo/mongoDialect.js';
-import type { DialectName } from './querier.js';
 /** The dialects the migrator runs on, which `dialectName` tells apart: every SQL engine, and MongoDB. */
 export type MigratorDialect = AbstractSqlDialect | MongoDialect;
-declare const KNOWN_MIGRATOR_DIALECTS: readonly ["postgres", "cockroachdb", "mysql", "mariadb", "sqlite", "mssql", "mongodb"];
-export type KnownMigratorDialect = (typeof KNOWN_MIGRATOR_DIALECTS)[number];
-/**
- * Whether `d` is supported by built-in migrator introspection / schema generators.
- * Other `Dialect` values may still be valid on a pool but get no default generator.
- */
-export declare function isKnownMigratorDialect(d: DialectName): d is KnownMigratorDialect;
-export {};

package/dist/type/migratorDialect.js

@@ -1,16 +1 @@
-const KNOWN_MIGRATOR_DIALECTS = [
-    'postgres',
-    'cockroachdb',
-    'mysql',
-    'mariadb',
-    'sqlite',
-    'mssql',
-    'mongodb',
-];
-/**
- * Whether `d` is supported by built-in migrator introspection / schema generators.
- * Other `Dialect` values may still be valid on a pool but get no default generator.
- */
-export function isKnownMigratorDialect(d) {
-    return KNOWN_MIGRATOR_DIALECTS.includes(d);
-}
+export {};

package/dist/type/querierPool.d.ts

@@ -75,10 +75,6 @@ export interface QuerierPool<Q extends Querier = Querier, D extends AbstractDial
  */
 export interface SqlQuerierPool<Q extends SqlQuerier = SqlQuerier, D extends AbstractSqlDialect = AbstractSqlDialect> extends QuerierPool<Q, D>, Pick<SqlQuerier, 'all' | 'run'> {
 }
-/** Dialect class used by pool `P` (when `P` is a {@link QuerierPool}). */
-export type QuerierPoolDialect<P> = P extends QuerierPool<infer _Q, infer D> ? D : never;
-/** Querier type produced by pool `P`. */
-export type QuerierPoolQuerier<P> = P extends QuerierPool<infer Q, infer _D> ? Q : never;
 /**
  * Represents a high-compatibility SQL pool shim for Node.js integrations (e.g., express-session).
  */

package/dist/type/queryRaw.d.ts

@@ -1,9 +1,9 @@
-import type { QueryContext, QueryDialect } from './dialect.js';
+import type { QueryContext, SqlQueryDialect } from './dialect.js';
 import type { Type } from './utility.js';
 /** What a `raw` callback receives. See {@link QueryRawFn}. */
 export type QueryRawRenderOptions = {
     /** The dialect rendering the SQL. */
-    dialect: QueryDialect;
+    dialect: SqlQueryDialect;
     /** The alias of the table in scope, unescaped; empty where there is none. */
     prefix: string;
     /** {@link prefix} escaped, with its trailing dot. */

package/dist/type/universalQuerier.d.ts

@@ -122,8 +122,8 @@ export interface UniversalQuerier extends SharedQuerier<'server', QueryOptions>
      * dialect's bind-parameter limit) and return their IDs in payload order.
      *
      * Provided IDs and client-generated ones (`@Id({ onInsert })`) are always returned as-is.
-     * Database-generated IDs are exact on `'returning'` dialects (Postgres, MariaDB, MongoDB);
-     * on MySQL/SQLite they are inferred from the driver header, which is only reliable for
+     * Database-generated IDs are exact wherever the statement returns them, which is everywhere but
+     * MySQL: there they are inferred from the driver header, which is only reliable for
      * auto-increment keys in batches without explicit IDs - otherwise those entries are
      * `undefined` rather than potentially wrong values. A composite key is never one the statement
      * reports, so those rows are named as written, `onInsert` columns included.

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The 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.64.0",
+  "version": "0.65.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -23,13 +23,11 @@
     "./entity": "./dist/entity/index.js",
     "./querier": "./dist/querier/index.js",
     "./type": "./dist/type/index.js",
-    "./type/migratorDialect": "./dist/type/migratorDialect.js",
     "./util": "./dist/util/index.js",
     "./namingStrategy": "./dist/namingStrategy/index.js",
     "./migrate": "./dist/migrate/index.js",
     "./mysql": "./dist/mysql/index.js",
     "./postgres": "./dist/postgres/index.js",
-    "./postgres/wireCapabilities": "./dist/postgres/postgresWireDriverCapabilities.js",
     "./cockroachdb": "./dist/cockroachdb/index.js",
     "./maria": "./dist/maria/index.js",
     "./sqlite": "./dist/sqlite/index.js",

package/dist/postgres/pgCursorStream.d.ts

@@ -1,20 +0,0 @@
-/**
- * Runs one statement of the cursor protocol. `internalAll` for every caller so far: the cursor holds
- * a connection's session state, so it must be the querier's own connection, and it must not go
- * through `all()`, whose `serialize` is not re-entrant.
- */
-export type CursorExecutor<T> = (query: string, values?: unknown[]) => Promise<T[]>;
-/**
- * Stream a Postgres-wire result through a server-side cursor, for a driver whose client exposes none:
- * `bun:sql` (no cursor API at all, [oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181))
- * and PGlite. `pg` has `pg-query-stream` and keeps using it.
- *
- * `DECLARE` is only legal inside a transaction, so one is opened here when the caller has none - and
- * then committed, or rolled back if the stream failed. That `BEGIN` goes straight to the connection
- * rather than through `beginTransaction`, so the querier's own transaction state stays untouched:
- * this one is the generator's, and ends with it.
- *
- * The cleanup lives in `finally` because a consumer that stops early (`break`, a `throw` downstream)
- * ends the generator there and nowhere else, and an abandoned cursor holds its transaction open.
- */
-export declare function streamViaCursor<T>(exec: CursorExecutor<T>, query: string, values?: unknown[], inTransaction?: boolean): AsyncIterable<T>;

package/dist/postgres/postgresWireDriverCapabilities.d.ts

@@ -1,21 +0,0 @@
-/**
- * Driver-shaped parameter handling for **Bun SQL** (and any client like it) on a Postgres-wire
- * dialect: arrays go as string literals (`nativeArrays: false`, {@link PgLikeSqlDialect}'s `toPgArray`
- * path) and a JSON bind is re-cast through text (`explicitJsonCast: true`). Both are measured, on a
- * live server: `bun:sql` binds neither `sql.array(...)` nor a plain JS array through `unsafe()`
- * (verified again on Bun 1.4.2), and without the text re-cast a `$set`/`$push` on a JSONB column
- * silently writes the wrong value or throws - on Postgres and, identically, on CockroachDB, which
- * `bun:sql` reaches through its own Postgres wire implementation.
- *
- * The pair is one constant because it is one driver's shape, and `BunSqlQuerierPool` hands it to
- * `PostgresDialect`/`CockroachDialect` as their `driverCapabilities` rather than subclassing either:
- * Bun changes how a parameter binds, never the SQL. `PgQuerierPool` uses neither, keeping the base
- * {@link PgLikeSqlDialect} defaults, since node-`pg` needs no fix.
- *
- * @remarks Optional import for custom pools. Neon uses its own serverless driver (not `bun:sql`),
- * so `NeonQuerierPool` is a separate, unverified case - do not assume it needs this without testing.
- */
-export declare const POSTGRES_WIRE_DRIVER_CAPABILITIES: {
-    readonly nativeArrays: false;
-    readonly explicitJsonCast: true;
-};

package/dist/postgres/postgresWireDriverCapabilities.js

@@ -1,21 +0,0 @@
-/**
- * Driver-shaped parameter handling for **Bun SQL** (and any client like it) on a Postgres-wire
- * dialect: arrays go as string literals (`nativeArrays: false`, {@link PgLikeSqlDialect}'s `toPgArray`
- * path) and a JSON bind is re-cast through text (`explicitJsonCast: true`). Both are measured, on a
- * live server: `bun:sql` binds neither `sql.array(...)` nor a plain JS array through `unsafe()`
- * (verified again on Bun 1.4.2), and without the text re-cast a `$set`/`$push` on a JSONB column
- * silently writes the wrong value or throws - on Postgres and, identically, on CockroachDB, which
- * `bun:sql` reaches through its own Postgres wire implementation.
- *
- * The pair is one constant because it is one driver's shape, and `BunSqlQuerierPool` hands it to
- * `PostgresDialect`/`CockroachDialect` as their `driverCapabilities` rather than subclassing either:
- * Bun changes how a parameter binds, never the SQL. `PgQuerierPool` uses neither, keeping the base
- * {@link PgLikeSqlDialect} defaults, since node-`pg` needs no fix.
- *
- * @remarks Optional import for custom pools. Neon uses its own serverless driver (not `bun:sql`),
- * so `NeonQuerierPool` is a separate, unverified case - do not assume it needs this without testing.
- */
-export const POSTGRES_WIRE_DRIVER_CAPABILITIES = {
-    nativeArrays: false,
-    explicitJsonCast: true,
-};

package/dist/sqlite/bunSqliteAdapter.bun.d.ts

@@ -1,27 +0,0 @@
-import type { SqliteBindValue } from './abstractSqliteQuerier.js';
-import type { LocalSqliteDatabase } from './localSqliteQuerierPool.js';
-import type { SqliteRunResult } from './sqliteQuerier.js';
-/** A `bun:sqlite` statement: better-sqlite3-shaped, except it reports columns instead of `reader`. */
-type BunStatement = {
-    columnNames: string[];
-    all(...values: SqliteBindValue[]): unknown[];
-    run(...values: SqliteBindValue[]): SqliteRunResult;
-    iterate(...values: SqliteBindValue[]): Iterable<unknown>;
-};
-type BunDatabase = {
-    prepare(sql: string): BunStatement;
-    loadExtension(path: string): void;
-    close(): unknown;
-};
-/**
- * Presents a `bun:sqlite` handle as a {@link LocalSqliteDatabase}.
- *
- * @remarks Its statements expose no `reader`, so without deriving one every `RETURNING` statement
- * would take the `run()` path, which discards returned rows, and inserts would report no ids.
- * `columnNames` is non-empty for exactly the statements better-sqlite3 marks as readers.
- *
- * Lives in a `.bun.ts` file because it only ever executes under Bun: the Node coverage run cannot
- * reach it, and `sqliteQuerier.bun.test.ts` covers it under `test:bun` instead.
- */
-export declare function adaptBunSqlite(db: BunDatabase): LocalSqliteDatabase;
-export {};