@vsrepo/prisma7-adapter 1.0.0

package/dist/prisma7.adapter.js

@@ -0,0 +1,505 @@
+"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 validate_adapter_config_validator_1 = require("./validators/validate-adapter-config.validator");
+/**
+ * `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.
+ *
+ * @template T Entity type this adapter operates on.
+ *
+ * @publicApi
+ */
+class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
+    prisma;
+    tableName;
+    pkName;
+    relations;
+    logger;
+    constructor(prisma, config) {
+        super();
+        this.prisma = prisma;
+        const validated = (0, validate_adapter_config_validator_1.validateAdapterConfig)(config);
+        this.tableName = validated.tableName;
+        this.pkName = validated.pkName;
+        this.relations = validated.relations;
+        this.logger = new vsrepo_1.VSLogger(validated.logLevel ?? vsrepo_1.VSLogLevel.WARN, this.constructor.name + "Logger");
+        this.logger.logInfo(`${this.constructor.name} initialized for table '${this.tableName}' (pkName: '${this.pkName}'${this.relations ? `, relations: [${Object.keys(this.relations).join(", ")}]` : ""})`);
+    }
+    getPrismaRepository(db) {
+        return db ? db[this.tableName] : this.prisma[this.tableName];
+    }
+    /** 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);
+        return {
+            select: prismaSelect,
+            include: prismaInclude,
+            orderBy: (0, order_by_parser_1.parsePrismaOrderBy)(options.order),
+            skip: options.pagination?.offset,
+            take: options.pagination?.limit,
+            distinct: options.distinct,
+        };
+    }
+    /**
+     * Strips relation fields from a payload — used by `createMany`/`updateMany`/
+     * `updateManyReturning`, since those Prisma operations don't support nested
+     * writes (scalar fields only). Throws a `VSRepoAdapterError` (code
+     * `NOT_SUPPORTED`) instead of silently ignoring the field, when a configured
+     * relation field is present in the payload.
+     */
+    stripRelationFields(obj) {
+        if (!this.relations)
+            return obj;
+        const data = {};
+        for (const [key, value] of Object.entries(obj)) {
+            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);
+            }
+            data[key] = value;
+        }
+        return data;
+    }
+    /**
+     * Tells apart a root Prisma Client from an active transaction client: only
+     * the root client exposes `$on` (used for event listeners), Prisma's
+     * interactive transaction client doesn't (see `Prisma7ClientLike`).
+     */
+    isRootClient(db) {
+        return typeof db?.$on === "function";
+    }
+    /**
+     * Runs `fn` against a transaction, reusing `db` when it's already a
+     * transaction client (see `isRootClient`) instead of nesting a new one —
+     * this is what lets `saveMany`/`deleteManyReturning` participate in a
+     * transaction already started via `VSRepository.transaction()`.
+     * When `db` isn't provided, or is a root client, a new transaction is
+     * started on it (or on `this.prisma` when `db` isn't provided at all).
+     */
+    async runTransactional(db, fn) {
+        if (db && !this.isRootClient(db)) {
+            this.logger.logDebug("Reusing an already-active transaction client");
+            return fn(db);
+        }
+        return (db ?? this.prisma).$transaction(fn);
+    }
+    /** Returns the underlying ORM client instance used outside of transactions. */
+    getDbClient() {
+        return this.prisma;
+    }
+    /** Runs `fn` inside a native transaction of the underlying ORM/database. */
+    async runInTransaction(fn, options) {
+        try {
+            return await this.prisma.$transaction(fn, options);
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "runInTransaction");
+        }
+    }
+    /** Fetches a single record matching `where`. */
+    async findOne(where, options) {
+        const start = this.logger.startPerformLog("findOne");
+        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);
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "findOne");
+        }
+        finally {
+            this.logger.endPerformLog(start);
+        }
+    }
+    /** Fetches a single record matching `where`, throwing if none is found. */
+    async findOneOrThrow(where, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /** Fetches all records matching `where`. */
+    async findMany(where, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /** Creates or updates (upsert) a single record. */
+    async save(obj, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /**
+     * 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`).
+     */
+    async saveMany(objs, options) {
+        const start = this.logger.startPerformLog("saveMany");
+        try {
+            this.logger.logDebug(`Saving ${objs.length} record(s) individually inside a transaction`);
+            return await this.runTransactional(options?.db, tx => Promise.all(objs.map(obj => this.save(obj, { ...options, db: tx }))));
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "saveMany");
+        }
+        finally {
+            this.logger.endPerformLog(start);
+        }
+    }
+    /** Deletes a single record matching `where`. */
+    async delete(where, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /** Deletes every record matching `where`, returning the count of affected rows. */
+    async deleteMany(where, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /**
+     * Deletes every record matching `where`, returning the deleted records.
+     * Prisma has no `deleteManyAndReturn`, so this fetches then deletes inside
+     * a transaction — reusing `options.db` when it's already a transaction
+     * client (see `runTransactional`), so it stays atomic even when it's not
+     * the one starting the transaction.
+     */
+    async deleteManyReturning(where, options) {
+        const start = this.logger.startPerformLog("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 repo = this.getPrismaRepository(tx);
+                const records = await repo.findMany(findArg);
+                await repo.deleteMany(deleteArg);
+                return records;
+            });
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "deleteManyReturning");
+        }
+        finally {
+            this.logger.endPerformLog(start);
+        }
+    }
+    /** Updates a single record matching `where`. */
+    async update(where, obj, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /** Updates every record matching `where`, returning the count of affected rows. */
+    async updateMany(where, obj, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /** Updates every record matching `where`, returning the updated records. */
+    async updateManyReturning(where, obj, options) {
+        const start = this.logger.startPerformLog("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 } },
+                });
+            });
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "updateManyReturning");
+        }
+        finally {
+            this.logger.endPerformLog(start);
+        }
+    }
+    /** Returns the number of records matching `where`. */
+    async count(where, options) {
+        const start = this.logger.startPerformLog("count");
+        try {
+            const arg = { 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);
+        }
+    }
+    /** Checks whether at least one record matching `where` exists. */
+    async exists(where, options) {
+        const start = this.logger.startPerformLog("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 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);
+        }
+    }
+    /** Executes a raw query/statement against the underlying database, used by `@QueryMethod`. */
+    async query(query, options) {
+        const modifying = options?.modifying ?? false;
+        const db = options?.db ?? this.prisma;
+        const args = options?.args ?? [];
+        const start = this.logger.startPerformLog(`run raw query (modifying: ${modifying})`);
+        try {
+            this.logger.logDebug("Running raw query", { query, args, modifying });
+            return modifying
+                ? await db.$executeRawUnsafe(query, ...args)
+                : await db.$queryRawUnsafe(query, ...args);
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "query");
+        }
+        finally {
+            this.logger.endPerformLog(start);
+        }
+    }
+    /** Creates a single record. */
+    async create(obj, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /**
+     * Creates multiple records in a single operation. Relation fields are
+     * stripped (see `stripRelationFields`), since Prisma's `createMany` doesn't
+     * support nested writes.
+     */
+    async createMany(objs, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+    /**
+     * Creates multiple records in a single operation, returning the created records.
+     */
+    async createManyReturning(objs, options) {
+        const start = this.logger.startPerformLog("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 } },
+                });
+            });
+        }
+        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("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);
+        }
+        catch (error) {
+            throw (0, map_prisma_error_resolver_1.mapPrismaError)(error, "merge");
+        }
+        finally {
+            this.logger.endPerformLog(start);
+        }
+    }
+    /** Creates a record if none matches `where`, otherwise updates it. */
+    async upsert(where, create, update, options) {
+        const start = this.logger.startPerformLog("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);
+        }
+    }
+}
+exports.VSRepoPrisma7Adapter = VSRepoPrisma7Adapter;

package/dist/resolvers/map-prisma-error.resolver.d.ts

@@ -0,0 +1,13 @@
+import { VSRepoAdapterError } from "vsrepo";
+/**
+ * Converts any error caught around a Prisma Client call into a
+ * `VSRepoAdapterError`, so `VSRepoPrisma7Adapter` never lets a raw Prisma (or
+ * other) error escape. Already-wrapped errors — e.g. bubbling up from a
+ * nested adapter call, such as `save` inside `saveMany`, or a config/usage
+ * error thrown by the adapter itself (see `stripRelationFields`) — are
+ * returned as-is instead of being wrapped a second time.
+ *
+ * @param error - The raw error caught around a Prisma Client call.
+ * @param operation - Name of the adapter method that failed, used in the message.
+ */
+export declare function mapPrismaError(error: unknown, operation: string): VSRepoAdapterError;

package/dist/resolvers/map-prisma-error.resolver.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapPrismaError = mapPrismaError;
+const vsrepo_1 = require("vsrepo");
+/**
+ * Maps a Prisma `PrismaClientKnownRequestError.code` (e.g. `"P2002"`) to a
+ * stable, adapter-agnostic `AdapterErrorCode`. Only codes an application is
+ * realistically expected to react to are listed here — anything else falls
+ * back to `AdapterErrorCode.UNKNOWN` in `mapPrismaError`.
+ *
+ * @see https://www.prisma.io/docs/orm/reference/error-reference
+ */
+const KNOWN_REQUEST_ERROR_CODE_MAP = {
+    // Connection / engine errors (P1xxx)
+    P1000: vsrepo_1.AdapterErrorCode.INVALID_CREDENTIALS,
+    P1001: vsrepo_1.AdapterErrorCode.CONNECTION_FAILED,
+    P1002: vsrepo_1.AdapterErrorCode.TIMEOUT,
+    P1008: vsrepo_1.AdapterErrorCode.TIMEOUT,
+    P1010: vsrepo_1.AdapterErrorCode.ACCESS_DENIED,
+    P1011: vsrepo_1.AdapterErrorCode.CONNECTION_FAILED,
+    P1017: vsrepo_1.AdapterErrorCode.CONNECTION_CLOSED,
+    // Query engine errors (P2xxx)
+    P2000: vsrepo_1.AdapterErrorCode.VALUE_TOO_LONG,
+    P2001: vsrepo_1.AdapterErrorCode.NOT_FOUND,
+    P2002: vsrepo_1.AdapterErrorCode.UNIQUE_CONSTRAINT_VIOLATION,
+    P2003: vsrepo_1.AdapterErrorCode.FOREIGN_KEY_VIOLATION,
+    P2004: vsrepo_1.AdapterErrorCode.CONSTRAINT_VIOLATION,
+    P2005: vsrepo_1.AdapterErrorCode.CONVERSION_ERROR,
+    P2006: vsrepo_1.AdapterErrorCode.INVALID_DATA,
+    P2007: vsrepo_1.AdapterErrorCode.INVALID_DATA,
+    P2010: vsrepo_1.AdapterErrorCode.INVALID_QUERY,
+    P2011: vsrepo_1.AdapterErrorCode.NOT_NULL_VIOLATION,
+    P2012: vsrepo_1.AdapterErrorCode.INVALID_DATA,
+    P2014: vsrepo_1.AdapterErrorCode.CONSTRAINT_VIOLATION,
+    P2015: vsrepo_1.AdapterErrorCode.NOT_FOUND,
+    P2016: vsrepo_1.AdapterErrorCode.INVALID_QUERY,
+    P2017: vsrepo_1.AdapterErrorCode.NOT_FOUND,
+    P2018: vsrepo_1.AdapterErrorCode.NOT_FOUND,
+    P2019: vsrepo_1.AdapterErrorCode.INVALID_DATA,
+    P2020: vsrepo_1.AdapterErrorCode.CONVERSION_ERROR,
+    P2021: vsrepo_1.AdapterErrorCode.TABLE_OR_COLUMN_NOT_FOUND,
+    P2022: vsrepo_1.AdapterErrorCode.TABLE_OR_COLUMN_NOT_FOUND,
+    P2023: vsrepo_1.AdapterErrorCode.CONVERSION_ERROR,
+    P2024: vsrepo_1.AdapterErrorCode.CONNECTION_POOL_EXHAUSTED,
+    P2025: vsrepo_1.AdapterErrorCode.NOT_FOUND,
+    P2026: vsrepo_1.AdapterErrorCode.NOT_SUPPORTED,
+    P2028: vsrepo_1.AdapterErrorCode.TRANSACTION_CLOSED,
+    P2030: vsrepo_1.AdapterErrorCode.NOT_SUPPORTED,
+    P2031: vsrepo_1.AdapterErrorCode.NOT_SUPPORTED,
+    P2033: vsrepo_1.AdapterErrorCode.CONVERSION_ERROR,
+    P2034: vsrepo_1.AdapterErrorCode.TRANSACTION_CONFLICT,
+    P2037: vsrepo_1.AdapterErrorCode.CONNECTION_POOL_EXHAUSTED,
+};
+/**
+ * Reads the Prisma error class name (`PrismaClientKnownRequestError`,
+ * `PrismaClientInitializationError`, ...) off a caught error without
+ * importing `@prisma/client` — the adapter never imports concrete Prisma
+ * types (see `Prisma7ClientLike`), so this duck-types via `error.name`
+ * instead of using `instanceof`.
+ */
+function prismaErrorName(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    return error.name || error.constructor?.name;
+}
+/**
+ * Converts any error caught around a Prisma Client call into a
+ * `VSRepoAdapterError`, so `VSRepoPrisma7Adapter` never lets a raw Prisma (or
+ * other) error escape. Already-wrapped errors — e.g. bubbling up from a
+ * nested adapter call, such as `save` inside `saveMany`, or a config/usage
+ * error thrown by the adapter itself (see `stripRelationFields`) — are
+ * returned as-is instead of being wrapped a second time.
+ *
+ * @param error - The raw error caught around a Prisma Client call.
+ * @param operation - Name of the adapter method that failed, used in the message.
+ */
+function mapPrismaError(error, operation) {
+    if (error instanceof vsrepo_1.VSRepoAdapterError)
+        return error;
+    const name = prismaErrorName(error);
+    const prismaError = error;
+    switch (name) {
+        case "PrismaClientKnownRequestError": {
+            const code = prismaError.code
+                ? KNOWN_REQUEST_ERROR_CODE_MAP[prismaError.code]
+                : undefined;
+            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed (Prisma code: ${prismaError.code ?? "unknown"})`, code ?? vsrepo_1.AdapterErrorCode.UNKNOWN, error);
+        }
+        case "PrismaClientInitializationError":
+            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed to initialize/connect to the database`, vsrepo_1.AdapterErrorCode.CONNECTION_FAILED, error);
+        case "PrismaClientRustPanicError":
+            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed due to an internal Prisma engine panic`, vsrepo_1.AdapterErrorCode.INTERNAL, error);
+        case "PrismaClientValidationError":
+            return new vsrepo_1.VSRepoAdapterError(`'${operation}' received invalid data/arguments`, vsrepo_1.AdapterErrorCode.INVALID_DATA, error);
+        case "PrismaClientUnknownRequestError":
+            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed with an unrecognized Prisma error`, vsrepo_1.AdapterErrorCode.UNKNOWN, error);
+        default:
+            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed: ${prismaError?.message ?? "unknown error"}`, vsrepo_1.AdapterErrorCode.UNKNOWN, error);
+    }
+}

package/dist/resolvers/merge-entities.resolver.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Faz o merge profundo, EM MEMÓRIA (sem persistir nada no banco), de `result`
+ * (registro já encontrado) com `obj` (payload enviado) — réplica exata do
+ * comportamento do `merge` da v1: ele só busca o registro e devolve o merge,
+ * quem decide o que fazer com o resultado (ex: chamar `save` depois) é quem
+ * chamou.
+ *
+ * Sem `relations`, é um deep merge padrão (arrays são concatenados). Com
+ * `relations`:
+ *  - to-one (`oto`/`mto`) recebe merge direto (ou vira `null` se `obj` mandar
+ *    `null` explicitamente)
+ *  - to-many (`otm`/`mtm`) casa os itens de `result[key]` com os de `obj[key]`
+ *    pela `pk` configurada: item com PK que bate -> merge entre os dois; item
+ *    sem correspondente -> apenas adicionado. Itens existentes que não
+ *    aparecem em `obj[key]` são mantidos (merge nunca remove nada).
+ */
+import { AdapterRelations } from "../types/adapter-relations.type";
+import { PlainObject } from "../types/plain-object.type";
+export declare function mergeEntities<T extends PlainObject, U extends PlainObject>(result: T, obj: U, relations?: AdapterRelations<T>): U & T;