uql-orm 0.51.0 → 0.53.0

package/dist/mssql/mssqlQuerierPool.d.ts

@@ -0,0 +1,17 @@
+import { ConnectionPool, type config as MsSqlConfig } from 'mssql';
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import { MsSqlDialect } from './mssqlDialect.js';
+import { MsSqlQuerier } from './mssqlQuerier.js';
+export declare class MsSqlQuerierPool extends AbstractSqlQuerierPool<MsSqlQuerier, MsSqlDialect> {
+    #private;
+    readonly pool: ConnectionPool;
+    constructor(opts: MsSqlConfig, extra?: ExtraOptions);
+    /**
+     * `mssql` connects the pool as a whole rather than per checkout, so the promise is shared. A
+     * failed one is dropped rather than kept: memoized, a single transient failure would be handed to
+     * every later caller for the life of the pool.
+     */
+    getQuerier(): Promise<MsSqlQuerier>;
+    end(): Promise<void>;
+}

package/dist/mssql/mssqlQuerierPool.js

@@ -0,0 +1,32 @@
+import { ConnectionPool } from 'mssql';
+import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { MsSqlDialect } from './mssqlDialect.js';
+import { MsSqlQuerier } from './mssqlQuerier.js';
+export class MsSqlQuerierPool extends AbstractSqlQuerierPool {
+    pool;
+    #connected;
+    constructor(opts, extra) {
+        super(new MsSqlDialect(dialectOptionsFrom(extra)), extra);
+        this.pool = new ConnectionPool(opts);
+    }
+    /**
+     * `mssql` connects the pool as a whole rather than per checkout, so the promise is shared. A
+     * failed one is dropped rather than kept: memoized, a single transient failure would be handed to
+     * every later caller for the life of the pool.
+     */
+    async getQuerier() {
+        return new MsSqlQuerier(() => this.#connect(), this.dialect, this.extra);
+    }
+    #connect() {
+        this.#connected ??= this.pool.connect().catch((err) => {
+            this.#connected = undefined;
+            throw err;
+        });
+        return this.#connected;
+    }
+    async end() {
+        this.#connected = undefined;
+        await this.pool.close();
+    }
+}

package/dist/mssql/mssqlWireTypes.d.ts

@@ -0,0 +1,23 @@
+/** The column metadata `tedious` reports beside a recordset, narrowed to the one field read here. */
+type ColumnTypes = Record<string, {
+    readonly type: unknown;
+}>;
+/**
+ * Decode `BIGINT` as a JS number, leaving every other type to the driver.
+ *
+ * uql owes this to the caller because uql picks the column: `type: Number` maps to BIGINT (see
+ * `schema/canonicalType.ts`), and `tedious` hands that back as a string to protect the digits past
+ * 2^53 - so without this a field declared `number` reads back as `'9'`, including every generated
+ * primary key on every entity.
+ *
+ * At the wire, for the reason `pgNumericTypes` gives: everything crosses it exactly once - entity
+ * reads, the ids an `OUTPUT` reports, raw SQL, counts, aggregates - where the ORM's own hydration
+ * only ever sees entity reads.
+ *
+ * Exact to 2^53, which covers any generated id. A value past it keeps the string the driver gave,
+ * because a number could no longer represent it: that is the one case where handing back the exact
+ * text is more useful than handing back the type that was asked for. The lighter escape hatch for a
+ * column that big is the declaration - `@Field({ type: String, columnType: 'bigint' })`.
+ */
+export declare function decodeWireTypes<T>(rows: T[] | undefined, columns: ColumnTypes | undefined): T[];
+export {};

package/dist/mssql/mssqlWireTypes.js

@@ -0,0 +1,44 @@
+/**
+ * Decode `BIGINT` as a JS number, leaving every other type to the driver.
+ *
+ * uql owes this to the caller because uql picks the column: `type: Number` maps to BIGINT (see
+ * `schema/canonicalType.ts`), and `tedious` hands that back as a string to protect the digits past
+ * 2^53 - so without this a field declared `number` reads back as `'9'`, including every generated
+ * primary key on every entity.
+ *
+ * At the wire, for the reason `pgNumericTypes` gives: everything crosses it exactly once - entity
+ * reads, the ids an `OUTPUT` reports, raw SQL, counts, aggregates - where the ORM's own hydration
+ * only ever sees entity reads.
+ *
+ * Exact to 2^53, which covers any generated id. A value past it keeps the string the driver gave,
+ * because a number could no longer represent it: that is the one case where handing back the exact
+ * text is more useful than handing back the type that was asked for. The lighter escape hatch for a
+ * column that big is the declaration - `@Field({ type: String, columnType: 'bigint' })`.
+ */
+export function decodeWireTypes(rows, columns) {
+    if (!rows?.length || !columns) {
+        return rows ?? [];
+    }
+    const wide = Object.keys(columns).filter((name) => typeName(columns[name]?.type) === 'BigInt');
+    if (!wide.length) {
+        // The overwhelmingly common case, so an ordinary read copies nothing.
+        return rows;
+    }
+    return rows.map((row) => {
+        const decoded = { ...row };
+        for (const name of wide) {
+            const value = decoded[name];
+            if (typeof value === 'string') {
+                const asNumber = Number(value);
+                if (Number.isSafeInteger(asNumber)) {
+                    decoded[name] = asNumber;
+                }
+            }
+        }
+        return decoded;
+    });
+}
+/** `tedious` reports a column's type as its factory function, whose `name` is the type's own. */
+function typeName(type) {
+    return typeof type === 'function' ? type.name : undefined;
+}

package/dist/pglite/pgliteQuerier.d.ts

@@ -21,8 +21,8 @@ export type PgliteDatabase = {
  * Querier for PGlite, Postgres compiled to WASM and run in this process.
  *
  * @remarks Extends {@link AbstractSqlQuerier} rather than `AbstractPgQuerier`, whose `internalStream`
- * hands a `pg-query-stream` object to `query()`: PGlite has no cursor API, so streaming falls back to
- * the base class buffering the whole result. `BEGIN`/`COMMIT` are plain statements on the single
+ * hands a `pg-query-stream` object to `query()`, which PGlite's client has no equivalent of - so
+ * streaming pages the rows in SQL instead. `BEGIN`/`COMMIT` are plain statements on the single
  * connection, leaving transactions to the base class.
  */
 export declare class PgliteQuerier extends AbstractSqlQuerier {
@@ -31,6 +31,8 @@ export declare class PgliteQuerier extends AbstractSqlQuerier {
     constructor(db: PgliteDatabase, dialect: PgliteDialect, extra?: ExtraOptions | undefined);
     internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
     internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
+    /** Postgres compiled to WASM is still Postgres: `DECLARE`/`FETCH` streams what the client cannot. */
+    protected internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, any>;
     /** The handle belongs to the pool, which hands out one querier per unit of work over it. */
     internalRelease(): Promise<void>;
 }

package/dist/pglite/pgliteQuerier.js

@@ -1,10 +1,11 @@
+import { streamViaCursor } from '../postgres/pgCursorStream.js';
 import { AbstractSqlQuerier } from '../querier/index.js';
 /**
  * Querier for PGlite, Postgres compiled to WASM and run in this process.
  *
  * @remarks Extends {@link AbstractSqlQuerier} rather than `AbstractPgQuerier`, whose `internalStream`
- * hands a `pg-query-stream` object to `query()`: PGlite has no cursor API, so streaming falls back to
- * the base class buffering the whole result. `BEGIN`/`COMMIT` are plain statements on the single
+ * hands a `pg-query-stream` object to `query()`, which PGlite's client has no equivalent of - so
+ * streaming pages the rows in SQL instead. `BEGIN`/`COMMIT` are plain statements on the single
  * connection, leaving transactions to the base class.
  */
 export class PgliteQuerier extends AbstractSqlQuerier {
@@ -25,6 +26,10 @@ export class PgliteQuerier extends AbstractSqlQuerier {
         // where the latter also counts a `SELECT`'s rows and is absent altogether from a DDL tag.
         return this.buildUpdateResult({ rows: res.rows, changes: res.affectedRows ?? 0 });
     }
+    /** Postgres compiled to WASM is still Postgres: `DECLARE`/`FETCH` streams what the client cannot. */
+    async *internalStream(query, values) {
+        yield* streamViaCursor((sql, params) => this.internalAll(sql, params), query, values, this.hasOpenTransaction);
+    }
     /** The handle belongs to the pool, which hands out one querier per unit of work over it. */
     async internalRelease() { }
 }

package/dist/postgres/pgCursorStream.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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/pgCursorStream.js

@@ -0,0 +1,49 @@
+/** The cursor a stream declares. Suffixed per call, so two streams on one connection cannot collide. */
+const CURSOR_ALIAS = '_uql_cursor';
+/** Rows per round trip, matching `pg-query-stream`'s own default so both paths read the same. */
+const FETCH_SIZE = 100;
+let cursorSeq = 0;
+/**
+ * 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 async function* streamViaCursor(exec, query, values, inTransaction = false) {
+    const cursor = `${CURSOR_ALIAS}_${++cursorSeq}`;
+    const ownsTransaction = !inTransaction;
+    if (ownsTransaction) {
+        await exec('BEGIN');
+    }
+    let failed = false;
+    try {
+        await exec(`DECLARE ${cursor} CURSOR FOR ${query}`, values);
+        for (;;) {
+            const rows = await exec(`FETCH FORWARD ${FETCH_SIZE} FROM ${cursor}`);
+            yield* rows;
+            if (rows.length < FETCH_SIZE) {
+                return;
+            }
+        }
+    }
+    catch (err) {
+        failed = true;
+        throw err;
+    }
+    finally {
+        // Best-effort once the stream has failed: an error raised here would replace the one that brought
+        // us here, which is the one worth reporting, and the rollback discards the cursor either way.
+        const end = failed ? (sql) => exec(sql).catch(() => []) : exec;
+        await end(`CLOSE ${cursor}`);
+        if (ownsTransaction) {
+            await end(failed ? 'ROLLBACK' : 'COMMIT');
+        }
+    }
+}

package/dist/postgres/pgDialect.d.ts

@@ -4,7 +4,7 @@ import { PostgresDialect } from './postgresDialect.js';
  *
  * @remarks Uses base {@link PostgresDialect} capabilities: native JS arrays for `ANY` / `ALL`
  * (`nativeArrays: true`) and `$n::jsonb` without a text re-cast. Bun SQL Postgres needs
- * `BunSqlPostgresDialect` from `uql-orm/bunSql` instead (wire array literals + text json cast).
+ * `BunSqlQuerierPool` from `uql-orm/bunSql` instead (wire array literals + text json cast).
  */
 export declare class PgDialect extends PostgresDialect {
 }

package/dist/postgres/pgDialect.js

@@ -4,7 +4,7 @@ import { PostgresDialect } from './postgresDialect.js';
  *
  * @remarks Uses base {@link PostgresDialect} capabilities: native JS arrays for `ANY` / `ALL`
  * (`nativeArrays: true`) and `$n::jsonb` without a text re-cast. Bun SQL Postgres needs
- * `BunSqlPostgresDialect` from `uql-orm/bunSql` instead (wire array literals + text json cast).
+ * `BunSqlQuerierPool` from `uql-orm/bunSql` instead (wire array literals + text json cast).
  */
 export class PgDialect extends PostgresDialect {
 }

package/dist/postgres/postgresWireDriverCapabilities.d.ts

@@ -1,19 +1,21 @@
 /**
- * Wire-style parameter shaping for **Bun SQL** (and similar clients) on any Postgres-wire dialect:
- * arrays are sent as string literals (`nativeArrays: false`) via {@link PgLikeSqlDialect}'s
- * `toPgArray` path.
+ * 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.
  *
- * `PgDialect` does **not** use this constant - it keeps base {@link PgLikeSqlDialect} defaults
- * (`nativeArrays: true`, `explicitJsonCast: false`), since node-`pg` doesn't need the fix.
- * `BunSqlPostgresDialect` and `BunSqlCockroachDialect` both spread this and set
- * `explicitJsonCast: true` - `bun:sql` routes CockroachDB through its own Postgres wire-protocol
- * implementation (see `bunSql.util.ts#normalizeBunOpts`), so it needs the identical fix: verified
- * directly that without it, `$set`/`$push` on a JSONB column silently produce the wrong value
- * or throw on a live CockroachDB instance.
+ * 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. `PgDialect` 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 `NeonDialect` 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,19 +1,21 @@
 /**
- * Wire-style parameter shaping for **Bun SQL** (and similar clients) on any Postgres-wire dialect:
- * arrays are sent as string literals (`nativeArrays: false`) via {@link PgLikeSqlDialect}'s
- * `toPgArray` path.
+ * 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.
  *
- * `PgDialect` does **not** use this constant - it keeps base {@link PgLikeSqlDialect} defaults
- * (`nativeArrays: true`, `explicitJsonCast: false`), since node-`pg` doesn't need the fix.
- * `BunSqlPostgresDialect` and `BunSqlCockroachDialect` both spread this and set
- * `explicitJsonCast: true` - `bun:sql` routes CockroachDB through its own Postgres wire-protocol
- * implementation (see `bunSql.util.ts#normalizeBunOpts`), so it needs the identical fix: verified
- * directly that without it, `$set`/`$push` on a JSONB column silently produce the wrong value
- * or throw on a live CockroachDB instance.
+ * 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. `PgDialect` 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 `NeonDialect` 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/querier/abstractQuerier.js

@@ -1,12 +1,13 @@
 import { assertSoleId, getMeta, idOf, namesKey, soleIdOf } from '../entity/index.js';
-import { asSelectMap, augmentWhere, childrenOf, clone, dataKeyed, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, idOnlyQuery, isScalarId, joinedColumns, keyColumns, LoggerWrapper, isBoundedPerParent, parentJoins, queryChildrenOfAll, parseRelationAtKey, parseRelationQueryValue, rowKey, runHooks, someKey, targetKeyColumns, withoutSoftDeleteFilter, } from '../util/index.js';
+import { asSelectMap, childrenOf, clone, dataKeyed, filterPersistableRelationKeys, forEachRequestedRelation, getKeys, getRelationRequestSummary, idOnlyQuery, isScalarId, joinedColumns, keyColumns, LoggerWrapper, isBoundedPerParent, parentJoins, queryChildrenOfAll, parseRelationAtKey, parseRelationQueryValue, rowKey, runHooks, someKey, targetKeyColumns, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { enrichError } from './queryError.js';
 import { fillRelationCounts, withIdForCounts } from './relationCount.js';
 /**
  * Rejects a nullish primary key before it reaches a statement. The by-id methods reduce to
- * `{ $where: id }`, and a nullish `$where` is *no filter*, so an unchecked one addresses the whole
- * table. An entity declares its id optional, which puts `undefined` inside `IdValue<E>`, and the
- * HTTP layer reaches these methods with parsed JSON regardless, so the guard belongs at runtime.
+ * `{ $where: { id } }`, and a key compared to `undefined` is *no filter*, so an unchecked one
+ * addresses the whole table. An entity declares its id optional, which puts `undefined` inside
+ * `IdValue<E>`, and the HTTP layer reaches these methods with parsed JSON regardless, so the guard
+ * belongs at runtime.
  *
  * Its callers are all `async` so this surfaces as a rejection on every one of them: a guard that
  * threw synchronously from some and rejected from others would escape a caller's `.catch()`.
@@ -16,7 +17,7 @@ function assertIdValue(entity, id) {
         throw new TypeError(`'${entity.name}' was addressed by id, but the id is ${String(id)}`);
     }
     if (isScalarId(id)) {
-        // One value names one column, which `buildQueryWhereAsMap` refuses on a composite.
+        // One value names one column, which `whereIds` refuses on a composite.
         return;
     }
     // Every key, or the `$where` names only some of the columns and addresses each row that agrees on
@@ -119,7 +120,7 @@ export class AbstractQuerier {
     }
     async findOneById(entity, id, q = {}, opts) {
         assertIdValue(entity, id);
-        return this.findOne(entity, { ...q, $where: augmentWhere(getMeta(entity), q.$where, id) }, opts);
+        return this.findOne(entity, { ...q, $where: { ...q.$where, ...whereIds(getMeta(entity), id) } }, opts);
     }
     async findOne(entityOrQuery, maybeQueryOrOpts, maybeOpts) {
         const [entity, q, opts] = this.resolveEntityQuery(entityOrQuery, maybeQueryOrOpts, maybeOpts);
@@ -194,21 +195,21 @@ export class AbstractQuerier {
     }
     async updateOneById(entity, id, payload, opts) {
         assertIdValue(entity, id);
-        return this.updateMany(entity, { $where: id }, payload, opts);
+        return this.updateMany(entity, { $where: whereIds(getMeta(entity), id) }, payload, opts);
     }
     async updateMany(entity, q, payload, opts) {
         return this.hooked(entity, 'Update', [payload], () => this.internalUpdateMany(entity, q, payload, opts));
     }
     async restoreOneById(entity, id) {
         assertIdValue(entity, id);
-        return this.restoreMany(entity, { $where: id });
+        return this.restoreMany(entity, { $where: whereIds(getMeta(entity), id) });
     }
     async restoreMany(entity, q) {
         const meta = getMeta(entity);
         if (!meta.softDelete) {
             throw new TypeError(`'${entity.name}' has not enabled 'softDelete'`);
         }
-        const $where = augmentWhere(meta, q.$where, { [meta.softDelete]: { $ne: null } });
+        const $where = { ...q.$where, [meta.softDelete]: { $ne: null } };
         return this.updateMany(entity, { ...q, $where }, { [meta.softDelete]: null }, {
             filters: { softDelete: false },
         });
@@ -234,7 +235,7 @@ export class AbstractQuerier {
     }
     async deleteOneById(entity, id, opts) {
         assertIdValue(entity, id);
-        return this.deleteMany(entity, { $where: id }, opts);
+        return this.deleteMany(entity, { $where: whereIds(getMeta(entity), id) }, opts);
     }
     async deleteMany(entityOrQuery, qOrOpts, maybeOpts) {
         const [entity, q, opts] = this.resolveEntityQuery(entityOrQuery, qOrOpts, maybeOpts);
@@ -248,7 +249,8 @@ export class AbstractQuerier {
         let target = q;
         if (doomed) {
             const meta = getMeta(entity);
-            target = { $where: doomed.map((it) => idOf(meta, it)) };
+            const ids = doomed.map((it) => idOf(meta, it));
+            target = { $where: whereIds(meta, ids) };
         }
         await this.emitHook(entity, 'beforeDelete', doomed ?? []);
         const changes = await this.internalDeleteMany(entity, target, opts);

package/dist/querier/abstractSqlQuerier.js

@@ -1,7 +1,7 @@
 import { COUNT_ALIAS, TOTAL_ALIAS } from '../dialect/aliases.js';
 import { decodeColumn } from '../dialect/hydrateColumn.js';
 import { getMeta, idOf, soleIdOf } from '../entity/index.js';
-import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, hasKeys, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, withoutSoftDeleteFilter, } from '../util/index.js';
+import { buildUpdateResult, cascadesOnDelete, clone, getInsertFieldKeys, insertShapeOf, getRelationRequestSummary, hasKeys, idOnlyQuery, isAutoIncrement, isPagedQuery, obtainAttrsPaths, throwNoPendingTransaction, throwPendingTransaction, unflatObject, unflatObjects, whereIds, withoutSoftDeleteFilter, } from '../util/index.js';
 import { AbstractQuerier } from './abstractQuerier.js';
 import { enrichError } from './queryError.js';
 /**
@@ -418,7 +418,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
             if (!ids.length) {
                 return 0;
             }
-            target = { $where: ids };
+            target = { $where: whereIds(getMeta(entity), ids) };
         }
         const ctx = this.dialect.createContext();
         this.dialect.update(ctx, entity, target, payload, opts);
@@ -507,7 +507,7 @@ export class AbstractSqlQuerier extends AbstractQuerier {
         // outright by any schema that declares the constraint without `ON DELETE CASCADE`.
         await this.deleteRelations(entity, ids, opts);
         const deleteCtx = this.dialect.createContext();
-        this.dialect.delete(deleteCtx, entity, { $where: ids }, opts);
+        this.dialect.delete(deleteCtx, entity, { $where: whereIds(meta, ids) }, opts);
         const { changes = 0 } = await this.run(deleteCtx.sql, deleteCtx.values);
         return changes;
     }