@vsrepo/prisma7-adapter 1.3.1 → 2.0.0-dev

package/dist/prisma7.adapter.d.ts

@@ -1,18 +1,8 @@
-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";
 /**
- * `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 +10,27 @@ 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>);
+    constructor(prisma: K, config: Prisma7AdapterConfig<T, K>);
     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 +60,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 +88,128 @@ 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;
     /** 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
      *