@vsrepo/prisma7-adapter 1.3.2 → 2.0.0-dev

package/dist/prisma7.adapter.js

@@ -1,37 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VSRepoPrisma7Adapter = void 0;
-const vsrepo_1 = require("vsrepo");
-const where_parser_1 = require("./parsers/where.parser");
-const include_parser_1 = require("./parsers/include.parser");
-const select_parser_1 = require("./parsers/select.parser");
-const order_by_parser_1 = require("./parsers/order-by.parser");
-const data_parser_1 = require("./parsers/data.parser");
-const merge_entities_resolver_1 = require("./resolvers/merge-entities.resolver");
-const map_prisma_error_resolver_1 = require("./resolvers/map-prisma-error.resolver");
-const resolve_provider_resolver_1 = require("./resolvers/resolve-provider.resolver");
-const validate_adapter_config_validator_1 = require("./validators/validate-adapter-config.validator");
-const validate_prisma_client_validator_1 = require("./validators/validate-prisma-client.validator");
+import { AdapterErrorCode, getPostgresPlaceholder, getSqlitePlaceholder, getSqlServerPlaceholder, VSLogger, VSLogLevel, VSRepoAdapter, VSRepoAdapterError, } from "vsrepo";
+import { RETURNING_MANY_PROVIDERS, SKIP_DUPLICATES_PROVIDERS } from "./constants/provider-capabilities.constant.js";
+import { parsePrismaWhere } from "./parsers/where.parser.js";
+import { parsePrismaInclude } from "./parsers/include.parser.js";
+import { parsePrismaSelect } from "./parsers/select.parser.js";
+import { parsePrismaOrderBy } from "./parsers/order-by.parser.js";
+import { parsePrismaWriteData } from "./parsers/data.parser.js";
+// import { mergeEntities } from "./resolvers/merge-entities.resolver.js";
+import { mapPrismaError } from "./resolvers/map-prisma-error.resolver.js";
+import { resolveProvider } from "./resolvers/resolve-provider.resolver.js";
+import { validatePrismaClient } from "./validators/validate-prisma-client.validator.js";
+import { isDecimal } from "./validators/is-decimal.validator.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.
  *
  * @publicApi
  */
-class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
+export class VSRepoPrisma7Adapter extends VSRepoAdapter {
     prisma;
-    tableName;
+    modelName;
     pkName;
     relations;
     logger;
@@ -39,34 +27,55 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     constructor(prisma, config) {
         super();
         this.prisma = prisma;
-        const validated = (0, validate_adapter_config_validator_1.validateAdapterConfig)(config);
-        (0, validate_prisma_client_validator_1.validatePrismaClient)(prisma, validated.tableName);
-        this.tableName = validated.tableName;
-        this.pkName = validated.pkName;
-        this.relations = validated.relations;
-        this.provider = (0, resolve_provider_resolver_1.resolveProvider)(prisma, validated.provider);
-        this.logger = new vsrepo_1.VSLogger(validated.logLevel ?? vsrepo_1.VSLogLevel.WARN, this.constructor.name + "Logger", validated.logSlowThresholdMs ?? 300);
-        this.logger.logInfo(`${this.constructor.name} initialized for table '${this.tableName}' (pkName: '${this.pkName}'${this.relations ? `, relations: [${Object.keys(this.relations).join(", ")}]` : ""}, provider: ${this.provider ? `'${this.provider}'` : "<not detected>"})`);
+        validatePrismaClient(prisma, config.modelName);
+        this.modelName = config.modelName;
+        this.pkName = config.pkName;
+        this.relations = config.relations;
+        this.provider = resolveProvider(prisma, config.provider);
+        this.logger = new VSLogger(config.logLevel ?? VSLogLevel.WARN, this.constructor.name + "Logger");
+        this.logger.logInfo(`${this.constructor.name} initialized for table '${this.modelName}' (pkName: '${this.pkName}'${this.relations ? `, relations: [${Object.keys(this.relations).join(", ")}]` : ""}, provider: ${this.provider ? `'${this.provider}'` : "<not detected>"})`);
     }
     getPrismaRepository(db) {
-        return db ? db[this.tableName] : this.prisma[this.tableName];
+        return db ? db[this.modelName] : this.prisma[this.modelName];
     }
     /** Resolves the "read" part of a Prisma arg: select/include/orderBy/pagination. */
     resolveReadArg(options) {
-        options ??= {};
-        const prismaSelect = options.select && (0, select_parser_1.parsePrismaSelect)(options.select);
-        const prismaInclude = prismaSelect
-            ? undefined
-            : options.relations && (0, include_parser_1.parsePrismaInclude)(options.relations);
+        if (!options)
+            return {};
+        const prismaSelect = options.select && parsePrismaSelect(options.select);
+        const prismaInclude = prismaSelect ? undefined : options.relations && parsePrismaInclude(options.relations);
         return {
             select: prismaSelect,
             include: prismaInclude,
-            orderBy: (0, order_by_parser_1.parsePrismaOrderBy)(options.order),
+            orderBy: parsePrismaOrderBy(options.order),
             skip: options.pagination?.offset,
             take: options.pagination?.limit,
-            distinct: options.distinct,
         };
     }
+    /** Parses a `where` for this adapter's provider (rejecting what the provider cannot run). */
+    parseWhere(where) {
+        return parsePrismaWhere(where, this.provider);
+    }
+    /**
+     * `createManyReturning` and `updateManyReturning` rely on Prisma's `createManyAndReturn` /
+     * `updateManyAndReturn`, which only exist on PostgreSQL, CockroachDB and SQLite.
+     */
+    assertReturningManySupported(methodName) {
+        if (RETURNING_MANY_PROVIDERS.has(this.provider))
+            return;
+        throw new VSRepoAdapterError(`'${methodName}' is not supported by the '${this.provider}' provider, since Prisma only provides ` +
+            `createManyAndReturn/updateManyAndReturn on PostgreSQL, CockroachDB and SQLite.`, AdapterErrorCode.NOT_SUPPORTED, null);
+    }
+    /**
+     * `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.
+     */
+    assertIgnoreConflictsSupported(methodName, ignoreConflicts) {
+        if (!ignoreConflicts || SKIP_DUPLICATES_PROVIDERS.has(this.provider))
+            return;
+        throw new VSRepoAdapterError(`The 'ignoreConflicts' option of '${methodName}' is not supported by the '${this.provider}' provider, since Prisma only ` +
+            `supports skipDuplicates on PostgreSQL, MySQL and CockroachDB. Remove 'ignoreConflicts' to run it without skipping conflicts.`, AdapterErrorCode.NOT_SUPPORTED, null);
+    }
     /**
      * Strips relation fields from a payload — used by `createMany`/`updateMany`/
      * `updateManyReturning`, since those Prisma operations don't support nested
@@ -82,7 +91,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
             if (value === undefined)
                 continue;
             if (key in this.relations) {
-                throw new vsrepo_1.VSRepoAdapterError(`Field '${key}' is a configured relation, but Prisma's *Many operations don't support nested relation writes.`, vsrepo_1.AdapterErrorCode.NOT_SUPPORTED, null);
+                throw new VSRepoAdapterError(`Field '${key}' is a configured relation, but Prisma's *Many operations don't support nested relation writes.`, AdapterErrorCode.NOT_SUPPORTED, null);
             }
             data[key] = value;
         }
@@ -117,28 +126,47 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
      * 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.
      */
     async atomicUpdate(operation, field, value, where, options) {
-        const start = this.logger.startPerformLog(`run ${operation}One`);
+        const methodName = `${operation}One`;
+        const start = this.logger.startPerformLog(`run ${methodName}`);
         try {
             const arg = {
-                ...this.resolveReadArg(options),
-                where: (0, where_parser_1.parsePrismaWhere)(where),
+                ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+                where: this.parseWhere(where),
                 data: { [field]: { [operation]: value } },
             };
-            this.logger.logDebug(`Resolved Prisma arg for '${operation}One'`, arg);
-            return await this.getPrismaRepository(options?.db).update(arg);
+            this.logger.logDebug(`Resolved Prisma arg for ${methodName}`, arg);
+            const result = await this.getPrismaRepository(options?.db).update(arg);
+            this.logger.endPerformLog(start);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, `${operation}One`);
+            this.logger.endPerformLog(start);
+            throw mapPrismaError(error, methodName);
+        }
+    }
+    async atomicUpdateMany(operation, field, value, where, options) {
+        const methodName = `${operation}Many`;
+        const start = this.logger.startPerformLog(`run ${methodName}`);
+        try {
+            const arg = {
+                where: this.parseWhere(where),
+                data: { [field]: { [operation]: value } },
+            };
+            this.logger.logDebug(`Resolved Prisma arg for ${methodName}`, arg);
+            const result = await this.getPrismaRepository(options?.db).updateMany(arg);
+            this.logger.endPerformLog(start);
+            return result;
         }
-        finally {
+        catch (error) {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, methodName);
         }
     }
     /**
@@ -152,7 +180,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
             return null;
         if (typeof value === "bigint")
             return Number(value);
-        if (typeof value?.toNumber === "function") {
+        if (isDecimal(value)) {
             return value.toNumber();
         }
         return Number(value);
@@ -170,18 +198,17 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
         const aggKey = `_${operation}`;
         try {
             const arg = {
-                where: (0, where_parser_1.parsePrismaWhere)(where),
+                where: this.parseWhere(where),
                 [aggKey]: { [field]: true },
             };
-            this.logger.logDebug(`Resolved Prisma arg for '${operation}'`, arg);
-            const result = await this.getPrismaRepository(options?.db).aggregate(arg);
-            return this.toNullableNumber(result?.[aggKey]?.[field]);
+            this.logger.logDebug(`Resolved Prisma arg for ${operation}`, arg);
+            const aggResult = await this.getPrismaRepository(options?.db).aggregate(arg);
+            this.logger.endPerformLog(start);
+            return this.toNullableNumber(aggResult?.[aggKey]?.[field]);
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, operation);
-        }
-        finally {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, operation);
         }
     }
     /** Returns the underlying ORM client instance used outside of transactions. */
@@ -197,277 +224,207 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
             });
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "runInTransaction");
+            throw mapPrismaError(error, "runInTransaction");
         }
     }
-    /** Fetches a single record matching `where`. */
-    async findOne(where, options) {
-        const start = this.logger.startPerformLog("run findOne");
+    async execMethod(fn, methodName, arg) {
+        const start = this.logger.startPerformLog(`run ${methodName}`);
         try {
-            const arg = { ...this.resolveReadArg(options), where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'findOne'", arg);
-            return await this.getPrismaRepository(options?.db).findFirst(arg);
+            this.logger.logDebug(`Resolved Prisma arg for ${methodName}`, arg);
+            const result = await fn();
+            this.logger.endPerformLog(start);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "findOne");
-        }
-        finally {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, methodName);
         }
     }
+    /** Fetches a single record matching `where`. */
+    async findOne(where, options) {
+        const arg = { ...this.resolveReadArg(options), where: this.parseWhere(where) };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).findFirst(arg), "findOne", arg);
+    }
     /** Fetches a single record matching `where`, throwing if none is found. */
     async findOneOrThrow(where, options) {
-        const start = this.logger.startPerformLog("run findOneOrThrow");
-        try {
-            const arg = { ...this.resolveReadArg(options), where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'findOneOrThrow'", arg);
-            return await this.getPrismaRepository(options?.db).findFirstOrThrow(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "findOneOrThrow");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const arg = { ...this.resolveReadArg(options), where: this.parseWhere(where) };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).findFirstOrThrow(arg), "findOneOrThrow", arg);
     }
     /** Fetches all records matching `where`. */
     async findMany(where, options) {
-        const start = this.logger.startPerformLog("run findMany");
-        try {
-            const arg = { ...this.resolveReadArg(options), where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'findMany'", arg);
-            return await this.getPrismaRepository(options?.db).findMany(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "findMany");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const arg = { ...this.resolveReadArg(options), where: this.parseWhere(where) };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).findMany(arg), "findMany", arg);
     }
     /** Creates or updates (upsert) a single record. */
     async save(obj, options) {
-        const start = this.logger.startPerformLog("run save");
-        try {
-            const objAny = obj;
-            const pkValue = objAny[this.pkName];
-            const readArg = this.resolveReadArg(options);
-            const repo = this.getPrismaRepository(options?.db);
-            if (pkValue === undefined) {
-                const { create } = (0, data_parser_1.parsePrismaWriteData)(objAny, this.pkName, this.relations);
-                const arg = { ...readArg, data: create };
-                this.logger.logDebug("Resolved Prisma arg for 'save' (create)", arg);
-                return await repo.create(arg);
-            }
-            const { create, update } = (0, data_parser_1.parsePrismaWriteData)(objAny, this.pkName, this.relations);
-            const arg = { ...readArg, where: { [this.pkName]: pkValue }, create, update };
-            this.logger.logDebug("Resolved Prisma arg for 'save' (upsert)", arg);
-            return await repo.upsert(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "save");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const objAny = obj;
+        const pkValue = objAny[this.pkName];
+        const readArg = this.resolveReadArg({ select: options?.select, relations: options?.relations });
+        const repo = this.getPrismaRepository(options?.db);
+        const { create, update } = parsePrismaWriteData(objAny, this.pkName, this.relations, true);
+        if (pkValue === undefined) {
+            const arg = { ...readArg, data: create };
+            return this.execMethod(() => repo.create(arg), "save (create)", arg);
+        }
+        const arg = { ...readArg, where: { [this.pkName]: pkValue }, create, update };
+        return this.execMethod(() => repo.upsert(arg), "save (upsert)", arg);
     }
     /**
      * 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.
      */
     async saveMany(objs, options) {
         const start = this.logger.startPerformLog("run saveMany");
         try {
             this.logger.logDebug(`Saving ${objs.length} record(s) individually inside a transaction`);
-            return await this.runTransactional(options?.db, async (tx) => {
+            const result = await this.runTransactional(options?.db, async (tx) => {
+                const optionsResolved = { ...options, db: tx };
                 const saved = [];
                 for (let i = 0; i < objs.length; i++) {
                     const obj = objs[i];
-                    saved.push(await this.save(obj, { ...options, db: tx }));
+                    saved.push(await this.save(obj, optionsResolved));
                 }
                 return saved;
             });
+            this.logger.endPerformLog(start);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "saveMany");
-        }
-        finally {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, "saveMany");
         }
     }
     /** Deletes a single record matching `where`. */
     async delete(where, options) {
-        const start = this.logger.startPerformLog("run delete");
-        try {
-            const arg = { ...this.resolveReadArg(options), where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'delete'", arg);
-            return await this.getPrismaRepository(options?.db).delete(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "delete");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const arg = {
+            ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+            where: this.parseWhere(where),
+        };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).delete(arg), "delete", arg);
     }
     /** Deletes every record matching `where`, returning the count of affected rows. */
     async deleteMany(where, options) {
-        const start = this.logger.startPerformLog("run deleteMany");
-        try {
-            const arg = { where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'deleteMany'", arg);
-            return await this.getPrismaRepository(options?.db).deleteMany(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "deleteMany");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const arg = { where: this.parseWhere(where) };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).deleteMany(arg), "deleteMany", arg);
     }
     /**
-     * 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`.
+     * 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`).
      */
     async deleteManyReturning(where, options) {
         const start = this.logger.startPerformLog("run deleteManyReturning");
         try {
-            const prismaWhere = (0, where_parser_1.parsePrismaWhere)(where);
-            const findArg = { ...this.resolveReadArg(options), where: prismaWhere };
-            const deleteArg = { where: prismaWhere };
-            this.logger.logDebug("Resolved Prisma args for 'deleteManyReturning'", {
-                findArg,
-                deleteArg,
-            });
-            return await this.runTransactional(options?.db, async (tx) => {
+            const prismaWhere = this.parseWhere(where);
+            const findArg = {
+                ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+                where: prismaWhere,
+            };
+            const userRequestedPk = findArg.include || !findArg.select || !!findArg.select[this.pkName];
+            if (!userRequestedPk) {
+                findArg.select[this.pkName] = true;
+            }
+            this.logger.logDebug("Resolved Prisma args for deleteManyReturning", findArg);
+            const result = await this.runTransactional(options?.db, async (tx) => {
                 const repo = this.getPrismaRepository(tx);
                 const records = await repo.findMany(findArg);
-                await repo.deleteMany(deleteArg);
+                if (records.length === 0)
+                    return [];
+                const pks = records.map((rec) => rec[this.pkName]);
+                await repo.deleteMany({ where: { [this.pkName]: { in: pks } } });
                 return records;
             });
+            if (!userRequestedPk) {
+                for (const obj of result) {
+                    delete obj[this.pkName];
+                }
+            }
+            this.logger.endPerformLog(start);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "deleteManyReturning");
-        }
-        finally {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, "deleteManyReturning");
         }
     }
     /** Updates a single record matching `where`. */
     async update(where, obj, options) {
-        const start = this.logger.startPerformLog("run update");
-        try {
-            const { update } = (0, data_parser_1.parsePrismaWriteData)(obj, this.pkName, this.relations);
-            const arg = {
-                ...this.resolveReadArg(options),
-                where: (0, where_parser_1.parsePrismaWhere)(where),
-                data: update,
-            };
-            this.logger.logDebug("Resolved Prisma arg for 'update'", arg);
-            return await this.getPrismaRepository(options?.db).update(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "update");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const { update } = parsePrismaWriteData(obj, this.pkName, this.relations);
+        const arg = {
+            ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+            where: this.parseWhere(where),
+            data: update,
+        };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).update(arg), "update", arg);
     }
     /** Updates every record matching `where`, returning the count of affected rows. */
     async updateMany(where, obj, options) {
-        const start = this.logger.startPerformLog("run updateMany");
-        try {
-            const data = this.stripRelationFields(obj);
-            const arg = { where: (0, where_parser_1.parsePrismaWhere)(where), data };
-            this.logger.logDebug("Resolved Prisma arg for 'updateMany'", arg);
-            return await this.getPrismaRepository(options?.db).updateMany(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "updateMany");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const data = this.stripRelationFields(obj);
+        const arg = { where: this.parseWhere(where), data };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).updateMany(arg), "updateMany", arg);
     }
-    /** Updates every record matching `where`, returning the updated records. */
+    /**
+     * Updates every record matching `where`, returning the updated records.
+     *
+     * Rejects with `NOT_SUPPORTED` on providers without `updateManyAndReturn` (MySQL and SQL Server).
+     */
     async updateManyReturning(where, obj, options) {
         const start = this.logger.startPerformLog("run updateManyReturning");
         try {
-            const data = this.stripRelationFields(obj);
-            const readArg = this.resolveReadArg(options);
-            const arg = {
-                ...readArg,
-                where: (0, where_parser_1.parsePrismaWhere)(where),
-                data,
-            };
-            this.logger.logDebug("Resolved Prisma arg for 'updateManyReturning'", arg);
-            return await this.runTransactional(options?.db, async (tx) => {
-                const repo = this.getPrismaRepository(tx);
-                const updated = await repo.updateManyAndReturn({
-                    ...arg,
-                    include: undefined,
-                    select: { [this.pkName]: true },
-                });
-                const idsUpdated = updated.map((_) => _[this.pkName]);
-                return repo.findMany({
-                    ...readArg,
-                    where: { [this.pkName]: { in: idsUpdated } },
+            this.assertReturningManySupported("updateManyReturning");
+            const readArg = this.resolveReadArg({ select: options?.select, relations: options?.relations });
+            const arg = { where: this.parseWhere(where), data: this.stripRelationFields(obj) };
+            this.logger.logDebug("Resolved Prisma args for updateManyReturning", { ...readArg, ...arg });
+            let result;
+            if (!readArg.select && !readArg.include) {
+                result = await this.getPrismaRepository(options?.db).updateManyAndReturn(arg);
+            }
+            else {
+                result = await this.runTransactional(options?.db, async (tx) => {
+                    const repo = this.getPrismaRepository(tx);
+                    const updated = await repo.updateManyAndReturn({ ...arg, select: { [this.pkName]: true } });
+                    const idsUpdated = updated.map((_) => _[this.pkName]);
+                    return await repo.findMany({
+                        ...readArg,
+                        where: { [this.pkName]: { in: idsUpdated } },
+                    });
                 });
-            });
+            }
+            this.logger.endPerformLog(start);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "updateManyReturning");
-        }
-        finally {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, "updateManyReturning");
         }
     }
     /** Returns the number of records matching `where`. */
     async count(where, options) {
-        const start = this.logger.startPerformLog("run count");
-        try {
-            const readArg = this.resolveReadArg(options);
-            const arg = { ...readArg, where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'count'", arg);
-            return await this.getPrismaRepository(options?.db).count(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "count");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const arg = { where: this.parseWhere(where) };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).count(arg), "count", arg);
     }
     /** Checks whether at least one record matching `where` exists. */
     async exists(where, options) {
-        const start = this.logger.startPerformLog("run exists");
-        try {
-            const arg = { where: (0, where_parser_1.parsePrismaWhere)(where), select: { [this.pkName]: true } };
-            this.logger.logDebug("Resolved Prisma arg for 'exists'", arg);
+        const arg = { where: this.parseWhere(where), select: { [this.pkName]: true } };
+        return this.execMethod(async () => {
             const result = await this.getPrismaRepository(options?.db).findFirst(arg);
             return result !== null;
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "exists");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        }, "exists", arg);
     }
-    /** Executes a raw query/statement against the underlying database, used by `@QueryMethod`. */
+    /** Executes a raw query/statement against the underlying database. */
     async query(query, options) {
         const modifying = options?.modifying ?? false;
         const db = options?.db ?? this.prisma;
@@ -475,128 +432,114 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
         const start = this.logger.startPerformLog(`run raw query (modifying: ${modifying})`);
         try {
             this.logger.logDebug("Running raw query", { query, args, modifying });
-            return modifying
+            const result = modifying
                 ? await db.$executeRawUnsafe(query, ...args)
                 : await db.$queryRawUnsafe(query, ...args);
+            this.logger.endPerformLog(start);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "query");
-        }
-        finally {
             this.logger.endPerformLog(start);
+            throw mapPrismaError(error, "query");
         }
     }
     /** Creates a single record. */
     async create(obj, options) {
-        const start = this.logger.startPerformLog("run create");
-        try {
-            const { create } = (0, data_parser_1.parsePrismaWriteData)(obj, this.pkName, this.relations);
-            const arg = { ...this.resolveReadArg(options), data: create };
-            this.logger.logDebug("Resolved Prisma arg for 'create'", arg);
-            return await this.getPrismaRepository(options?.db).create(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "create");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const { create } = parsePrismaWriteData(obj, this.pkName, this.relations);
+        const arg = {
+            ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+            data: create,
+        };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).create(arg), "create", arg);
     }
     /**
-     * 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).
      */
     async createMany(objs, options) {
-        const start = this.logger.startPerformLog("run createMany");
-        try {
-            const data = objs.map(obj => this.stripRelationFields(obj));
-            const arg = { data, skipDuplicates: options?.ignoreConflicts };
-            this.logger.logDebug("Resolved Prisma arg for 'createMany'", arg);
-            return await this.getPrismaRepository(options?.db).createMany(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "createMany");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        this.assertIgnoreConflictsSupported("createMany", options?.ignoreConflicts);
+        const data = objs.map(obj => this.stripRelationFields(obj));
+        const arg = { data, skipDuplicates: options?.ignoreConflicts };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).createMany(arg), "createMany", arg);
     }
     /**
      * 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).
      */
     async createManyReturning(objs, options) {
         const start = this.logger.startPerformLog("run createManyReturning");
         try {
-            const data = objs.map(obj => this.stripRelationFields(obj));
-            const readArg = this.resolveReadArg(options);
-            const arg = { data, skipDuplicates: options?.ignoreConflicts };
-            this.logger.logDebug("Resolved Prisma arg for 'createManyReturning'", arg);
-            return await this.runTransactional(options?.db, async (tx) => {
-                const repo = this.getPrismaRepository(tx);
-                const created = await repo.createManyAndReturn({
-                    ...arg,
-                    include: undefined,
-                    select: { [this.pkName]: true },
-                });
-                const idsCreated = created.map((_) => _[this.pkName]);
-                return repo.findMany({
-                    ...readArg,
-                    where: { [this.pkName]: { in: idsCreated } },
+            this.assertReturningManySupported("createManyReturning");
+            this.assertIgnoreConflictsSupported("createManyReturning", options?.ignoreConflicts);
+            const readArg = this.resolveReadArg({ select: options?.select, relations: options?.relations });
+            const arg = {
+                data: objs.map(obj => this.stripRelationFields(obj)),
+                skipDuplicates: options?.ignoreConflicts,
+            };
+            this.logger.logDebug("Resolved Prisma args for createManyReturning", { ...readArg, ...arg });
+            let result;
+            if (!readArg.select && !readArg.include) {
+                result = await this.getPrismaRepository(options?.db).createManyAndReturn(arg);
+            }
+            else {
+                result = await this.runTransactional(options?.db, async (tx) => {
+                    const repo = this.getPrismaRepository(tx);
+                    const created = await repo.createManyAndReturn({ ...arg, select: { [this.pkName]: true } });
+                    const idsCreated = created.map((_) => _[this.pkName]);
+                    return await repo.findMany({
+                        ...readArg,
+                        where: { [this.pkName]: { in: idsCreated } },
+                    });
                 });
-            });
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "createManyReturning");
-        }
-        finally {
+            }
             this.logger.endPerformLog(start);
-        }
-    }
-    /**
-     * 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).
-     */
-    async merge(where, obj, options) {
-        const start = this.logger.startPerformLog("run merge");
-        try {
-            const arg = { ...this.resolveReadArg(options), where: (0, where_parser_1.parsePrismaWhere)(where) };
-            this.logger.logDebug("Resolved Prisma arg for 'merge'", arg);
-            const result = await this.getPrismaRepository(options?.db).findFirst(arg);
-            if (!result)
-                return null;
-            return (0, merge_entities_resolver_1.mergeEntities)(result, obj, this.relations);
+            return result;
         }
         catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "merge");
-        }
-        finally {
             this.logger.endPerformLog(start);
-        }
-    }
+            throw mapPrismaError(error, "createManyReturning");
+        }
+    }
+    // /**
+    //  * Fetches the record matching `where` and returns it merged with `obj`,
+    //  * WITHOUT persisting anything. Only the configured `relations` are merged;
+    //  * every other value is replaced. It's on the caller to decide what to do
+    //  * with the result (e.g. call `save` next).
+    //  */
+    // async merge<K extends DeepPartial<T>>(
+    //     where: VSRepoWhere<T>,
+    //     obj: K,
+    //     options?: SimpleAdapterMethodOptions<T>,
+    // ): Promise<(K & T) | null> {
+    //     const arg = {
+    //         ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+    //         where: this.parseWhere(where),
+    //     };
+    //     return this.execMethod(
+    //         async () => {
+    //             const result = await this.getPrismaRepository(options?.db).findFirst(arg);
+    //             if (!result) return null;
+    //             return mergeEntities(result, obj as PlainObject, this.relations) as K & T;
+    //         },
+    //         "merge",
+    //         arg,
+    //     );
+    // }
     /** Creates a record if none matches `where`, otherwise updates it. */
     async upsert(where, create, update, options) {
-        const start = this.logger.startPerformLog("run upsert");
-        try {
-            const parsedCreate = (0, data_parser_1.parsePrismaWriteData)(create, this.pkName, this.relations).create;
-            const parsedUpdate = (0, data_parser_1.parsePrismaWriteData)(update, this.pkName, this.relations).update;
-            const arg = {
-                ...this.resolveReadArg(options),
-                where: (0, where_parser_1.parsePrismaWhere)(where),
-                create: parsedCreate,
-                update: parsedUpdate,
-            };
-            this.logger.logDebug("Resolved Prisma arg for 'upsert'", arg);
-            return await this.getPrismaRepository(options?.db).upsert(arg);
-        }
-        catch (error) {
-            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "upsert");
-        }
-        finally {
-            this.logger.endPerformLog(start);
-        }
+        const parsedCreate = parsePrismaWriteData(create, this.pkName, this.relations).create;
+        const parsedUpdate = parsePrismaWriteData(update, this.pkName, this.relations).update;
+        const arg = {
+            ...this.resolveReadArg({ select: options?.select, relations: options?.relations }),
+            where: this.parseWhere(where),
+            create: parsedCreate,
+            update: parsedUpdate,
+        };
+        return this.execMethod(() => this.getPrismaRepository(options?.db).upsert(arg), "upsert", arg);
     }
     /**
      * Atomically adds `value` to `field` on the record matching `where`,
@@ -605,24 +548,55 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     async incrementOne(field, value, where, options) {
         return this.atomicUpdate("increment", field, value, where, options);
     }
-    /** Same as {@link VSRepoPrisma7Adapter.incrementOne}, subtracting `value` instead of adding it. */
+    /**
+     * Atomically subtracts `value` to `field` on the record matching `where`,
+     * via Prisma's native `{ field: { decrement: value } }` write.
+     */
     async decrementOne(field, value, where, options) {
         return this.atomicUpdate("decrement", field, value, where, options);
     }
-    /** Same as {@link VSRepoPrisma7Adapter.incrementOne}, multiplying the field's current value by `value`. */
+    /**
+     * Atomically multiplies `value` to `field` on the record matching `where`,
+     * via Prisma's native `{ field: { multiply: value } }` write.
+     */
     async multiplyOne(field, value, where, options) {
         return this.atomicUpdate("multiply", field, value, where, options);
     }
     /**
-     * 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 `value` to `field` on the record matching `where`,
+     * via Prisma's native `{ field: { divide: value } }` write.
      */
     async divideOne(field, value, where, options) {
         return this.atomicUpdate("divide", field, value, where, options);
     }
+    /**
+     * Atomically adds `value` to `field` on every record matching `where`,
+     * via Prisma's native `{ field: { increment: value } }` write.
+     */
+    async incrementMany(field, value, where, options) {
+        return this.atomicUpdateMany("increment", field, value, where, options);
+    }
+    /**
+     * Atomically subtracts `value` from `field` on every record matching `where`,
+     * via Prisma's native `{ field: { decrement: value } }` write.
+     */
+    async decrementMany(field, value, where, options) {
+        return this.atomicUpdateMany("decrement", field, value, where, options);
+    }
+    /**
+     * Atomically multiplies `field` by `value` on every record matching `where`,
+     * via Prisma's native `{ field: { multiply: value } }` write.
+     */
+    async multiplyMany(field, value, where, options) {
+        return this.atomicUpdateMany("multiply", field, value, where, options);
+    }
+    /**
+     * Atomically divides `field` by `value` on every record matching `where`,
+     * via Prisma's native `{ field: { divide: value } }` write.
+     */
+    async divideMany(field, value, where, options) {
+        return this.atomicUpdateMany("divide", field, value, where, options);
+    }
     /**
      * Returns the sum of `field` across every record matching `where` (all
      * records if `where` is empty), or `null` if no record matches.
@@ -659,19 +633,12 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
         switch (this.provider) {
             case "postgresql":
             case "cockroachdb":
-                return `$${index + 1}`;
+                return getPostgresPlaceholder(index);
             case "mysql":
             case "sqlite":
-                return "?";
+                return getSqlitePlaceholder(index);
             case "sqlserver":
-                return `@P${index + 1}`;
-            default:
-                throw new vsrepo_1.VSRepoAdapterError("Cannot resolve the raw-query placeholder syntax: the Prisma provider couldn't be detected from the client, " +
-                    "and no 'provider' was set in the adapter config. Set 'provider' in the VSRepoPrisma7Adapter config (one of: " +
-                    "postgresql, cockroachdb, mysql, sqlite, sqlserver) to enable raw-query placeholder compilation " +
-                    "(e.g. VSSql fragments and 'vsPlaceholders').", vsrepo_1.AdapterErrorCode.NOT_SUPPORTED, null);
+                return getSqlServerPlaceholder(index);
         }
     }
 }
-exports.VSRepoPrisma7Adapter = VSRepoPrisma7Adapter;
-//# sourceMappingURL=prisma7.adapter.js.map