@vsrepo/prisma7-adapter 1.3.2 → 2.0.0-dev.1

package/dist/parsers/where.parser.js

@@ -1,71 +1,27 @@
-"use strict";
-/**
- * Parser que converte um `VSRepoWhere<T>` (formato "amigável" da aplicação)
- * em um `where` válido de qualquer modelo do Prisma.
- *
- * Suporta:
- *  - Valor direto:               { name: "Ana" }
- *  - Operadores de campo:        { age: { gte: 18, lte: 65 } }
- *  - `between`:                  { age: { between: [18, 65] } } -> { gte: 18, lte: 65 }
- *  - `not` (valor ou operador):  { name: { not: "Ana" } }
- *                                { name: { not: { contains: "an" } } }
- *  - Strings case-insensitive:   { name: { contains: "ana", ignoreCase: true } }
- *                                -> { contains: "ana", mode: "insensitive" }
- *  - Relação lista (array):      { posts: { _some: { title: "x" } } } -> { posts: { some: {...} } }
- *  - Relação objeto (to-one):    { author: { _with: { id: 1 } } }    -> { author: { is: {...} } }
- *                                { author: { _without: { id: 1 } } } -> { author: { isNot: {...} } }
- *  - Lógicos no nível raiz:      { AND: [...] , OR: [...], NOT: {...} }
- *
- * Reflete a tipagem atual: `AND`/`OR`/`NOT` só existem em `VSRepoWhere<T>`
- * (nível raiz). Dentro de relações (`_some`/`_every`/`_none`/`_with`/
- * `_without`), o tipo usado é `VSRepoWherePlain<U>`, que NÃO tem esses
- * operadores lógicos — por isso a recursão para relações usa
- * `parsePlainWhere`, e não `parseWhere`.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaWhere = parsePrismaWhere;
-const is_decimal_validator_1 = require("../validators/is-decimal.validator");
-const is_plain_object_validator_1 = require("../validators/is-plain-object.validator");
-/** Chaves reconhecidas como operadores de campo do VSRepoFieldOperators */
-const FIELD_OPERATOR_KEYS = new Set([
-    "equals",
-    "not",
-    "in",
-    "notIn",
-    "gt",
-    "gte",
-    "lt",
-    "lte",
-    "between",
-    "contains",
-    "startsWith",
-    "endsWith",
-    "ignoreCase",
-]);
+import { AdapterErrorCode, VSRepoAdapterError } from "vsrepo";
+import { INSENSITIVE_MODE_PROVIDERS } from "../constants/provider-capabilities.constant.js";
+import { isPlainObject } from "../validators/is-plain-object.validator.js";
 const LOGICAL_KEYS = new Set(["AND", "OR", "NOT"]);
-/** Verifica se um objeto "parece" um VSRepoFieldOperators (e não um filtro de relação/nested where) */
-function isFieldOperatorObject(value) {
-    return Object.keys(value).some(key => FIELD_OPERATOR_KEYS.has(key));
-}
-function isArrayRelationFilter(value) {
-    return "_some" in value || "_every" in value || "_none" in value;
-}
-function isObjectRelationFilter(value) {
-    return "_with" in value || "_without" in value;
-}
-/**
- * Converte um VSRepoFieldOperators<V> em um filtro de campo do Prisma.
- */
-function parseFieldOperators(value) {
+function parseFieldValue(value, provider) {
+    if (!isPlainObject(value)) {
+        return value;
+    }
     const result = {};
-    const ignoreCase = value.ignoreCase === true;
     for (const [key, val] of Object.entries(value)) {
         if (val === undefined)
             continue;
         switch (key) {
-            case "ignoreCase":
-                // tratado à parte, no final (vira `mode`)
+            case "ignoreCase": {
+                if (val !== true)
+                    break;
+                if (provider && !INSENSITIVE_MODE_PROVIDERS.has(provider)) {
+                    throw new VSRepoAdapterError(`The 'ignoreCase' option is not supported by the '${provider}' provider, since Prisma only ` +
+                        `supports case-insensitive filtering on PostgreSQL and CockroachDB. ` +
+                        `Remove 'ignoreCase' to filter using the database's own collation rules.`, AdapterErrorCode.NOT_SUPPORTED, null);
+                }
+                result.mode = "insensitive";
                 break;
+            }
             case "between": {
                 const [min, max] = val;
                 if (min !== undefined)
@@ -75,111 +31,56 @@ function parseFieldOperators(value) {
                 break;
             }
             case "not": {
-                result.not =
-                    (0, is_plain_object_validator_1.isPlainObject)(val) && isFieldOperatorObject(val)
-                        ? parseFieldOperators(val)
-                        : val;
+                result.not = isPlainObject(val) ? parseFieldValue(val, provider) : val;
+                break;
+            }
+            case "_some": {
+                result.some = parsePrismaWhere(value._some, provider);
+                break;
+            }
+            case "_every": {
+                result.every = parsePrismaWhere(value._every, provider);
                 break;
             }
+            case "_none": {
+                result.none = parsePrismaWhere(value._none, provider);
+                break;
+            }
+            case "_with": {
+                result.is = parsePrismaWhere(value._with, provider);
+                break;
+            }
+            case "_without": {
+                result.isNot = parsePrismaWhere(value._without, provider);
+                break;
+            }
+            case "like": {
+                throw new VSRepoAdapterError(`The 'like' operator is not supported by the Prisma adapter, since Prisma has no equivalent. ` +
+                    `Use 'contains', 'startsWith' or 'endsWith' instead.`, AdapterErrorCode.NOT_SUPPORTED, null);
+            }
             default:
                 result[key] = val;
         }
     }
-    if (ignoreCase) {
-        // * Simplismente aplica o "insensitive" se o ignoreCase for true, se for em um campo inválido o proprio Prisma lança erro
-        result.mode = "insensitive";
-    }
-    return result;
-}
-/** Converte { _some, _every, _none } em { some, every, none } (VSRepoWherePlain — sem AND/OR/NOT) */
-function parseArrayRelationFilter(value) {
-    const result = {};
-    if (value._some !== undefined) {
-        result.some = parsePlainWhere(value._some);
-    }
-    if (value._every !== undefined) {
-        result.every = parsePlainWhere(value._every);
-    }
-    if (value._none !== undefined) {
-        result.none = parsePlainWhere(value._none);
-    }
     return result;
 }
-/** Converte { _with, _without } em { is, isNot } (VSRepoWherePlain — sem AND/OR/NOT) */
-function parseObjectRelationFilter(value) {
-    const result = {};
-    if (value._with !== undefined) {
-        result.is = parsePlainWhere(value._with);
-    }
-    if (value._without !== undefined) {
-        result.isNot = parsePlainWhere(value._without);
-    }
-    return result;
-}
-/** Decide como interpretar o valor de um campo do where */
-function parseFieldValue(value) {
-    // valores primitivos (string, number, boolean, Date, null, bigint, Decimal) passam direto
-    if (value === null || typeof value !== "object" || value instanceof Date || (0, is_decimal_validator_1.isDecimal)(value)) {
-        return value;
-    }
-    // arrays (usados em `in`/`notIn` no nível mais alto, ex: { status: ["A","B"] })
-    if (Array.isArray(value)) {
-        return value;
-    }
-    const obj = value;
-    if (isArrayRelationFilter(obj)) {
-        return parseArrayRelationFilter(obj);
-    }
-    if (isObjectRelationFilter(obj)) {
-        return parseObjectRelationFilter(obj);
-    }
-    if (isFieldOperatorObject(obj)) {
-        return parseFieldOperators(obj);
-    }
-    // fallback: nested where (não deveria ocorrer para campos primitivos bem tipados)
-    return parsePlainWhere(obj);
-}
 /**
- * Converte um `VSRepoWherePlain<T>` (sem AND/OR/NOT) — usado para o corpo de
- * relações (`_some`/`_every`/`_none`/`_with`/`_without`).
+ * Converts a `VSRepoWhere` into a Prisma `where`.
  */
-function parsePlainWhere(where) {
-    if (where === undefined || where === null)
-        return undefined;
-    const result = {};
-    for (const [key, value] of Object.entries(where)) {
-        if (value === undefined)
-            continue;
-        result[key] = parseFieldValue(value);
-    }
-    return result;
-}
-/**
- * Converte um `VSRepoWhere<T>` completo (nível raiz, com AND/OR/NOT) em um
- * where do Prisma.
- */
-function parseWhere(where) {
-    if (where === undefined || where === null)
+export function parsePrismaWhere(where, provider) {
+    if (where === undefined)
         return undefined;
     const result = {};
     for (const [key, value] of Object.entries(where)) {
         if (value === undefined)
             continue;
         if (LOGICAL_KEYS.has(key)) {
-            result[key] = Array.isArray(value) ? value.map(v => parseWhere(v)) : parseWhere(value);
+            result[key] = Array.isArray(value)
+                ? value.map(v => parsePrismaWhere(v, provider))
+                : parsePrismaWhere(value, provider);
             continue;
         }
-        result[key] = parseFieldValue(value);
+        result[key] = parseFieldValue(value, provider);
     }
     return result;
 }
-/**
- * Use o segundo generic para tipar o retorno com o `WhereInput`
- * do Prisma correspondente ao modelo, ex:
- *
- *   parseVSRepoWhere<User, Prisma.UserWhereInput>(where)
- */
-function parsePrismaWhere(where) {
-    return parseWhere(where);
-}
-//# sourceMappingURL=where.parser.js.map

package/dist/prisma7.adapter.d.ts

@@ -1,18 +1,9 @@
-import { AdapterMethodOptions, AdapterQueryOptions, CountResult, DeepPartial, NumericKeys, VSRepoAdapter, VSRepoTransactionOptions, VSRepoWhere } from "vsrepo";
-import { VSRepoPrisma7AdapterConfig } from "./types/adapter-config.type";
-import { Prisma7ClientLike } from "./types/prisma7-client-like.type";
+import { AdapterMethodOptions, AdapterQueryOptions, CountResult, DeepPartial, NumericKeys, RestrictAdapterMethodOptions, SimpleAdapterMethodOptions, VSRepoAdapter, VSRepoTransactionOptions, VSRepoWhere, WithIgnoreConflicts } from "vsrepo";
+import { Prisma7AdapterConfig } from "./types/adapter-config.type.js";
+import { Prisma7ClientLike } from "./types/prisma7-client-like.type.js";
+import { Prisma7GlobalConfig } from "./types/prisma7-global-config.type.js";
 /**
- * `VSRepoAdapter` implementation for Prisma 7. Translates every method of the
- * adapter contract into Prisma Client calls, resolving `VSRepoWhere`/`Ordering`/
- * `select`/`include` through the parsers, and — when a
- * `relations` config is provided — resolving relation fields on `create`/
- * `update`/`upsert`/`merge` the same way the v1 of VSRepository did (see
- * `Relation`).
- *
- * Every method always rejects with a `VSRepoAdapterError` — any error raised
- * by Prisma (or by the adapter itself) is translated through `mapPrismaError`
- * before leaving the adapter, so callers never have to deal with a raw
- * Prisma/driver error shape.
+ * `VSRepoAdapter` implementation for Prisma 7.
  *
  * @template T Entity type this adapter operates on.
  *
@@ -20,15 +11,36 @@ import { Prisma7ClientLike } from "./types/prisma7-client-like.type";
  */
 export declare class VSRepoPrisma7Adapter<T, K extends Prisma7ClientLike = Prisma7ClientLike> extends VSRepoAdapter<T> {
     private readonly prisma;
-    private readonly tableName;
+    private readonly modelName;
     private readonly pkName;
     private readonly relations?;
     private readonly logger;
     private readonly provider;
-    constructor(prisma: K, config: VSRepoPrisma7AdapterConfig<T, K>);
+    /** Whether the primary key may be dropped from a write payload when Prisma can't take it. */
+    private readonly allowOmitPk?;
+    private static globalConfig;
+    constructor(prisma: K, config: Prisma7AdapterConfig<T, K>);
+    /**
+     * Sets defaults (`provider`, `logLevel`, `allowOmitPk`) for every adapter
+     * created **after** this call. It replaces the previous global config, and
+     * the config passed to each adapter's constructor takes precedence.
+     */
+    static setGlobalConfig(globalConfig: Prisma7GlobalConfig): void;
     private getPrismaRepository;
     /** Resolves the "read" part of a Prisma arg: select/include/orderBy/pagination. */
     private resolveReadArg;
+    /** Parses a `where` for this adapter's provider (rejecting what the provider cannot run). */
+    private parseWhere;
+    /**
+     * `createManyReturning` and `updateManyReturning` rely on Prisma's `createManyAndReturn` /
+     * `updateManyAndReturn`, which only exist on PostgreSQL, CockroachDB and SQLite.
+     */
+    private assertReturningManySupported;
+    /**
+     * `ignoreConflicts` is translated to Prisma's `skipDuplicates`, which isn't available on
+     * SQL Server and SQLite. Rejects with `NOT_SUPPORTED` instead of leaving it to Prisma.
+     */
+    private assertIgnoreConflictsSupported;
     /**
      * Strips relation fields from a payload — used by `createMany`/`updateMany`/
      * `updateManyReturning`, since those Prisma operations don't support nested
@@ -58,13 +70,14 @@ export declare class VSRepoPrisma7Adapter<T, K extends Prisma7ClientLike = Prism
      * evaluated server-side against the row's current value, never as a
      * client-side read-modify-write. `value` is passed through as-is:
      * Prisma accepts a `number`, `bigint`, or any `Decimal`/`DecimalJsLike`
-     * value (which covers a {@link DecimalLike} like `Prisma.Decimal`)
+     * value (which covers a `DecimalLike` like `Prisma.Decimal`)
      * depending on the target column's type.
      *
      * Prisma's `update()` already returns the row reflecting the state
      * *after* the write, so no follow-up read is needed here.
      */
     private atomicUpdate;
+    private atomicUpdateMany;
     /**
      * Converts a raw value returned by Prisma's `aggregate()` (`number`,
      * `bigint`, a `Decimal` instance, or `null` when no record matches)
@@ -85,108 +98,130 @@ export declare class VSRepoPrisma7Adapter<T, K extends Prisma7ClientLike = Prism
     getDbClient(): any;
     /** Runs `fn` inside a native transaction of the underlying ORM/database. */
     runInTransaction<R>(fn: (tx: any) => Promise<R>, options?: VSRepoTransactionOptions): Promise<R>;
+    private execMethod;
+    /** Runs `parsePrismaWriteData` with this adapter's `pkName`, `relations` and `allowOmitPk`. */
+    private parseData;
     /** Fetches a single record matching `where`. */
-    findOne(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T | null>;
+    findOne(where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T | null>;
     /** Fetches a single record matching `where`, throwing if none is found. */
-    findOneOrThrow(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    findOneOrThrow(where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
     /** Fetches all records matching `where`. */
-    findMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T> & {
-        distinct?: (keyof T)[];
-    }): Promise<T[]>;
+    findMany(where?: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
     /** Creates or updates (upsert) a single record. */
-    save(obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    save(obj: DeepPartial<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
     /**
      * Creates or updates (upsert) multiple records. Prisma has no native bulk
      * upsert, so each record is saved individually inside a transaction —
-     * reusing `options.db` when it's already a transaction client (see
-     * `runTransactional`).
+     * reusing `options.db` when it's already a transaction client.
      */
-    saveMany(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T>): Promise<T[]>;
+    saveMany(objs: DeepPartial<T>[], options?: SimpleAdapterMethodOptions<T>): Promise<T[]>;
     /** Deletes a single record matching `where`. */
-    delete(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    delete(where: VSRepoWhere<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
     /** Deletes every record matching `where`, returning the count of affected rows. */
-    deleteMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
+    deleteMany(where: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<CountResult>;
     /**
-     * Deletes every record matching `where`, returning the deleted records.
+     * Deletes every record matching `where` and returns the deleted records.
      *
-     * Prisma has no `deleteManyAndReturn`, so this does a `findMany` on
-     * `where` first and then re-applies the same `where` to a `deleteMany`,
-     * both inside a transaction (`runTransactional`).
+     * In the absence of a native `deleteManyAndReturn`, this fetches matching records
+     * via `findMany` first, extracts their primary keys, and then deletes them by ID
+     * using `{ [pkName]: { in: pks } }` inside a transaction.
      *
-     * Because the delete is driven by the same `where` (not by the fetched
-     * records), a concurrent change between the two operations can make them
-     * diverge — e.g. a row inserted after the `findMany` matching the `where`
-     * would still be deleted, while a row changed to stop matching wouldn't.
-     * If you need to guarantee no concurrency issues, run this method inside a
-     * `repository.transaction()` with a higher isolation level, e.g.
-     * `TransactionIsolationLevel.SERIALIZABLE`.
-     */
-    deleteManyReturning(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
+     * Key behaviors:
+     * - **Primary Key Handling:** If `options.select` omits the primary key, it is
+     *   temporarily added to the query so the subsequent batch delete can target
+     *   those exact IDs, and stripped from the returned objects afterward.
+     * - **Concurrency & Isolation:** Deleting strictly by the fetched IDs ensures only
+     *   the exact returned rows are removed (avoiding deleting newly inserted rows that
+     *   match `where`). However, if a row is modified or deleted concurrently between
+     *   the read and the delete step, race conditions can still occur unless wrapped
+     *   in a transaction with an appropriate isolation level (e.g., `SERIALIZABLE`).
+     */
+    deleteManyReturning(where: VSRepoWhere<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T[]>;
     /** Updates a single record matching `where`. */
-    update(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    update(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
     /** Updates every record matching `where`, returning the count of affected rows. */
-    updateMany(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
-    /** Updates every record matching `where`, returning the updated records. */
-    updateManyReturning(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
+    updateMany(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: RestrictAdapterMethodOptions<T>): Promise<CountResult>;
+    /**
+     * Updates every record matching `where`, returning the updated records.
+     *
+     * Rejects with `NOT_SUPPORTED` on providers without `updateManyAndReturn` (MySQL and SQL Server).
+     */
+    updateManyReturning(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T[]>;
     /** Returns the number of records matching `where`. */
-    count(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number>;
+    count(where?: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<number>;
     /** Checks whether at least one record matching `where` exists. */
-    exists(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<boolean>;
-    /** Executes a raw query/statement against the underlying database, used by `@QueryMethod`. */
+    exists(where?: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<boolean>;
+    /** Executes a raw query/statement against the underlying database. */
     query<R = any>(query: string, options?: AdapterQueryOptions): Promise<R>;
     /** Creates a single record. */
-    create(obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    create(obj: DeepPartial<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
     /**
-     * Creates multiple records in a single operation. Relation fields are
-     * stripped (see `stripRelationFields`), since Prisma's `createMany` doesn't
-     * support nested writes.
+     * Creates multiple records in a single operation.
+     *
+     * Rejects with `NOT_SUPPORTED` when `ignoreConflicts` is used on a provider without
+     * `skipDuplicates` (SQL Server and SQLite).
      */
-    createMany(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T> & {
-        ignoreConflicts?: boolean;
-    }): Promise<CountResult>;
+    createMany(objs: DeepPartial<T>[], options?: WithIgnoreConflicts<RestrictAdapterMethodOptions<T>>): Promise<CountResult>;
     /**
      * Creates multiple records in a single operation, returning the created records.
+     *
+     * Rejects with `NOT_SUPPORTED` on providers without `createManyAndReturn` (MySQL and SQL Server),
+     * and when `ignoreConflicts` is used on a provider without `skipDuplicates` (SQL Server and SQLite).
      */
-    createManyReturning(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T> & {
-        ignoreConflicts?: boolean;
-    }): Promise<T[]>;
-    /**
-     * Fetches the record matching `where` and returns it deep-merged with
-     * `obj`, WITHOUT persisting anything — same behavior the v1 of
-     * VSRepository had (see `mergeEntities`). It's on the caller to decide
-     * what to do with the result (e.g. call `save` next).
-     */
-    merge<K extends DeepPartial<T>>(where: VSRepoWhere<T>, obj: K, options?: AdapterMethodOptions<T>): Promise<(K & T) | null>;
+    createManyReturning(objs: DeepPartial<T>[], options?: WithIgnoreConflicts<SimpleAdapterMethodOptions<T>>): Promise<T[]>;
     /** Creates a record if none matches `where`, otherwise updates it. */
-    upsert(where: VSRepoWhere<T>, create: DeepPartial<T>, update: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    upsert(where: VSRepoWhere<T>, create: DeepPartial<T>, update: DeepPartial<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
     /**
      * Atomically adds `value` to `field` on the record matching `where`,
      * via Prisma's native `{ field: { increment: value } }` write.
      */
-    incrementOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
-    /** Same as {@link VSRepoPrisma7Adapter.incrementOne}, subtracting `value` instead of adding it. */
-    decrementOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
-    /** Same as {@link VSRepoPrisma7Adapter.incrementOne}, multiplying the field's current value by `value`. */
-    multiplyOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    incrementOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Atomically subtracts `value` to `field` on the record matching `where`,
+     * via Prisma's native `{ field: { decrement: value } }` write.
+     */
+    decrementOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Atomically multiplies `value` to `field` on the record matching `where`,
+     * via Prisma's native `{ field: { multiply: value } }` write.
+     */
+    multiplyOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Atomically divides `value` to `field` on the record matching `where`,
+     * via Prisma's native `{ field: { divide: value } }` write.
+     */
+    divideOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: SimpleAdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Atomically adds `value` to `field` on every record matching `where`,
+     * via Prisma's native `{ field: { increment: value } }` write.
+     */
+    incrementMany<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<CountResult>;
+    /**
+     * Atomically subtracts `value` from `field` on every record matching `where`,
+     * via Prisma's native `{ field: { decrement: value } }` write.
+     */
+    decrementMany<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<CountResult>;
+    /**
+     * Atomically multiplies `field` by `value` on every record matching `where`,
+     * via Prisma's native `{ field: { multiply: value } }` write.
+     */
+    multiplyMany<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<CountResult>;
     /**
-     * Same as {@link VSRepoPrisma7Adapter.incrementOne}, dividing the
-     * field's current value by `value`. Division-by-zero is not handled by
-     * the adapter — it's whatever Postgres does natively (raises a
-     * `division_by_zero` error for integer columns; `Infinity`/`NaN` are not
-     * representable in a numeric/decimal column, so those also error).
+     * Atomically divides `field` by `value` on every record matching `where`,
+     * via Prisma's native `{ field: { divide: value } }` write.
      */
-    divideOne<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    divideMany<K extends NumericKeys<T>>(field: K, value: NonNullable<T[K]>, where: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<CountResult>;
     /**
      * Returns the sum of `field` across every record matching `where` (all
      * records if `where` is empty), or `null` if no record matches.
      */
-    sum(field: NumericKeys<T>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    sum(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<number | null>;
     /** Same as {@link VSRepoPrisma7Adapter.sum}, but the arithmetic mean instead of the total. */
-    average(field: NumericKeys<T>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    average(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<number | null>;
     /** Same as {@link VSRepoPrisma7Adapter.sum}, but the minimum value instead of the total. */
-    min(field: NumericKeys<T>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    min(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<number | null>;
     /** Same as {@link VSRepoPrisma7Adapter.sum}, but the maximum value instead of the total. */
-    max(field: NumericKeys<T>, where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number | null>;
+    max(field: NumericKeys<T>, where?: VSRepoWhere<T>, options?: RestrictAdapterMethodOptions<T>): Promise<number | null>;
     /**
      * Returns the model's primary key
      *