uql-orm 0.62.0 → 0.64.0

package/dist/type/entity.d.ts

@@ -1,6 +1,6 @@
 import type { EnumValues, ForeignKeyAction, IndexType } from '../schema/types.js';
 import type { FilterOptions } from './query.js';
-import type { QueryRaw } from './queryRaw.js';
+import type { ColumnRef, QueryRaw } from './queryRaw.js';
 import type { QueryWhere } from './queryWhere.js';
 import type { Except, IsMany, Json, Scalar, Type, Unpacked } from './utility.js';
 import type { VectorDistance, VectorIndexOptions, VectorIndexType } from './vector.js';
@@ -595,14 +595,6 @@ type RelationOptionsThroughOwner<E, O> = Pick<RelationOptions<E, O>, 'entity' |
 export type KeyMap<E> = {
     readonly [K in keyof E]-?: K;
 };
-declare const COLUMN_KEY: unique symbol;
-/**
- * A field of an entity as SQL, read off a {@link RefMap}: interpolated into `raw`, it renders as that
- * field's column. A `QueryRaw` like any other fragment, branded with the field `K` it names.
- */
-export type ColumnRef<K extends string = string> = QueryRaw & {
-    readonly [COLUMN_KEY]?: K;
-};
 /**
  * The fields of `E` as {@link ColumnRef}s, for SQL that names them: `refs(User)` in a statement, the
  * callback's parameter in a definition. Keyed over a type parameter constrained to `keyof E`, as
@@ -612,15 +604,13 @@ export type RefMap<E, F extends keyof E = FieldKey<E>> = {
     readonly [K in F]-?: ColumnRef<K & string>;
 };
 /**
- * A callback reading an entity's fields off a {@link RefMap} for the SQL it returns. Declared as a
- * method, bivariant in its refs, so one typed for its entity still fits where the entity is erased: the
- * registry, which resolves it.
+ * SQL a definition writes: `raw`, or a callback reading the entity's fields off its refs. The callback is
+ * declared as a method, bivariant in its refs, so one typed for its entity still fits where the entity is
+ * erased: the registry, which resolves it.
  */
-export type SqlCallback<E> = {
-    sql(row: RefMap<E>): QueryRaw;
+export type EntitySql<E> = QueryRaw | {
+    sql(refs: RefMap<E>): QueryRaw;
 }['sql'];
-/** SQL a definition writes: `raw`, or a {@link SqlCallback} for SQL that names the entity's fields. */
-export type EntitySql<E> = QueryRaw | SqlCallback<E>;
 /**
  * A predicate DDL carries, over the entity's own fields: a relation, full-text search and a sub-query
  * have nothing a `CHECK` or a partial index can hold. An intersection rather than `Except`, which would
@@ -677,41 +667,24 @@ export type IndexTypeOptions = {
     distance?: never;
 };
 /**
- * One entry of an index: a column by default, a {@link SqlCallback} to index an expression, or an object
- * when the entry needs more than that.
- *
- * @example
- * ```ts
- * @Index((post) => [post.tenantId, { column: post.createdAt, order: 'desc' }]) // keyset pagination
- * @Index(() => [(post) => raw`lower(${post.email})`], { unique: true })       // case-insensitive uniqueness
- * @Index((post) => [{ column: post.body, length: 64 }])                       // MySQL needs a prefix on TEXT
- * @Index((post) => [post.data], { type: 'gin' })                              // JSONB containment
- * ```
- *
- * `C` is the entity's `FieldKey` on the `@Index`/`defineEntity` paths, where the decorated class says
- * which columns exist, and `E` the entity itself, which is what checks a JSON entry's path. Both
- * default to the unchecked form for the migration builder's `table.index(...)`, which names raw
- * table columns with no entity in scope.
- */
-export type IndexColumnInput<C extends string = string, E = unknown> = C | SqlCallback<E> | IndexColumnOptions<C, E> | IndexJsonColumnOptions<C, E>;
-/**
- * The JSON entries, whose `path` is checked against the payload of the column the same entry names -
- * a mapped union, one arm per JSON field, so `{ column: 'kind', jsonPath: { path: 'thema.color' } }`
- * cannot compile. It matters more here than anywhere else in the index API: a path that is merely
- * *misspelled* still builds a perfectly valid index, one no query will ever match, and nothing at
- * runtime can tell that from the index you meant.
- *
- * `jsonArray`'s path is the array's own, so on a column that *is* the array (`Json<string[]>`) it
- * resolves to `never` and the property can only be omitted, which is exactly the truth.
- *
- * Falls back to the unchecked shape only where there is no entity to check against - the migration
- * builder. An entity with no JSON field at all offers no arm, which is also the truth.
+ * One index entry as the migration builder takes it: a column name, `raw` for an expression, or an object
+ * when the entry needs more. An entity's entries are this too, which is what `normalizeIndexColumn` reads.
+ */
+export type IndexColumnInput = string | QueryRaw | EntityIndexColumn;
+/**
+ * One entry of an entity's index, read off its refs: a column, `raw` for an expression, or an object when
+ * the entry needs more, a JSON entry's path checked against its column.
+ * @example `@Index((post) => [post.tenantId, { column: post.createdAt, order: 'desc' }, raw`lower(${post.email})`])`
  */
-type IndexJsonColumnOptions<C extends string, E> = unknown extends E ? IndexColumnModifiers & {
-    readonly column: C;
-} : {
+export type EntityIndexColumnInput<E> = QueryRaw | IndexColumnOptions | IndexJsonColumnOptions<E>;
+/**
+ * The JSON entries, one arm per JSON field, each `path` checked against the payload of the column its own
+ * entry names: a misspelled path still builds a valid index that no query matches. On a column that is
+ * the array (`Json<string[]>`), `jsonArray`'s path resolves to `never`, so it can only be omitted.
+ */
+type IndexJsonColumnOptions<E> = {
     [K in JsonColumnKey<E>]: IndexColumnPlainModifiers & {
-        readonly column: K;
+        readonly column: ColumnRef<K & string>;
     } & ({
         readonly jsonPath: WithCheckedPath<IndexJsonPath, E, K>;
         readonly jsonArray?: never;
@@ -727,7 +700,7 @@ type IndexJsonColumnOptions<C extends string, E> = unknown extends E ? IndexColu
  * subject is that column.
  */
 type JsonColumnKey<E> = {
-    readonly [K in keyof E]-?: IsJson<NonNullable<E[K]>> extends true ? K : IsJson<JsonElement<E[K]>> extends true ? K : never;
+    readonly [K in keyof E]-?: IsJsonColumn<NonNullable<E[K]>> extends true ? K : never;
 }[Key<E>];
 /** The payload a path is checked against: the column's own brand, or that of the documents it holds. */
 type JsonColumnPayload<V> = IsJson<NonNullable<V>> extends true ? UnwrapJson<NonNullable<V>> : JsonPayload<V>;
@@ -807,15 +780,19 @@ export type IndexJsonArray = {
 };
 /** The modifiers that do not name a JSON path, and so need no entity to be checked against. */
 type IndexColumnPlainModifiers = Except<IndexColumnModifiers, 'jsonPath' | 'jsonArray'>;
-export type IndexColumnOptions<C extends string = string, E = unknown> = IndexColumnPlainModifiers & {
-    /** The column to index, or a {@link SqlCallback} for an expression. */
-    readonly column: C | SqlCallback<E>;
+/**
+ * An entity's entry with plain modifiers. `jsonPath` and `jsonArray` are `never` here, since a JSON entry
+ * would otherwise match this shape too, its path unchecked.
+ */
+type IndexColumnOptions = IndexColumnPlainModifiers & {
+    /** A column read off the refs, or `raw` for an expression. */
+    readonly column: QueryRaw;
     readonly jsonPath?: never;
     readonly jsonArray?: never;
 };
 /**
- * One index entry, normalized: {@link IndexColumnInput}'s three authored shapes all reduce to this
- * before any dialect or generator sees them, so rendering never re-parses the sugar.
+ * One index entry, normalized: every authored shape reduces to this before any dialect or generator sees
+ * it, so rendering never re-parses the sugar.
  */
 export type IndexColumnSchema = IndexColumnModifiers & {
     /** A column name, or raw SQL when {@link expression} is set. */
@@ -967,27 +944,25 @@ export type EntityOptions<E = unknown> = {
  * and through {@link EntityIndexOptions} `@Index` and `defineEntity`. `Except` (not plain `Omit`) keeps
  * `type`/`distance` a discriminated pair: omitting `distance` on a vector index type is a compile error.
  */
-export type IndexOptions = Except<EntityIndexMeta, 'columns' | 'include' | 'where'> & {
-    /** Non-key columns stored in the index, by column name; a typo builds nothing, the server refusing it. */
-    readonly include?: readonly string[];
+export type IndexOptions = Except<EntityIndexMeta, 'columns' | 'where'> & {
     /** Partial-index predicate, as `raw` with no interpolation: the migration builder has no entity to compile one against. */
     readonly where?: QueryRaw;
 };
 /**
- * {@link IndexOptions} on an entity, whose stored columns are read off its key map, `(post) => [post.slug]`,
+ * {@link IndexOptions} on an entity, whose stored columns are read off its refs, `(post) => [post.slug]`,
  * so they are checked against it and follow a rename. The migration builder names raw columns instead.
  */
 export type EntityIndexOptions<E> = Except<IndexOptions, 'include' | 'where'> & {
-    readonly include?: (keys: KeyMap<E>) => readonly FieldKey<E>[];
+    readonly include?: (refs: RefMap<E>) => readonly ColumnRef<FieldKey<E>>[];
     /** Partial-index predicate. See {@link EntityWhere}. */
     readonly where?: EntityWhere<E>;
 };
 /**
- * An index as authored on an entity, before `defineIndex` reads its columns off the key map. Only the
+ * An index as authored on an entity, before `defineIndex` reads its columns off the refs. Only the
  * member lists are callbacks: TypeScript never checks a callback's returned literal for excess properties,
  * so the options stay a literal of their own, where `uniqe: true` is a compile error.
  */
 export type EntityIndexInput<E> = EntityIndexOptions<E> & {
-    readonly columns: (keys: KeyMap<E>) => readonly IndexColumnInput<FieldKey<E>, E>[];
+    readonly columns: (refs: RefMap<E>) => readonly EntityIndexColumnInput<E>[];
 };
 export {};

package/dist/type/migration.d.ts

@@ -1,8 +1,8 @@
 import type { VectorCast } from '../dialect/vectorCast.js';
-import type { FullColumnDefinition, IndexDefinition, TableDefinition } from '../migrate/builder/types.js';
+import type { AnyMigrationOperation } from '../migrate/builder/types.js';
 import type { IndexFacet } from '../schema/indexDifferences.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
-import type { ColumnNode, ForeignKeyAction, IndexNode, IndexType, TableNode } from '../schema/types.js';
+import type { ColumnNode, ForeignKeyAction, IndexType, TableNode } from '../schema/types.js';
 import type { EntityMeta, EntityWhereMeta, FieldOptions, IndexColumnSchema, LoggingOptions, Querier, SqlQuerier, Type, VectorIndexOptions } from './index.js';
 /**
  * Defines a migration using a simple object literal. `Q` is `MongoQuerier` for a MongoDB migration.
@@ -148,7 +148,7 @@ export interface IndexSchema extends VectorIndexOptions {
     readonly unique: boolean;
     /** Index type (btree, hnsw, ivfflat, etc.) */
     readonly type?: IndexType;
-    /** Partial index condition (WHERE clause) */
+    /** Partial index predicate as its engine writes it: SQL, or on MongoDB the JSON of its filter document. */
     readonly where?: string;
     /** Non-key columns stored in the index (Postgres-wire `INCLUDE`). */
     readonly include?: readonly string[];
@@ -292,14 +292,20 @@ export interface SchemaGenerator {
      */
     generateDropIndex(tableName: string, indexName: string): string;
     /**
-     * Get the SQL type for a field based on its options
+     * The statements one migration builder operation runs as, one string each. An operation the engine
+     * has no form for throws: MongoDB has no columns, constraints or SQL.
      */
-    getSqlType(fieldOptions: FieldOptions): string;
+    generateOperation(operation: AnyMigrationOperation): string[];
     /**
      * The text of SQL an entity declares - a check, a stored computed column, an index expression or
      * predicate - rendered for this engine, which is what building an entity's schema needs from it.
      */
     compileDdl(sql: EntityWhereMeta<object>, entity: Type<object>): string;
+    /**
+     * A partial index's `$where` as this engine writes it into {@link IndexSchema.where}, refused where its
+     * index takes less of a predicate than a query does: SQL Server's filter has no `OR`.
+     */
+    compileIndexPredicate(where: EntityWhereMeta<object>, entity: Type<object>, indexName: string): string;
     /**
      * Compare an entity with a database table node and return the differences.
      *
@@ -333,41 +339,6 @@ export interface SchemaGenerator {
      * Resolve column name using field options and naming strategy
      */
     resolveColumnName(key: string, field: FieldOptions): string;
-    /** DDL from a `TableNode`, one string per `querier.run`. */
-    generateCreateTableFromNode(table: TableNode, options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    /** Generate CREATE INDEX statement from an IndexNode */
-    generateCreateIndexFromNode(index: IndexNode, options?: {
-        ifNotExists?: boolean;
-    }): string;
-    /** DDL from a `TableDefinition`, one string per `querier.run`. */
-    generateCreateTableFromDefinition(table: TableDefinition, options?: {
-        ifNotExists?: boolean;
-    }): string[];
-    /** Generate RENAME TABLE statement */
-    generateRenameTableSql(oldName: string, newName: string): string;
-}
-/**
- * The column and constraint DDL a migration builder emits, which only a SQL engine has. Split from
- * {@link SchemaGenerator} because MongoDB used to satisfy these six by returning `''`: a document store
- * has no `ADD COLUMN`, and an empty statement silently did nothing rather than saying so.
- */
-export interface SqlDdlGenerator extends SchemaGenerator {
-    /** Generate ADD COLUMN statement */
-    generateAddColumnSql(tableName: string, column: FullColumnDefinition): string;
-    /** Generate ALTER COLUMN statement */
-    generateAlterColumnSql(tableName: string, columnName: string, column: FullColumnDefinition): string;
-    /** Generate DROP COLUMN statement */
-    generateDropColumnSql(tableName: string, columnName: string): string;
-    /** Generate RENAME COLUMN statement */
-    generateRenameColumnSql(tableName: string, oldName: string, newName: string): string;
-    /** Generate ADD FOREIGN KEY statement */
-    generateAddForeignKeySql(tableName: string, foreignKey: ForeignKeySchema): string;
-    /** Generate DROP FOREIGN KEY statement */
-    generateDropForeignKeySql(tableName: string, constraintName: string): string;
-    /** CREATE INDEX from a builder's {@link IndexDefinition}, its SQL rendered for this engine. */
-    generateCreateIndexFromDefinition(tableName: string, index: IndexDefinition): string;
 }
 /**
  * Interface for introspecting the current database schema

package/dist/type/queryRaw.d.ts

@@ -43,3 +43,11 @@ export declare class QueryRaw {
      */
     render(opts: QueryRawRenderOptions): void;
 }
+/**
+ * A field of an entity as SQL, read off `refs(Entity)` or a definition's refs: interpolated into `raw`, it
+ * renders as the field's column. Its `key` is how an index tells a column from an expression.
+ */
+export declare class ColumnRef<K extends string = string> extends QueryRaw {
+    readonly key: K;
+    constructor(key: K, value: QueryRawFn);
+}

package/dist/type/queryRaw.js

@@ -26,3 +26,14 @@ export class QueryRaw {
         }
     }
 }
+/**
+ * A field of an entity as SQL, read off `refs(Entity)` or a definition's refs: interpolated into `raw`, it
+ * renders as the field's column. Its `key` is how an index tells a column from an expression.
+ */
+export class ColumnRef extends QueryRaw {
+    key;
+    constructor(key, value) {
+        super(value);
+        this.key = key;
+    }
+}

package/dist/util/ddlExpression.util.d.ts

@@ -1,9 +1,11 @@
-import { type EntityIndexColumn, type IndexColumnInput, type IndexColumnSchema, QueryRaw } from '../type/index.js';
+import { type EntityIndexColumn, type EntityIndexMeta, type EntityMeta, type IndexColumnInput, type IndexColumnSchema, QueryRaw } from '../type/index.js';
 /**
- * Reduces an authored index entry to the form metadata keeps, so the shapes users write - a column
- * name, an expression's callback, an options object - reach the schema as one, each callback resolved.
+ * Reduces an authored index entry to the form metadata keeps, so a column, an expression and an options
+ * object reach the schema as one: a column read off the refs as its key, any other `raw` as it is.
  */
 export declare function normalizeIndexColumn(entry: IndexColumnInput): EntityIndexColumn;
+/** Every index an entity declares: each `@Field({ index })` as the one-column `@Index` it is, then its `@Index`es. */
+export declare function declaredIndexes<E>(meta: EntityMeta<E>): EntityIndexMeta<E>[];
 /** An index entry as the schema holds it, its expression rendered to text by `render`. */
 export declare function renderIndexColumn(entry: EntityIndexColumn, render: (sql: QueryRaw) => string): IndexColumnSchema;
 /** What an unnamed index's name is built from: each entry's column, or `expr<n>` for an expression, which has none. */

package/dist/util/ddlExpression.util.js

@@ -1,18 +1,25 @@
-import { QueryRaw } from '../type/index.js';
-import { entitySql } from './raw.js';
+import { ColumnRef, QueryRaw, } from '../type/index.js';
+import { definedEntries } from './object.util.js';
 /**
- * Reduces an authored index entry to the form metadata keeps, so the shapes users write - a column
- * name, an expression's callback, an options object - reach the schema as one, each callback resolved.
+ * Reduces an authored index entry to the form metadata keeps, so a column, an expression and an options
+ * object reach the schema as one: a column read off the refs as its key, any other `raw` as it is.
  */
 export function normalizeIndexColumn(entry) {
-    if (typeof entry === 'string') {
-        return { column: entry };
-    }
-    if (typeof entry === 'function') {
-        return { column: entitySql(entry) };
-    }
-    const { column } = entry;
-    return { ...entry, column: typeof column === 'function' ? entitySql(column) : column };
+    const { column, ...modifiers } = typeof entry === 'string' || entry instanceof QueryRaw ? { column: entry } : entry;
+    return { ...modifiers, column: column instanceof ColumnRef ? column.key : column };
+}
+/** Every index an entity declares: each `@Field({ index })` as the one-column `@Index` it is, then its `@Index`es. */
+export function declaredIndexes(meta) {
+    const fieldIndexes = definedEntries(meta.fields).flatMap(([key, field]) => field.index
+        ? [
+            {
+                columns: [{ column: key }],
+                name: typeof field.index === 'string' ? field.index : undefined,
+                unique: field.unique,
+            },
+        ]
+        : []);
+    return [...fieldIndexes, ...(meta.indexes ?? [])];
 }
 /** An index entry as the schema holds it, its expression rendered to text by `render`. */
 export function renderIndexColumn(entry, render) {

package/dist/util/raw.d.ts

@@ -32,7 +32,12 @@ export declare function raw(value: QueryRawFn): QueryRaw;
  * in scope. Metadata is read when a ref renders, so the map serves before the fields are registered.
  */
 export declare function refs<E>(entity: Type<E>): RefMap<E>;
-/** SQL a definition writes, a callback's refs read off {@link MEMBER_REFS}. */
+/**
+ * The refs a definition's callbacks read: an index's, a check's, a computed field's. A member decorator
+ * sees no class, so these name no entity and resolve against the one rendering them.
+ */
+export declare function memberRefs<E>(): RefMap<E>;
+/** SQL a definition writes, a callback's refs read off {@link memberRefs}. */
 export declare function entitySql<E>(sql: EntitySql<E>): QueryRaw;
 /** A definition's predicate, its callback resolved the way {@link entitySql} resolves one. */
 export declare function entityWhere<E>(where: EntityWhere<E>): EntityWhereMeta<E>;

package/dist/util/raw.js

@@ -1,5 +1,5 @@
 import { getMeta } from '../entity/metadata/definition.js';
-import { QueryRaw, } from '../type/index.js';
+import { ColumnRef, QueryRaw, } from '../type/index.js';
 import { isInlinedExpression } from './field.util.js';
 export function raw(value, ...rest) {
     if (!isTemplateStrings(value)) {
@@ -27,22 +27,25 @@ export function raw(value, ...rest) {
 export function refs(entity) {
     return new Proxy({}, { get: (_, key) => columnRef(entity, String(key)) });
 }
+const MEMBER_REFS = new Proxy({}, { get: (_, key) => columnRef(undefined, String(key)) });
 /**
- * The refs a definition's callback reads. A member decorator sees no class, so these name no entity and
- * resolve against the one rendering them: a computed field's own, or the one whose schema is built.
+ * The refs a definition's callbacks read: an index's, a check's, a computed field's. A member decorator
+ * sees no class, so these name no entity and resolve against the one rendering them.
  */
-const MEMBER_REFS = new Proxy({}, { get: (_, key) => columnRef(undefined, String(key)) });
-/** SQL a definition writes, a callback's refs read off {@link MEMBER_REFS}. */
+export function memberRefs() {
+    return MEMBER_REFS;
+}
+/** SQL a definition writes, a callback's refs read off {@link memberRefs}. */
 export function entitySql(sql) {
-    return sql instanceof QueryRaw ? sql : sql(MEMBER_REFS);
+    return sql instanceof QueryRaw ? sql : sql(memberRefs());
 }
 /** A definition's predicate, its callback resolved the way {@link entitySql} resolves one. */
 export function entityWhere(where) {
-    return typeof where === 'function' ? where(MEMBER_REFS) : where;
+    return typeof where === 'function' ? where(memberRefs()) : where;
 }
 /** One field as SQL, against its own entity or, read off a definition, the entity rendering it. */
 function columnRef(entity, key) {
-    return new QueryRaw((opts) => {
+    return new ColumnRef(key, (opts) => {
         const owner = entity ?? opts.entity;
         if (!owner) {
             throw new TypeError(`'${key}' was read off a definition's refs, so it renders only inside its entity's SQL`);

package/dist/util/sqlLiteral.js

@@ -32,7 +32,6 @@ const MYSQL_ESCAPES = {
     '\\': '\\\\',
 };
 const mysqlStringLiteral = (val) => `'${val.replace(MYSQL_SPECIALS, (char) => MYSQL_ESCAPES[char])}'`;
-const pad = (value, len) => String(value).padStart(len, '0');
 const HEX_BYTES = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, '0'));
 /** Native hex encoder where available (~130x faster on 4 KB); lookup table for browsers. */
 function bytesToHexLiteral(bytes) {
@@ -49,8 +48,11 @@ function bytesToHexLiteral(bytes) {
  * measured 1.1-1.5x slower. Rejects unsupported types rather than stringifying them into SQL.
  */
 function createEscaper(escapeString) {
-    /** `YYYY-MM-DD HH:mm:ss.mmm` in local time, wrapped as a quoted literal. */
-    const dateLiteral = (date) => escapeString(`${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1, 2)}-${pad(date.getDate(), 2)} ${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}`);
+    /**
+     * `YYYY-MM-DD HH:mm:ss.SSS` in UTC, so the SQL is the same whichever machine wrote it. Not `toISOString`
+     * as it is, whose `T` and `Z` MySQL rejects outright ("Invalid default value").
+     */
+    const dateLiteral = (date) => escapeString(date.toISOString().replace('T', ' ').replace('Z', ''));
     const sqlList = (arr) => {
         let sql = '';
         for (let i = 0; i < arr.length; i++) {

package/dist/util/wideNumber.d.ts

@@ -8,7 +8,7 @@ import type { RawRow } from '../type/index.js';
 export declare function decodeWideNumber(value: string | bigint): number | string;
 /**
  * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
- * as one (`bun:sql` with `bigint: true`, `mariadb`). In place: the row is the driver's fresh object, and
- * a copy per row cost more than the decode it carried.
+ * as one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
+ * object, and a copy per row cost more than the decode it carried.
  */
 export declare function decodeBigInts(row: RawRow): RawRow;

package/dist/util/wideNumber.js

@@ -10,8 +10,8 @@ export function decodeWideNumber(value) {
 }
 /**
  * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
- * as one (`bun:sql` with `bigint: true`, `mariadb`). In place: the row is the driver's fresh object, and
- * a copy per row cost more than the decode it carried.
+ * as one (`bun:sql`, `mariadb`, and every SQLite driver but D1). In place: the row is the driver's fresh
+ * object, and a copy per row cost more than the decode it carried.
  */
 export function decodeBigInts(row) {
     for (const key in row) {

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.62.0",
+  "version": "0.64.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -71,7 +71,7 @@
     "@nestjs/common": ">=10.0.0",
     "@nestjs/core": ">=10.0.0",
     "@tursodatabase/database": ">=0.7.0",
-    "@tursodatabase/serverless": ">=1.0.0",
+    "@tursodatabase/serverless": ">=1.3.0",
     "better-sqlite3": ">=9.0.0",
     "express": ">=5.0.0",
     "mariadb": ">=3.0.0",

package/dist/migrate/schemaGeneratorAsync.d.ts

@@ -1,7 +0,0 @@
-import type { ForeignKeyAction } from '../schema/types.js';
-import type { MigratorDialect, SchemaGenerator } from '../type/index.js';
-/**
- * Async factory for schema generators. Use this for MongoDB so the optional peer
- * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
- */
-export declare function createSchemaGeneratorAsync(dialect: MigratorDialect, defaultForeignKeyAction?: ForeignKeyAction): Promise<SchemaGenerator | undefined>;

package/dist/migrate/schemaGeneratorAsync.js

@@ -1,12 +0,0 @@
-import { createSchemaGenerator } from './schemaGenerator.js';
-/**
- * Async factory for schema generators. Use this for MongoDB so the optional peer
- * `mongodb` is only loaded when this path runs. SQL dialects delegate to {@link createSchemaGenerator}.
- */
-export async function createSchemaGeneratorAsync(dialect, defaultForeignKeyAction) {
-    if (dialect.dialectName === 'mongodb') {
-        const { MongoSchemaGenerator } = await import('./generator/mongoSchemaGenerator.js');
-        return new MongoSchemaGenerator(dialect.namingStrategy, defaultForeignKeyAction);
-    }
-    return createSchemaGenerator(dialect, defaultForeignKeyAction);
-}

package/dist/sqlite/hranaQuerierPool.d.ts

@@ -1,20 +0,0 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
-import { type HranaClient, HranaQuerier } from './hranaQuerier.js';
-import type { SqliteDialect } from './sqliteDialect.js';
-/**
- * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
- * `@tursodatabase/serverless/compat`).
- *
- * @remarks The client is shared by every querier, since Hrana keeps no per-connection state: a
- * transaction takes its own session handle. It is resolved on first use rather than in the
- * constructor, so building a pool never throws when the optional driver peer is absent, which is what
- * lets a Workers bundle construct one at module scope.
- */
-export declare abstract class AbstractHranaQuerierPool<D extends SqliteDialect> extends AbstractSqlQuerierPool<HranaQuerier, D> {
-    private client?;
-    /** False when the caller injected their own client, in which case they own its lifecycle. */
-    protected readonly ownsClient: boolean;
-    protected abstract openClient(): Promise<HranaClient>;
-    getQuerier(): Promise<HranaQuerier>;
-    end(): Promise<void>;
-}

package/dist/sqlite/hranaQuerierPool.js

@@ -1,26 +0,0 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
-import { HranaQuerier } from './hranaQuerier.js';
-/**
- * Pool for SQLite databases reached over the Hrana wire protocol (`@libsql/client`,
- * `@tursodatabase/serverless/compat`).
- *
- * @remarks The client is shared by every querier, since Hrana keeps no per-connection state: a
- * transaction takes its own session handle. It is resolved on first use rather than in the
- * constructor, so building a pool never throws when the optional driver peer is absent, which is what
- * lets a Workers bundle construct one at module scope.
- */
-export class AbstractHranaQuerierPool extends AbstractSqlQuerierPool {
-    client;
-    /** False when the caller injected their own client, in which case they own its lifecycle. */
-    ownsClient = true;
-    async getQuerier() {
-        this.client ??= await this.openClient();
-        return new HranaQuerier(this.client, this.dialect, this.extra);
-    }
-    async end() {
-        if (this.ownsClient) {
-            this.client?.close();
-        }
-        this.client = undefined;
-    }
-}

package/dist/turso/tursoLocalQuerier.d.ts

@@ -1,24 +0,0 @@
-import { PreparedSqliteQuerier, type SqlitePreparedStatement } from '../sqlite/abstractSqliteQuerier.js';
-import type { SqliteDialect } from '../sqlite/sqliteDialect.js';
-import type { ExtraOptions } from '../type/index.js';
-/**
- * Structural subset of the `@tursodatabase/database` API actually used here, declared locally so
- * this package does not couple its published types to a pre-1.0 dependency.
- */
-export type TursoDatabase = {
-    prepare(sql: string): Promise<SqlitePreparedStatement>;
-    close(): Promise<void>;
-};
-/**
- * Querier for the embedded Turso engine.
- *
- * @remarks The engine exposes better-sqlite3 semantics (`reader`, `{changes, lastInsertRowid}`,
- * array-bound values) over an async API, so all it supplies is the awaited `prepare`.
- * `BEGIN`/`COMMIT` work as plain statements, leaving transactions to the base class.
- */
-export declare class TursoLocalQuerier extends PreparedSqliteQuerier {
-    readonly db: TursoDatabase;
-    readonly extra?: ExtraOptions | undefined;
-    constructor(db: TursoDatabase, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    protected prepare(query: string): Promise<SqlitePreparedStatement>;
-}

package/dist/turso/tursoLocalQuerier.js

@@ -1,20 +0,0 @@
-import { PreparedSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
-/**
- * Querier for the embedded Turso engine.
- *
- * @remarks The engine exposes better-sqlite3 semantics (`reader`, `{changes, lastInsertRowid}`,
- * array-bound values) over an async API, so all it supplies is the awaited `prepare`.
- * `BEGIN`/`COMMIT` work as plain statements, leaving transactions to the base class.
- */
-export class TursoLocalQuerier extends PreparedSqliteQuerier {
-    db;
-    extra;
-    constructor(db, dialect, extra) {
-        super(dialect, extra);
-        this.db = db;
-        this.extra = extra;
-    }
-    prepare(query) {
-        return this.db.prepare(query);
-    }
-}