uql-orm 0.63.0 → 0.65.0

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/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/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/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 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,4 +1,5 @@
 import { ColumnRef, QueryRaw, } from '../type/index.js';
+import { definedEntries } from './object.util.js';
 /**
  * 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.
@@ -7,6 +8,19 @@ export function normalizeIndexColumn(entry) {
     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) {
     const { column } = entry;

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/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.63.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/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/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 {};