turbine-orm 0.55.0 → 0.57.0

package/dist/cjs/powql.d.ts

@@ -125,6 +125,17 @@ export declare class PowqlInterface<T extends object = Record<string, unknown>>
      * callers short-circuit it, because PowDB's projection fast path returned ONE
      * row for `limit 0` below 0.20.
      */
+    /**
+     * Refuse the per-query `forceCustomPlan` read option.
+     *
+     * `FindManyArgs.forceCustomPlan` documents an `UnsupportedFeatureError` on any
+     * engine with no PostgreSQL plan cache, and PowDB is one: it is not a
+     * `Dialect` at all, so it never reaches the SQL builder's own refusal at
+     * `preparedNameFor`. Without this the flag would be silently ignored here,
+     * which is precisely the "reports a guarantee that was never made" failure the
+     * option's refusal exists to prevent.
+     */
+    private assertNoForceCustomPlan;
     private assertPagination;
     /** A predicate that is always false, the empty-`in` / contradiction sentinel. */
     private alwaysFalse;

package/dist/cjs/powql.js

@@ -328,6 +328,22 @@ class PowqlInterface {
      * callers short-circuit it, because PowDB's projection fast path returned ONE
      * row for `limit 0` below 0.20.
      */
+    /**
+     * Refuse the per-query `forceCustomPlan` read option.
+     *
+     * `FindManyArgs.forceCustomPlan` documents an `UnsupportedFeatureError` on any
+     * engine with no PostgreSQL plan cache, and PowDB is one: it is not a
+     * `Dialect` at all, so it never reaches the SQL builder's own refusal at
+     * `preparedNameFor`. Without this the flag would be silently ignored here,
+     * which is precisely the "reports a guarantee that was never made" failure the
+     * option's refusal exists to prevent.
+     */
+    assertNoForceCustomPlan(args) {
+        if (args?.forceCustomPlan !== true)
+            return;
+        throw new errors_js_1.UnsupportedFeatureError('The forceCustomPlan query option', 'powdb', 'Forcing a per-query custom plan means keeping the statement out of the PostgreSQL plan cache, and PowDB ' +
+            'has no such cache to keep it out of. Remove the option, or set it only on PostgreSQL queries.');
+    }
     assertPagination(limit, offset, context) {
         for (const [name, value] of [
             ['limit', limit],
@@ -1157,6 +1173,7 @@ class PowqlInterface {
     // Reads
     // -------------------------------------------------------------------------
     async findMany(args = {}) {
+        this.assertNoForceCustomPlan(args);
         return this.withMiddleware('findMany', args, async () => {
             // `limit: 0` means "no rows" (SQL `LIMIT 0`), and answering it client-side
             // is correct on every engine version: PowDB's projection fast path returned
@@ -1296,6 +1313,7 @@ class PowqlInterface {
             .filter((line) => line.length > 0);
     }
     async findUnique(args) {
+        this.assertNoForceCustomPlan(args);
         // Prisma compound-unique selector → column conjunction (engine parity with
         // the SQL findUnique family; pure metadata, so this is a one-line adoption).
         if (args.where) {
@@ -1318,6 +1336,7 @@ class PowqlInterface {
         });
     }
     async findFirst(args = {}) {
+        this.assertNoForceCustomPlan(args);
         return this.withMiddleware('findFirst', args, async () => {
             const { rows, native, nestedPlans, linkPlans, residualWith } = await this.runFind({ ...args, limit: 1 }, 'findFirst');
             if (!rows.length)
@@ -2524,6 +2543,7 @@ class PowqlInterface {
     // Aggregates
     // -------------------------------------------------------------------------
     async count(args = {}) {
+        this.assertNoForceCustomPlan(args);
         return this.withMiddleware('count', (args ?? {}), async () => {
             const params = [];
             const resolvedWhere = await this.resolveRelationFilters(args.where, args.timeout);
@@ -2562,6 +2582,7 @@ class PowqlInterface {
             '`_count` of a NOT NULL column are correct on every version and are never refused.');
     }
     async aggregate(args) {
+        this.assertNoForceCustomPlan(args);
         return this.withMiddleware('aggregate', args, async () => {
             // One scalar query per aggregate, PowDB's bare-projection aggregate is broken.
             const result = {};
@@ -2607,6 +2628,7 @@ class PowqlInterface {
         });
     }
     async groupBy(args) {
+        this.assertNoForceCustomPlan(args);
         return this.withMiddleware('groupBy', args, async () => {
             // DISTINCT ON has no PowQL equivalent (no DISTINCT ON row source).
             if (args.distinctOn) {

package/dist/cjs/prisma-compat.d.ts

@@ -31,6 +31,15 @@
  *   atomic.
  * - **Result reshaping**: `_count` objects keyed back to Prisma relation names,
  *   and to-one relations surfaced as `object | null`.
+ * - **Turbine-native query options** (`timeout`, `forceCustomPlan`,
+ *   `warnOnUnlimited`, `skipGlobalFilters`, `stableRelationOrder`,
+ *   `allowFullTableScan`, `includePii`, `optimisticLock`, `distinctOn`) reach
+ *   core on every operation whose arg surface declares them. The set is not a
+ *   hand-maintained list here: it comes from the compiler-checked tables in
+ *   `query/option-surface.ts`, so a new core option cannot be silently stranded
+ *   by this layer, and a key that is neither a Prisma arg nor a turbine option
+ *   gets a dev-mode warning instead of vanishing (see
+ *   {@link PRISMA_ARG_KEYS} and `warnUnknownQueryOptions`).
  *
  * ## What it deliberately does NOT do (documented divergences)
  *
@@ -63,6 +72,14 @@
  *   exclusive-cursor + `offset` translation.
  * - **Negative `take`** (take-from-end) and **`skip` on a nested relation
  *   include** throw, Turbine's `with` clause has no offset and no reverse-take.
+ * - **`limit` on `updateMany` / `deleteMany`** (Prisma 6.7+) throws. Turbine has
+ *   no row-bounded mass mutation, and dropping a SAFETY BOUND with a warning
+ *   would turn "change at most 10 rows" into "change every matching row".
+ * - **Write projections** (`select` / `include` / `omit` on
+ *   create/update/delete/upsert), **`select` on `count`**, and
+ *   **`orderBy` / `cursor` / `take` / `skip` on `aggregate`** are accepted and
+ *   IGNORED (they are legitimate Prisma, so they never warn); the full row / a
+ *   plain number comes back.
  *
  * ## Type dependencies (0.41.0)
  *
@@ -93,7 +110,7 @@
  * ```
  */
 import type { TurbineClient } from './client.js';
-import type { DeferredQuery } from './query/index.js';
+import { type DeferredQuery } from './query/index.js';
 import type { PrismaCompatMap, SchemaMetadata } from './schema.js';
 /** A build-only query object with the `build*` methods the adapter drives. */
 export interface CompatQueryInterface {
@@ -237,6 +254,20 @@ export interface PrismaCompatOptions {
      */
     prismaErrorCodes?: boolean;
 }
+/** The delegate operations this adapter exposes. */
+export type CompatOperation = 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'create' | 'createMany' | 'update' | 'updateMany' | 'delete' | 'deleteMany' | 'upsert' | 'count' | 'aggregate' | 'groupBy';
+/**
+ * Every argument key Prisma itself accepts, per operation.
+ *
+ * Extracted from a generated `@prisma/client` 7.9.0 `index.d.ts` (the
+ * `<Model><Op>Args` blocks). It must stay the UNION across the Prisma majors
+ * this adapter supports, never one version's set: a key a newer major
+ * introduces should degrade to one noisy dev line, never to a throw, and a key
+ * an older major had must keep working. The drift test in
+ * `src/test/prisma-compat-option-surface.test.ts` re-extracts from a generated
+ * client when one is present and asserts this stays a superset.
+ */
+export declare const PRISMA_ARG_KEYS: Record<CompatOperation, readonly string[]>;
 /** Symbol under which a lazy delegate call exposes its batchable plan. */
 export declare const COMPAT_DEFERRED: unique symbol;
 /**

package/dist/cjs/prisma-compat.js

@@ -32,6 +32,15 @@
  *   atomic.
  * - **Result reshaping**: `_count` objects keyed back to Prisma relation names,
  *   and to-one relations surfaced as `object | null`.
+ * - **Turbine-native query options** (`timeout`, `forceCustomPlan`,
+ *   `warnOnUnlimited`, `skipGlobalFilters`, `stableRelationOrder`,
+ *   `allowFullTableScan`, `includePii`, `optimisticLock`, `distinctOn`) reach
+ *   core on every operation whose arg surface declares them. The set is not a
+ *   hand-maintained list here: it comes from the compiler-checked tables in
+ *   `query/option-surface.ts`, so a new core option cannot be silently stranded
+ *   by this layer, and a key that is neither a Prisma arg nor a turbine option
+ *   gets a dev-mode warning instead of vanishing (see
+ *   {@link PRISMA_ARG_KEYS} and `warnUnknownQueryOptions`).
  *
  * ## What it deliberately does NOT do (documented divergences)
  *
@@ -64,6 +73,14 @@
  *   exclusive-cursor + `offset` translation.
  * - **Negative `take`** (take-from-end) and **`skip` on a nested relation
  *   include** throw, Turbine's `with` clause has no offset and no reverse-take.
+ * - **`limit` on `updateMany` / `deleteMany`** (Prisma 6.7+) throws. Turbine has
+ *   no row-bounded mass mutation, and dropping a SAFETY BOUND with a warning
+ *   would turn "change at most 10 rows" into "change every matching row".
+ * - **Write projections** (`select` / `include` / `omit` on
+ *   create/update/delete/upsert), **`select` on `count`**, and
+ *   **`orderBy` / `cursor` / `take` / `skip` on `aggregate`** are accepted and
+ *   IGNORED (they are legitimate Prisma, so they never warn); the full row / a
+ *   plain number comes back.
  *
  * ## Type dependencies (0.41.0)
  *
@@ -94,10 +111,12 @@
  * ```
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLIENT_RESERVED_KEYS = exports.COMPAT_DEFERRED = exports.Prisma = void 0;
+exports.CLIENT_RESERVED_KEYS = exports.COMPAT_DEFERRED = exports.PRISMA_ARG_KEYS = exports.Prisma = void 0;
 exports.createPrismaCompatClient = createPrismaCompatClient;
 const errors_js_1 = require("./errors.js");
 const nested_write_js_1 = require("./nested-write.js");
+const index_js_1 = require("./query/index.js");
+const utils_js_1 = require("./query/utils.js");
 const warn_registry_js_1 = require("./query/warn-registry.js");
 // ---------------------------------------------------------------------------
 // Prisma.sql-style raw fragments (local, minimal, never imports @prisma/client)
@@ -256,6 +275,199 @@ function isPlainObject(v) {
 function renameField(mm, prismaField) {
     return mm.fields[prismaField] ?? prismaField;
 }
+/** The turbine arg surface each operation compiles into. */
+const OPERATION_TABLES = {
+    findMany: index_js_1.FIND_MANY_OPTIONS,
+    findFirst: index_js_1.FIND_MANY_OPTIONS,
+    findFirstOrThrow: index_js_1.FIND_MANY_OPTIONS,
+    findUnique: index_js_1.FIND_UNIQUE_OPTIONS,
+    findUniqueOrThrow: index_js_1.FIND_UNIQUE_OPTIONS,
+    create: index_js_1.CREATE_OPTIONS,
+    createMany: index_js_1.CREATE_MANY_OPTIONS,
+    update: index_js_1.UPDATE_OPTIONS,
+    updateMany: index_js_1.UPDATE_MANY_OPTIONS,
+    delete: index_js_1.DELETE_OPTIONS,
+    deleteMany: index_js_1.DELETE_MANY_OPTIONS,
+    upsert: index_js_1.UPSERT_OPTIONS,
+    count: index_js_1.COUNT_OPTIONS,
+    aggregate: index_js_1.AGGREGATE_OPTIONS,
+    groupBy: index_js_1.GROUP_BY_OPTIONS,
+};
+/**
+ * Every argument key Prisma itself accepts, per operation.
+ *
+ * Extracted from a generated `@prisma/client` 7.9.0 `index.d.ts` (the
+ * `<Model><Op>Args` blocks). It must stay the UNION across the Prisma majors
+ * this adapter supports, never one version's set: a key a newer major
+ * introduces should degrade to one noisy dev line, never to a throw, and a key
+ * an older major had must keep working. The drift test in
+ * `src/test/prisma-compat-option-surface.test.ts` re-extracts from a generated
+ * client when one is present and asserts this stays a superset.
+ */
+exports.PRISMA_ARG_KEYS = {
+    findMany: [
+        'select',
+        'omit',
+        'include',
+        'where',
+        'orderBy',
+        'cursor',
+        'take',
+        'skip',
+        'distinct',
+        'relationLoadStrategy',
+    ],
+    findFirst: [
+        'select',
+        'omit',
+        'include',
+        'where',
+        'orderBy',
+        'cursor',
+        'take',
+        'skip',
+        'distinct',
+        'relationLoadStrategy',
+    ],
+    findFirstOrThrow: [
+        'select',
+        'omit',
+        'include',
+        'where',
+        'orderBy',
+        'cursor',
+        'take',
+        'skip',
+        'distinct',
+        'relationLoadStrategy',
+    ],
+    findUnique: ['select', 'omit', 'include', 'where', 'relationLoadStrategy'],
+    findUniqueOrThrow: ['select', 'omit', 'include', 'where', 'relationLoadStrategy'],
+    create: ['select', 'omit', 'include', 'data', 'relationLoadStrategy'],
+    createMany: ['data', 'skipDuplicates'],
+    update: ['select', 'omit', 'include', 'data', 'where', 'relationLoadStrategy'],
+    updateMany: ['data', 'where', 'limit'],
+    delete: ['select', 'omit', 'include', 'where', 'relationLoadStrategy'],
+    deleteMany: ['where', 'limit'],
+    upsert: ['select', 'omit', 'include', 'where', 'create', 'update', 'relationLoadStrategy'],
+    count: ['where', 'orderBy', 'cursor', 'take', 'skip', 'select'],
+    aggregate: ['where', 'orderBy', 'cursor', 'take', 'skip', '_count', '_avg', '_sum', '_min', '_max'],
+    groupBy: ['where', 'orderBy', 'by', 'having', 'take', 'skip', '_count', '_avg', '_sum', '_min', '_max'],
+};
+/**
+ * Turbine spellings whose Prisma equivalent is spelled differently. A caller
+ * who reaches for one of these is not confused about the NAME, they are
+ * confused about which surface they are on, so they get a specific message
+ * rather than a fuzzy did-you-mean.
+ */
+const ALIAS_HINT = {
+    limit: 'take',
+    offset: 'skip',
+    with: 'include',
+};
+/**
+ * Known(op) = Prisma's own keys for that operation, plus every key the
+ * operation's turbine arg surface declares except the `'internal'` ones.
+ *
+ * The second half is NOT just the `'native'` keys. Two turbine-only options are
+ * classified `'prisma'` because their values carry field names and so must be
+ * hand-translated (`optimisticLock`, `distinctOn`); they are fully honoured, and
+ * warning about a key the adapter just acted on would be the worst possible
+ * diagnostic. `'nativeAlias'` members are in the set on purpose too: `limit` on
+ * `findMany` IS recognized, it simply gets the alias message rather than the
+ * generic one. Only `'internal'` is excluded, because nothing on this surface
+ * can reach it.
+ *
+ * A `Set` rather than an `in` test on a record, so an inherited
+ * `Object.prototype` name (`toString`, `constructor`) is treated as the unknown
+ * key it is.
+ */
+const KNOWN_KEYS = (() => {
+    const out = {};
+    for (const op of Object.keys(OPERATION_TABLES)) {
+        out[op] = new Set([
+            ...exports.PRISMA_ARG_KEYS[op],
+            ...(0, index_js_1.optionKeysOfKind)(OPERATION_TABLES[op], 'prisma', 'native', 'nativeAlias'),
+        ]);
+    }
+    return out;
+})();
+/**
+ * Dev-mode notice for a key on a delegate's args object that this operation has
+ * no meaning for.
+ *
+ * An unrecognized key is silently ignored (JavaScript objects have no schema),
+ * which makes a typo, a turbine spelling, and a genuinely missing feature all
+ * look identical: nothing happens. The client-config warner
+ * (`warnUnknownConfigKeys` in client.ts) exists for the same reason and this is
+ * its query-level twin, down to the ranking of the suggestion.
+ *
+ * Deliberately a WARNING, never an error. Throwing would turn a working app
+ * into a failing one on upgrade over one stray key, and a key from a Prisma
+ * major newer than {@link PRISMA_ARG_KEYS} would be exactly that key. The whole
+ * body is wrapped so a hostile or exotic args object (a Proxy whose `ownKeys`
+ * throws) can never be the reason a query fails. Dev-only and once per
+ * `model.operation.key` per process, like every other advisory here.
+ */
+function warnUnknownQueryOptions(model, op, args) {
+    if (process.env.NODE_ENV === 'production')
+        return;
+    if (!isPlainObject(args))
+        return;
+    try {
+        const known = KNOWN_KEYS[op];
+        const table = OPERATION_TABLES[op];
+        for (const key of Object.keys(args)) {
+            // `{ ...maybeOptions }` routinely materializes keys with no value.
+            // Nothing is being dropped when the value is undefined.
+            if (args[key] === undefined)
+                continue;
+            const alias = table[key] === 'nativeAlias' ? ALIAS_HINT[key] : undefined;
+            if (!alias && known.has(key))
+                continue;
+            if (!(0, warn_registry_js_1.shouldWarnOnce)(warn_registry_js_1.WARN_NS.unknownQueryOption, `${model}.${op}.${key}`))
+                continue;
+            if (alias) {
+                console.warn(`[turbine] prisma-compat: "${key}" is Turbine's spelling and is ignored here;` +
+                    ` prisma-compat takes Prisma's "${alias}". (${model}.${op})`);
+                continue;
+            }
+            const suggestion = (0, utils_js_1.suggestKey)(key, known);
+            console.warn(`[turbine] prisma-compat: unknown option "${key}" in ${model}.${op}(), it is ignored.` +
+                (suggestion ? ` Did you mean "${suggestion}"?` : ''));
+        }
+    }
+    catch {
+        // Key enumeration is the only thing that can fail here, and a diagnostic
+        // must never be the reason a query fails.
+    }
+}
+/**
+ * Prisma 6.7+ accepts `limit` on `updateMany` / `deleteMany` to BOUND how many
+ * rows a mass mutation touches. Turbine has no row-bounded mass mutation, so
+ * this one is refused rather than warned about: everywhere else in this design
+ * a dropped option costs the caller a feature, but silently dropping a safety
+ * bound turns "change at most 10 rows" into "change every row".
+ */
+function refuseRowLimit(model, op, args) {
+    if (!isPlainObject(args) || args.limit === undefined)
+        return;
+    throw new errors_js_1.UnsupportedFeatureError(`\`limit\` on ${op} (row-bounded mass mutation)`, 'prisma-compat', `Turbine has no row-bounded ${op}; select the rows you mean with \`where\`` +
+        ` (on ${model}.${op}), or page them and mutate by primary key.`);
+}
+/**
+ * Prisma's `relationLoadStrategy` and Turbine's share a name and NOT a value
+ * domain: Prisma has `'query' | 'join'`, Turbine has
+ * `'join' | 'batched' | 'auto' | 'flatten'`. Core's strategy resolution has no
+ * branch for `'query'` and returns the value unchanged, so forwarding it
+ * verbatim gave a caller who asked for the per-relation query plan the JOIN
+ * plan, the exact opposite of the request. Prisma's `'query'` IS Turbine's
+ * `'batched'` (one follow-up statement per relation); the turbine-only values
+ * pass through so a compat caller can still reach them.
+ */
+function mapRelationLoadStrategy(value) {
+    return value === 'query' ? 'batched' : value;
+}
 /**
  * Translate a Prisma `where` (or nested relation where) into a Turbine `where`.
  * Renames scalar field keys and relation keys through the map, recurses into
@@ -450,6 +662,13 @@ function modelName(ctx, mm) {
  */
 function translateReadArgs(ctx, mm, prismaArgs, kind) {
     const t = {};
+    // FIRST, so a per-call `stableRelationOrder` overrides it: the client-level
+    // option is a default, the arg is an instruction.
+    if (ctx.options.stablePkOrder)
+        t.stableRelationOrder = true;
+    // Every turbine-native option the arg surface declares, in one line that
+    // cannot fall behind the interface (see the option-surface tables).
+    (0, index_js_1.applyNativeOptions)(kind === 'unique' ? index_js_1.FIND_UNIQUE_OPTIONS : index_js_1.FIND_MANY_OPTIONS, prismaArgs, t);
     if (prismaArgs.where !== undefined)
         t.where = translateWhere(ctx, mm, prismaArgs.where);
     if (prismaArgs.orderBy !== undefined)
@@ -462,17 +681,9 @@ function translateReadArgs(ctx, mm, prismaArgs, kind) {
     if (Array.isArray(prismaArgs.distinct)) {
         t.distinct = prismaArgs.distinct.map((f) => renameField(mm, f));
     }
-    if (prismaArgs.relationLoadStrategy !== undefined)
-        t.relationLoadStrategy = prismaArgs.relationLoadStrategy;
-    if (typeof prismaArgs.timeout === 'number')
-        t.timeout = prismaArgs.timeout;
-    // Turbine-only passthrough. Prisma has no PII concept, so a compat caller
-    // whose schema tags columns needs SOME way to opt in; without this the
-    // adapter is a one-way door into redacted reads and refused aggregates.
-    if (prismaArgs.includePii !== undefined)
-        t.includePii = prismaArgs.includePii;
-    if (ctx.options.stablePkOrder)
-        t.stableRelationOrder = true;
+    if (prismaArgs.relationLoadStrategy !== undefined) {
+        t.relationLoadStrategy = mapRelationLoadStrategy(prismaArgs.relationLoadStrategy);
+    }
     // ORDER IS LOAD-BEARING: translateCursor MUST run BEFORE applyImplicitPkOrder.
     // The cursor translation reads `t.orderBy` to decide the seek direction and to
     // validate that a bare inclusive cursor names the sort key; it must see the
@@ -771,6 +982,7 @@ function translateUpsertNested(ctx, target, p) {
 const AGG_FIELD_BLOCKS = ['_sum', '_avg', '_min', '_max'];
 function translateAggregateArgs(ctx, mm, args, isGroupBy) {
     const t = {};
+    (0, index_js_1.applyNativeOptions)(isGroupBy ? index_js_1.GROUP_BY_OPTIONS : index_js_1.AGGREGATE_OPTIONS, args, t);
     if (args.where !== undefined)
         t.where = translateWhere(ctx, mm, args.where);
     if (args._count !== undefined)
@@ -779,12 +991,6 @@ function translateAggregateArgs(ctx, mm, args, isGroupBy) {
         if (args[block] !== undefined)
             t[block] = renameAggBlock(mm, args[block], false);
     }
-    if (typeof args.timeout === 'number')
-        t.timeout = args.timeout;
-    // Turbine-only passthrough: the PII gate on groupBy keys and _min/_max needs
-    // an opt-in that Prisma's arg shape has no equivalent for.
-    if (args.includePii !== undefined)
-        t.includePii = args.includePii;
     if (isGroupBy) {
         if (Array.isArray(args.by))
             t.by = args.by.map((f) => renameField(mm, f));
@@ -792,6 +998,8 @@ function translateAggregateArgs(ctx, mm, args, isGroupBy) {
             t.orderBy = translateOrderBy(ctx, mm, args.orderBy);
         if (args.having !== undefined)
             t.having = renameHaving(mm, args.having);
+        if (args.distinctOn !== undefined)
+            t.distinctOn = translateDistinctOn(ctx, mm, args.distinctOn);
         if (typeof args.take === 'number')
             t.limit = mapTake(args.take);
         if (typeof args.skip === 'number')
@@ -799,6 +1007,23 @@ function translateAggregateArgs(ctx, mm, args, isGroupBy) {
     }
     return t;
 }
+/**
+ * Translate a turbine-native groupBy `distinctOn`. Both halves of its value
+ * (`columns`, `orderBy`) are FIELD NAMES, so this is the concrete reason the
+ * option surface refuses to copy unknown keys through by default: a blind
+ * passthrough is correct on a model whose Prisma and turbine names coincide and
+ * silently wrong on one with a `@map`.
+ */
+function translateDistinctOn(ctx, mm, val) {
+    if (!isPlainObject(val))
+        return val;
+    const out = { ...val };
+    if (Array.isArray(val.columns))
+        out.columns = val.columns.map((f) => renameField(mm, f));
+    if (val.orderBy !== undefined)
+        out.orderBy = translateOrderBy(ctx, mm, val.orderBy);
+    return out;
+}
 /** Rename field keys inside an aggregate block; `_count`'s `_all` passes through. */
 function renameAggBlock(mm, block, isCount) {
     if (block === true || !isPlainObject(block))
@@ -1143,6 +1368,8 @@ async function createManyByRun(qi, t, runs) {
         const args = { data: run };
         if (t.skipDuplicates)
             args.skipDuplicates = true;
+        if (t.timeout !== undefined)
+            args.timeout = t.timeout;
         count += (await qi.createMany(args)).length;
     }
     return { count };
@@ -1158,7 +1385,14 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
     // async run wrapper also converts any synchronous throw from the underlying
     // `qi.*` build into a rejection; the array `$transaction([...])` batch path
     // catches the same throw from `batch.build`.
-    const defer = (translate, run, batch) => {
+    const defer = (op, rawArgs, translateRaw, run, batch) => {
+        // The unknown-key check rides the SAME deferred boundary as the translation
+        // itself, for the same reason (see the comment above): a compat promise that
+        // is built and never awaited must produce no output at all.
+        const translate = () => {
+            warnUnknownQueryOptions(modelName(ctx, mm), op, rawArgs);
+            return translateRaw();
+        };
         const batchable = batch
             ? {
                 build: () => batch.build(getQI(), translate()),
@@ -1198,27 +1432,27 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
         return args;
     };
     return {
-        findMany: (args = {}) => defer(() => translateReadArgs(ctx, mm, args, 'many'), (qi, t) => qi.findMany(t).then((r) => reshapeRows(ctx, mm, r)), { build: (qi, t) => qi.buildFindMany(t), reshape: (raw) => reshapeRows(ctx, mm, raw) }),
-        findFirst: (args = {}) => defer(() => translateReadArgs(ctx, mm, args, 'first'), (qi, t) => qi.findFirst(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirst(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
-        findUnique: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUnique'), 'unique'), (qi, t) => qi.findUnique(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindUnique(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
-        findFirstOrThrow: (args = {}) => defer(() => translateReadArgs(ctx, mm, args, 'first'), (qi, t) => qi.findFirstOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
-        findUniqueOrThrow: (args) => defer(() => translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow'), 'unique'), (qi, t) => qi.findUniqueOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
-        create: (args) => defer(() => {
+        findMany: (args = {}) => defer('findMany', args, () => translateReadArgs(ctx, mm, args, 'many'), (qi, t) => qi.findMany(t).then((r) => reshapeRows(ctx, mm, r)), { build: (qi, t) => qi.buildFindMany(t), reshape: (raw) => reshapeRows(ctx, mm, raw) }),
+        findFirst: (args = {}) => defer('findFirst', args, () => translateReadArgs(ctx, mm, args, 'first'), (qi, t) => qi.findFirst(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirst(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
+        findUnique: (args) => defer('findUnique', args, () => translateReadArgs(ctx, mm, requireWhere(args, 'findUnique'), 'unique'), (qi, t) => qi.findUnique(t).then((r) => reshapeRowOrNull(ctx, mm, r)), { build: (qi, t) => qi.buildFindUnique(t), reshape: (raw) => reshapeRowOrNull(ctx, mm, raw) }),
+        findFirstOrThrow: (args = {}) => defer('findFirstOrThrow', args, () => translateReadArgs(ctx, mm, args, 'first'), (qi, t) => qi.findFirstOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindFirstOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        findUniqueOrThrow: (args) => defer('findUniqueOrThrow', args, () => translateReadArgs(ctx, mm, requireWhere(args, 'findUniqueOrThrow'), 'unique'), (qi, t) => qi.findUniqueOrThrow(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildFindUniqueOrThrow(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
+        create: (args) => defer('create', args, () => {
             const t = { data: translateWriteData(ctx, mm, applyCreateDefaults(mm, args.data)) };
-            if (typeof args.timeout === 'number')
-                t.timeout = args.timeout;
+            (0, index_js_1.applyNativeOptions)(index_js_1.CREATE_OPTIONS, args, t);
             return t;
         }, (qi, t) => qi.create(t).then((r) => reshapeRow(ctx, mm, r)), {
             build: (qi, t) => qi.buildCreate(t),
             reshape: (raw) => reshapeRow(ctx, mm, raw),
             nested: (t) => hasNestedKeys(ctx, mm, t.data),
         }),
-        createMany: (args) => defer(() => {
+        createMany: (args) => defer('createMany', args, () => {
             const data = args.data;
             const rows = Array.isArray(data)
                 ? data.map((d) => translateWriteData(ctx, mm, applyCreateDefaults(mm, d)))
                 : [];
             const t = { data: rows };
+            (0, index_js_1.applyNativeOptions)(index_js_1.CREATE_MANY_OPTIONS, args, t);
             if (args.skipDuplicates)
                 t.skipDuplicates = true;
             return t;
@@ -1239,45 +1473,68 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
             nested: (t) => createManyRunsOf(t).length > 1,
             execInTx: (table, t) => createManyByRun(table(mm.table), t, createManyRunsOf(t)),
         }),
-        update: (args) => defer(() => {
+        update: (args) => defer('update', args, () => {
             const a = requireWhere(args, 'update');
-            return {
+            const t = {
                 where: translateWhere(ctx, mm, a.where),
                 data: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.data)),
             };
+            (0, index_js_1.applyNativeOptions)(index_js_1.UPDATE_OPTIONS, a, t);
+            // `optimisticLock.field` is a FIELD NAME, so it is renamed rather than
+            // copied: a blind passthrough would send the Prisma spelling into core
+            // and break on any model whose column is `@map`ped.
+            if (isPlainObject(a.optimisticLock)) {
+                t.optimisticLock = {
+                    ...a.optimisticLock,
+                    field: renameField(mm, String(a.optimisticLock.field)),
+                };
+            }
+            return t;
         }, (qi, t) => qi.update(t).then((r) => reshapeRow(ctx, mm, r)), {
             build: (qi, t) => qi.buildUpdate(t),
             reshape: (raw) => reshapeRow(ctx, mm, raw),
             nested: (t) => hasNestedKeys(ctx, mm, t.data),
         }),
-        updateMany: (args) => defer(() => {
+        updateMany: (args) => defer('updateMany', args, () => {
             const a = args;
+            refuseRowLimit(modelName(ctx, mm), 'updateMany', a);
             const t = {
                 where: translateWhere(ctx, mm, a.where ?? {}),
                 data: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.data)),
             };
+            (0, index_js_1.applyNativeOptions)(index_js_1.UPDATE_MANY_OPTIONS, a, t);
+            // LAST, so it wins: a Prisma updateMany with no `where` affects every
+            // row, and an explicit `allowFullTableScan: false` must not be able to
+            // turn that parity into a thrown empty-where guard.
             if (a.where === undefined)
                 t.allowFullTableScan = true;
             return t;
         }, (qi, t) => qi.updateMany(t), { build: (qi, t) => qi.buildUpdateMany(t), reshape: (raw) => raw }),
-        delete: (args) => defer(() => {
+        delete: (args) => defer('delete', args, () => {
             const a = requireWhere(args, 'delete');
-            return { where: translateWhere(ctx, mm, a.where) };
+            const t = { where: translateWhere(ctx, mm, a.where) };
+            (0, index_js_1.applyNativeOptions)(index_js_1.DELETE_OPTIONS, a, t);
+            return t;
         }, (qi, t) => qi.delete(t).then((r) => reshapeRow(ctx, mm, r)), { build: (qi, t) => qi.buildDelete(t), reshape: (raw) => reshapeRow(ctx, mm, raw) }),
-        deleteMany: (args = {}) => defer(() => {
+        deleteMany: (args = {}) => defer('deleteMany', args, () => {
             const a = args;
+            refuseRowLimit(modelName(ctx, mm), 'deleteMany', a);
             const t = { where: translateWhere(ctx, mm, a.where ?? {}) };
+            (0, index_js_1.applyNativeOptions)(index_js_1.DELETE_MANY_OPTIONS, a, t);
+            // LAST, so it wins. See the same note on updateMany.
             if (a.where === undefined)
                 t.allowFullTableScan = true;
             return t;
         }, (qi, t) => qi.deleteMany(t), { build: (qi, t) => qi.buildDeleteMany(t), reshape: (raw) => raw }),
-        upsert: (args) => defer(() => {
+        upsert: (args) => defer('upsert', args, () => {
             const a = requireWhere(args, 'upsert');
-            return {
+            const t = {
                 where: translateWhere(ctx, mm, a.where),
                 create: translateWriteData(ctx, mm, applyCreateDefaults(mm, a.create)),
                 update: translateWriteData(ctx, mm, applyUpdateTouch(mm, a.update)),
             };
+            (0, index_js_1.applyNativeOptions)(index_js_1.UPSERT_OPTIONS, a, t);
+            return t;
         }, (qi, t) => {
             // Native ON CONFLICT upsert is only Prisma-equivalent when the where
             // key values equal the create values AND no nested write data is
@@ -1300,16 +1557,15 @@ function makeDelegate(ctx, mm, getQI, runInTx) {
                 return reshapeRow(ctx, mm, await upsertLookupFirst(table(mm.table), t));
             },
         }),
-        count: (args = {}) => defer(() => {
+        count: (args = {}) => defer('count', args, () => {
             const t = {};
+            (0, index_js_1.applyNativeOptions)(index_js_1.COUNT_OPTIONS, args, t);
             if (args.where !== undefined)
                 t.where = translateWhere(ctx, mm, args.where);
-            if (typeof args.timeout === 'number')
-                t.timeout = args.timeout;
             return t;
         }, (qi, t) => qi.count(t), { build: (qi, t) => qi.buildCount(t), reshape: (raw) => raw }),
-        aggregate: (args) => defer(() => translateAggregateArgs(ctx, mm, args, false), (qi, t) => qi.aggregate(t).then((r) => reshapeAggregate(ctx, mm, r)), { build: (qi, t) => qi.buildAggregate(t), reshape: (raw) => reshapeAggregate(ctx, mm, raw) }),
-        groupBy: (args) => defer(() => translateAggregateArgs(ctx, mm, args, true), (qi, t) => qi.groupBy(t).then((rows) => rows.map((r) => reshapeGroupRow(ctx, mm, r))), {
+        aggregate: (args) => defer('aggregate', args, () => translateAggregateArgs(ctx, mm, args, false), (qi, t) => qi.aggregate(t).then((r) => reshapeAggregate(ctx, mm, r)), { build: (qi, t) => qi.buildAggregate(t), reshape: (raw) => reshapeAggregate(ctx, mm, raw) }),
+        groupBy: (args) => defer('groupBy', args, () => translateAggregateArgs(ctx, mm, args, true), (qi, t) => qi.groupBy(t).then((rows) => rows.map((r) => reshapeGroupRow(ctx, mm, r))), {
             build: (qi, t) => qi.buildGroupBy(t),
             reshape: (raw) => raw.map((r) => reshapeGroupRow(ctx, mm, r)),
         }),