uql-orm 0.64.0 → 0.65.1

package/dist/bunSql/bunSqlQuerier.d.ts

@@ -4,19 +4,12 @@ import { type BunSqlConn } from './bunSql.util.js';
  * Querier for `bun:sql`, Bun's built-in driver for Postgres, MySQL, MariaDB and CockroachDB.
  *
  * @remarks Exposes no `SQL` of its own: the pool's would run a statement on any connection, outside
- * the transaction this one's reserved connection holds. Raw access is `pool.sql`.
+ * the transaction this one's reserved connection holds. Raw access is `pool.sql`. It streams through the
+ * base class, `bun:sql` having no cursor API ([oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181)).
  */
 export declare class BunSqlQuerier extends AbstractPoolQuerier<BunSqlConn> {
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
-    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
-    /**
-     * A server-side cursor where the engine has one, the base class's buffering where it does not.
-     *
-     * Bun's `SQL.Query` is a `Promise` with no cursor or async-iterator API
-     * ([oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181)), so the rows have to be paged
-     * in SQL instead - which the Postgres wire family can do and MySQL cannot.
-     */
-    protected internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, any>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../index.js").QueryUpdateResult>;
     private execute;
     protected releaseConn(conn: BunSqlConn): Promise<void>;
 }

package/dist/bunSql/bunSqlQuerier.js

@@ -1,4 +1,3 @@
-import { streamViaCursor } from '../postgres/pgCursorStream.js';
 import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
 import { decodeBigInts } from '../util/wideNumber.js';
 import { getAffectedRows, getInsertId } from './bunSql.util.js';
@@ -6,7 +5,8 @@ import { getAffectedRows, getInsertId } from './bunSql.util.js';
  * Querier for `bun:sql`, Bun's built-in driver for Postgres, MySQL, MariaDB and CockroachDB.
  *
  * @remarks Exposes no `SQL` of its own: the pool's would run a statement on any connection, outside
- * the transaction this one's reserved connection holds. Raw access is `pool.sql`.
+ * the transaction this one's reserved connection holds. Raw access is `pool.sql`. It streams through the
+ * base class, `bun:sql` having no cursor API ([oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181)).
  */
 export class BunSqlQuerier extends AbstractPoolQuerier {
     async internalAll(query, values) {
@@ -21,20 +21,6 @@ export class BunSqlQuerier extends AbstractPoolQuerier {
             upsertStatus: res.affectedRows ?? undefined,
         });
     }
-    /**
-     * A server-side cursor where the engine has one, the base class's buffering where it does not.
-     *
-     * Bun's `SQL.Query` is a `Promise` with no cursor or async-iterator API
-     * ([oven-sh/bun#17181](https://github.com/oven-sh/bun/issues/17181)), so the rows have to be paged
-     * in SQL instead - which the Postgres wire family can do and MySQL cannot.
-     */
-    async *internalStream(query, values) {
-        if (!this.dialect.features.serverSideCursors) {
-            yield* super.internalStream(query, values);
-            return;
-        }
-        yield* streamViaCursor((sql, params) => this.internalAll(sql, params), query, values, this.hasOpenTransaction);
-    }
     async execute(query, values) {
         // Safe: UQL parameters are strictly bound. .unsafe() correctly bypasses Bun's tagged template
         // literal parsing requirement so we can execute our dynamically compiled AST strings natively.

package/dist/bunSql/bunSqlQuerierPool.d.ts

@@ -2,12 +2,10 @@ import { SQL } from 'bun';
 import type { AbstractSqlDialect } from '../dialect/abstractSqlDialect.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import type { ExtraOptions, SqlPoolCompat } from '../type/index.js';
-import { type BunSqlDialectName } from './bunSql.util.js';
 import { BunSqlQuerier } from './bunSqlQuerier.js';
 export declare class BunSqlQuerierPool extends AbstractSqlQuerierPool<BunSqlQuerier, AbstractSqlDialect> {
     readonly config: SQL.Options;
     readonly sql: SQL;
-    readonly sqlDialectName: BunSqlDialectName;
     /** @param config Bun's own `SQL.Options`, from which the engine is inferred. */
     constructor(config: SQL.Options, extra?: ExtraOptions);
     /**

package/dist/bunSql/bunSqlQuerierPool.js

@@ -4,36 +4,34 @@ import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { MariaDialect } from '../maria/mariaDialect.js';
 import { MySqlDialect } from '../mysql/mysqlDialect.js';
 import { PostgresDialect } from '../postgres/postgresDialect.js';
-import { POSTGRES_WIRE_DRIVER_CAPABILITIES } from '../postgres/postgresWireDriverCapabilities.js';
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import { decodeBigInts } from '../util/wideNumber.js';
 import { getAffectedRows, inferDialectName, normalizeBunOpts, } from './bunSql.util.js';
 import { BunSqlQuerier } from './bunSqlQuerier.js';
 /**
- * The dialect each engine `bun:sql` drives is given, and how this driver shapes its parameters.
- *
- * The engine dialects themselves, not `bun:sql` subclasses of them: what Bun changes is the binding,
- * never the SQL, and a per-instance `driverCapabilities` is where the base class already takes that -
- * so the Postgres and CockroachDB entries differ from `PgQuerierPool`'s only by naming the same
- * constant. Total over {@link BunSqlDialectName}, so a new Bun adapter has to be answered here.
+ * How `bun:sql` binds on the Postgres wire, measured live on Postgres and CockroachDB alike: an array
+ * as its literal, since `unsafe()` binds no JS array, and JSON re-cast through text, without which a
+ * JSONB `$set`/`$push` writes the wrong value or throws.
  */
-const DialectMap = {
-    postgres: [PostgresDialect, POSTGRES_WIRE_DRIVER_CAPABILITIES],
-    cockroachdb: [CockroachDialect, POSTGRES_WIRE_DRIVER_CAPABILITIES],
-    mysql: [MySqlDialect],
-    mariadb: [MariaDialect],
+const POSTGRES_WIRE = { nativeArrays: false, explicitJsonCast: true };
+/**
+ * The dialect of each engine `bun:sql` drives: the engine's own, since Bun changes how a parameter binds,
+ * never the SQL. Total over {@link BunSqlDialectName}, so a new Bun adapter has to be answered here.
+ */
+const DIALECTS = {
+    postgres: (options) => new PostgresDialect({ ...options, driverCapabilities: POSTGRES_WIRE }),
+    cockroachdb: (options) => new CockroachDialect({ ...options, driverCapabilities: POSTGRES_WIRE }),
+    mysql: (options) => new MySqlDialect(options),
+    mariadb: (options) => new MariaDialect(options),
 };
 export class BunSqlQuerierPool extends AbstractSqlQuerierPool {
     config;
     sql;
-    sqlDialectName;
     /** @param config Bun's own `SQL.Options`, from which the engine is inferred. */
     constructor(config, extra) {
         const dialectName = inferDialectName(config);
-        const [Dialect, driverCapabilities] = DialectMap[dialectName];
-        super(new Dialect({ ...dialectOptionsFrom(extra), driverCapabilities }), extra);
+        super(DIALECTS[dialectName](dialectOptionsFrom(extra)), extra);
         this.config = config;
-        this.sqlDialectName = dialectName;
         this.sql = new SQL(normalizeBunOpts(config, dialectName));
     }
     /**

package/dist/d1/d1Querier.d.ts

@@ -1,51 +1,30 @@
-import { AbstractSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
+import { AbstractSqliteQuerier, type SqliteBindValue } from '../sqlite/abstractSqliteQuerier.js';
 import type { SqliteDialect } from '../sqlite/sqliteDialect.js';
 import type { ExtraOptions, RawRow } from '../type/index.js';
-export interface D1Meta {
-    duration?: number;
-    size_after?: number;
-    rows_read?: number;
-    rows_written?: number;
-    last_row_id?: number;
-    changed_db?: boolean;
-    changes?: number;
-    [key: string]: unknown;
-}
+/** What a statement answers on D1: the rows it read, and how many rows it changed. */
 export interface D1Result<T = unknown> {
     results: T[];
-    success: boolean;
-    meta: D1Meta;
-    error?: string;
-}
-export interface D1ExecResult {
-    count: number;
-    duration: number;
-    meta?: D1Meta;
+    meta: {
+        changes?: number;
+    };
 }
 export interface D1PreparedStatement {
     bind(...values: unknown[]): D1PreparedStatement;
-    first<T = unknown>(colName?: string): Promise<T | null>;
-    /** Documented by D1 as an alias of {@link all}: both answer the rows and `meta.changes`. */
-    run<T = unknown>(): Promise<D1Result<T>>;
+    /** Documented by D1 as the same call as `run()`: both answer the rows and `meta.changes`. */
     all<T = unknown>(): Promise<D1Result<T>>;
-    raw<T = unknown>(): Promise<T[]>;
 }
+/**
+ * The part of a D1 binding uql calls, which a session from `withSession()` - how a read-replicated
+ * database is read - has too. The rest of a binding is typed by `@cloudflare/workers-types`.
+ */
 export interface D1Database {
     prepare(query: string): D1PreparedStatement;
-    dump(): Promise<ArrayBuffer>;
-    batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
-    exec(query: string): Promise<D1ExecResult>;
 }
-/**
- * The only part of a D1 binding the querier uses: what a {@link D1Database} and a session from
- * `withSession()`, which a read-replicated database is read through, both have.
- */
-export type D1Preparer = Pick<D1Database, 'prepare'>;
 export declare class D1Querier extends AbstractSqliteQuerier {
-    readonly db: D1Preparer;
+    readonly db: D1Database;
     readonly extra?: ExtraOptions | undefined;
-    constructor(db: D1Preparer, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
-    protected execute(query: string, values?: unknown[]): Promise<{
+    constructor(db: D1Database, dialect: SqliteDialect, extra?: ExtraOptions | undefined);
+    protected execute(query: string, values: SqliteBindValue[]): Promise<{
         rows: RawRow[];
         changes: number;
     }>;

package/dist/d1/d1Querier.js

@@ -9,7 +9,7 @@ export class D1Querier extends AbstractSqliteQuerier {
     }
     async execute(query, values) {
         const stmt = this.db.prepare(query);
-        const { results, meta } = await (values?.length ? stmt.bind(...values) : stmt).all();
+        const { results, meta } = await (values.length ? stmt.bind(...values) : stmt).all();
         return { rows: results, changes: meta.changes ?? 0 };
     }
     /** D1 answers `BEGIN` with `D1_ERROR: not authorized`: a single statement is its only atomic unit. */

package/dist/d1/d1QuerierPool.d.ts

@@ -1,14 +1,14 @@
 import { AbstractSqlQuerierPool } from '../querier/index.js';
 import type { ExtraOptions } from '../type/index.js';
-import { type D1Preparer, D1Querier } from './d1Querier.js';
+import { type D1Database, D1Querier } from './d1Querier.js';
 import { D1SqliteDialect } from './d1SqliteDialect.js';
 /**
  * Pool for Cloudflare D1. It holds nothing: every querier runs on what it was given, `env.DB` or a
  * session from `env.DB.withSession()`, the way a read-replicated database is read consistently.
  */
 export declare class D1QuerierPool extends AbstractSqlQuerierPool<D1Querier, D1SqliteDialect> {
-    readonly db: D1Preparer;
-    constructor(db: D1Preparer, extra?: ExtraOptions);
+    readonly db: D1Database;
+    constructor(db: D1Database, extra?: ExtraOptions);
     getQuerier(): Promise<D1Querier>;
     end(): Promise<void>;
 }

package/dist/dialect/abstractDialect.d.ts

@@ -6,12 +6,11 @@ export interface DialectOptions {
     readonly namingStrategy?: NamingStrategy;
     /** Default schema for entities naming none; unset leaves them unqualified. See {@link AbstractDialect.resolveSchema}. */
     readonly schema?: string;
-    readonly driverCapabilities?: Partial<DialectFeatures>;
 }
 /**
  * The dialect's share of a pool's {@link ExtraOptions}: what changes the SQL rather than the
  * connection. Every pool builds its dialect through this, so a new option lands here instead of in
- * each of the thirteen constructors.
+ * each pool's constructor.
  */
 export declare function dialectOptionsFrom(extra: ExtraOptions | undefined): DialectOptions;
 /**
@@ -23,10 +22,7 @@ export declare abstract class AbstractDialect {
     abstract readonly dialectName: DialectName;
     /** How this dialect surfaces the IDs generated by an INSERT (see {@link InsertIdSource}). */
     abstract readonly insertIdSource: InsertIdSource;
-    /**
-     * Engine/driver feature defaults for this dialect, before per-instance
-     * {@link DialectOptions.driverCapabilities} overrides. Each concrete dialect declares its own.
-     */
+    /** What the engine has, as this dialect's family has it. Each concrete dialect declares its own. */
     protected abstract readonly featureDefaults: DialectFeatures;
     /**
      * How this dialect differs from the family it extends, so a subclass states only its deltas rather
@@ -36,9 +32,8 @@ export declare abstract class AbstractDialect {
     readonly namingStrategy: NamingStrategy | undefined;
     constructor(options?: DialectOptions);
     /**
-     * Effective features: {@link featureDefaults}, then this dialect's {@link featureOverrides}, then
-     * any per-instance {@link DialectOptions.driverCapabilities}. Computed lazily (and memoized)
-     * because both are subclass fields, initialized only after `super()` returns.
+     * Effective features: {@link featureDefaults}, then this dialect's {@link featureOverrides}. Computed
+     * lazily (and memoized) because both are subclass fields, initialized only after `super()` returns.
      */
     get features(): DialectFeatures;
     /**

package/dist/dialect/abstractDialect.js

@@ -4,7 +4,7 @@ import { qualifyName } from '../util/sql.util.js';
 /**
  * The dialect's share of a pool's {@link ExtraOptions}: what changes the SQL rather than the
  * connection. Every pool builds its dialect through this, so a new option lands here instead of in
- * each of the thirteen constructors.
+ * each pool's constructor.
  */
 export function dialectOptionsFrom(extra) {
     return { namingStrategy: extra?.namingStrategy, schema: extra?.schema };
@@ -26,12 +26,11 @@ export class AbstractDialect {
         this.namingStrategy = options.namingStrategy;
     }
     /**
-     * Effective features: {@link featureDefaults}, then this dialect's {@link featureOverrides}, then
-     * any per-instance {@link DialectOptions.driverCapabilities}. Computed lazily (and memoized)
-     * because both are subclass fields, initialized only after `super()` returns.
+     * Effective features: {@link featureDefaults}, then this dialect's {@link featureOverrides}. Computed
+     * lazily (and memoized) because both are subclass fields, initialized only after `super()` returns.
      */
     get features() {
-        this.#features ??= { ...this.featureDefaults, ...this.featureOverrides, ...this.options.driverCapabilities };
+        this.#features ??= { ...this.featureDefaults, ...this.featureOverrides };
         return this.#features;
     }
     /**

package/dist/dialect/abstractSqlDialect.d.ts

@@ -1,4 +1,4 @@
-import { type EntityData, type EntityMeta, type EntityWhereMeta, type FieldKey, type FieldOptions, type IsolationLevel, type JsonColumnType, type JsonUpdateOp, type Query, type QueryAggMap, type QueryAggregate, type QueryBuildFn, type QueryComparisonOptions, type QueryConflictPaths, type QueryContext, type QueryContextOptions, type QueryDialect, type QueryExclude, type QueryFilter, type QueryGroupMap, type QueryGroupOp, type QueryHavingMap, type QueryOptions, type QueryPager, QueryRaw, type QueryRawFnOptions, type QuerySearch, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryTextSearchOptions, type QueryVectorNear, type QueryWhere, type QueryWhereArray, type QueryWhereFieldOperatorMap, type QueryWhereOptions, type RelationMeta, type SqlDialectName, type SqlQueryDialect, type Type, type UpdatePayload } from '../type/index.js';
+import { type EntityData, type EntityMeta, type EntityWhereMeta, type FieldKey, type FieldOptions, type IsolationLevel, type JsonColumnType, type JsonUpdateOp, type Query, type QueryAggMap, type QueryAggregate, type QueryBuildFn, type QueryComparisonOptions, type QueryConflictPaths, type QueryContext, type QueryContextOptions, type QueryExclude, type QueryFilter, type QueryGroupMap, type QueryGroupOp, type QueryHavingMap, type QueryOptions, type QueryPager, QueryRaw, type QueryRawFnOptions, type QuerySearch, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryTextSearchOptions, type QueryVectorNear, type QueryWhere, type QueryWhereArray, type QueryWhereFieldOperatorMap, type QueryWhereOptions, type RelationMeta, type SqlDialectName, type SqlQueryDialect, type Type, type UpdatePayload } from '../type/index.js';
 import { type ColumnFamily } from '../util/field.util.js';
 import type { HydrateKind } from './hydrateColumn.js';
 import { type JsonAccessMode } from './jsonSql.js';
@@ -80,7 +80,7 @@ export type CarriedFields = {
 /** The key a term answers under in a populated relation's row, which a raw expression has only once aliased. */
 export declare function relationTermKey({ sql, key }: SelectTerm): string;
 export type { HydrateKind };
-export declare abstract class AbstractSqlDialect extends VectorSqlDialect implements QueryDialect, SqlQueryDialect {
+export declare abstract class AbstractSqlDialect extends VectorSqlDialect implements SqlQueryDialect {
     abstract readonly dialectName: SqlDialectName;
     abstract readonly escapeIdChar: '"' | '`';
     /**

package/dist/dialect/index.d.ts

@@ -1,4 +1,3 @@
 export * from './abstractDialect.js';
 export * from './abstractSqlDialect.js';
-export * from './mysqlLikeSqlDialect.js';
 export * from './queryContext.js';

package/dist/dialect/index.js

@@ -1,6 +1,5 @@
-// The concrete dialects are behind their own entries (`uql-orm/postgres`, `/mysql`, `/maria`,
-// `/sqlite`, `/cockroachdb`): importing the root should not carry four engines' worth of SQL.
+// Each engine's dialect is behind its own entry, and the family bases they extend behind none: the root
+// carries no engine's SQL.
 export * from './abstractDialect.js';
 export * from './abstractSqlDialect.js';
-export * from './mysqlLikeSqlDialect.js';
 export * from './queryContext.js';

package/dist/dialect/mysqlLikeSqlDialect.js

@@ -24,9 +24,6 @@ const MAX_LIMIT = BigInt.asUintN(64, -1n);
 export class MysqlLikeSqlDialect extends AbstractSqlDialect {
     /** Default {@link DialectFeatures} for MySQL-compatible SQL dialects. */
     featureDefaults = {
-        explicitJsonCast: false,
-        nativeArrays: false,
-        supportsJsonb: false,
         ifNotExists: true,
         indexIfNotExists: false,
         schemas: true,

package/dist/dialect/pgLikeSqlDialect.d.ts

@@ -1,5 +1,10 @@
-import { type DialectFeatures, type EntityMeta, type FieldOptions, type JsonColumnType, type Query, type QueryContext, type QuerySizeComparisonOps, type QueryTextSearchOptions, type Type } from '../type/index.js';
+import { type DialectFeatures, type DriverCapabilities, type EntityMeta, type FieldOptions, type JsonColumnType, type Query, type QueryContext, type QuerySizeComparisonOps, type QueryTextSearchOptions, type Type } from '../type/index.js';
+import type { DialectOptions } from './abstractDialect.js';
 import { AbstractSqlDialect, type RelationRows } from './abstractSqlDialect.js';
+/** A Postgres-wire dialect's options: the base's, and how its driver binds a parameter. */
+export type PgLikeDialectOptions = DialectOptions & {
+    readonly driverCapabilities?: Partial<DriverCapabilities>;
+};
 /**
  * Shared AST/quoting/JSONB/full-text-search/vector-search implementation between Postgres and
  * CockroachDB (wire- and SQL-compatible for everything below, including `TO_TSVECTOR`/`TO_TSQUERY`
@@ -10,6 +15,9 @@ import { AbstractSqlDialect, type RelationRows } from './abstractSqlDialect.js';
  * syntax; CockroachDB's vector type and `CREATE VECTOR INDEX` syntax are both native).
  */
 export declare abstract class PgLikeSqlDialect extends AbstractSqlDialect {
+    /** How the driver binds a parameter: node-`pg`'s, unless the pool states its own. */
+    readonly driverCapabilities: DriverCapabilities;
+    constructor(options?: PgLikeDialectOptions);
     /** `FOR UPDATE` and a window function cannot share a statement here. See the base declaration. */
     readonly supportsWindowWithRowLock = false;
     /** Default {@link DialectFeatures} for Postgres-wire dialects. */

package/dist/dialect/pgLikeSqlDialect.js

@@ -17,13 +17,16 @@ import { resolveVectorCast, toSparsevecLiteral } from './vectorCast.js';
  * syntax; CockroachDB's vector type and `CREATE VECTOR INDEX` syntax are both native).
  */
 export class PgLikeSqlDialect extends AbstractSqlDialect {
+    /** How the driver binds a parameter: node-`pg`'s, unless the pool states its own. */
+    driverCapabilities;
+    constructor(options = {}) {
+        super(options);
+        this.driverCapabilities = { nativeArrays: true, explicitJsonCast: false, ...options.driverCapabilities };
+    }
     /** `FOR UPDATE` and a window function cannot share a statement here. See the base declaration. */
     supportsWindowWithRowLock = false;
     /** Default {@link DialectFeatures} for Postgres-wire dialects. */
     featureDefaults = {
-        explicitJsonCast: false,
-        nativeArrays: true,
-        supportsJsonb: true,
         ifNotExists: true,
         indexIfNotExists: true,
         schemas: true,
@@ -109,7 +112,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
     }
     normalizeValue(value) {
         if (value != null && typeof value === 'object' && Array.isArray(value)) {
-            return this.features.nativeArrays ? value : toPgArray(value);
+            return this.driverCapabilities.nativeArrays ? value : toPgArray(value);
         }
         return super.normalizeValue(value);
     }
@@ -227,7 +230,7 @@ export class PgLikeSqlDialect extends AbstractSqlDialect {
             return `${this.addValue(ctx, null)}::${type}`;
         const json = JSON.stringify(value);
         const ph = this.addValue(ctx, json);
-        return this.features.explicitJsonCast ? `(${ph}::text)::${type}` : `${ph}::${type}`;
+        return this.driverCapabilities.explicitJsonCast ? `(${ph}::text)::${type}` : `${ph}::${type}`;
     }
 }
 /**

package/dist/dialect/queryContext.d.ts

@@ -1,4 +1,4 @@
-import type { QueryContext, QueryDialect } from '../type/index.js';
+import type { QueryContext, SqlQueryDialect } from '../type/index.js';
 /**
  * SqlQueryContext is an implementation of the QueryContext interface specifically for SQL-based dialects.
  * It follows the "Accumulator" or "Builder" pattern to construct SQL queries and their corresponding parameters.
@@ -7,7 +7,7 @@ import type { QueryContext, QueryDialect } from '../type/index.js';
  * preventing SQL injection and handling dialect-specific parameter placeholders (e.g., '?' for MySQL, '$n' for PostgreSQL).
  */
 export declare class SqlQueryContext implements QueryContext {
-    readonly dialect: QueryDialect;
+    readonly dialect: SqlQueryDialect;
     private readonly statement?;
     readonly inlineValues: boolean;
     private readonly sqlChunks;
@@ -23,7 +23,7 @@ export declare class SqlQueryContext implements QueryContext {
      * fragment is part of one statement, so its aliases have to be unique across the whole of it.
      * @param inlineValues See {@link QueryContext.inlineValues}; a fragment takes its statement's.
      */
-    constructor(dialect: QueryDialect, params?: unknown[], statement?: SqlQueryContext | undefined, inlineValues?: boolean);
+    constructor(dialect: SqlQueryDialect, params?: unknown[], statement?: SqlQueryContext | undefined, inlineValues?: boolean);
     createFragment(): QueryContext;
     /**
      * Appends raw SQL string fragments to the query.

package/dist/entity/metadata/definition.d.ts

@@ -68,3 +68,9 @@ export declare function idOf<E>(meta: EntityMeta<E>, row: EntityData<E>): Writte
 export declare function removeEntity<E>(entity: Type<E>): boolean;
 export declare function getEntities(): Type<object>[];
 export declare function getMeta<E>(entity: Type<E>): EntityMeta<E>;
+/**
+ * The foreign keys an entity holds: each owning to-one's columns, and each `@Field({ references })` no
+ * relation joins on, as the many-to-one it describes, once its target has registered a key. What the
+ * schema build constrains and a junction joins by, read once the relations holding them are settled.
+ */
+export declare function foreignKeysOf<E>(meta: EntityMeta<E>): RelationMeta[];