@vsrepo/prisma7-adapter 1.3.2 → 2.0.0-dev

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

@@ -1,13 +1,2 @@
 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

@@ -1,101 +1,77 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapPrismaError = mapPrismaError;
-const vsrepo_1 = require("vsrepo");
+import { AdapterErrorCode, VSRepoAdapterError } from "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
+ * @see https://www.prisma.io/docs/orm/v7/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,
+    P1000: AdapterErrorCode.INVALID_CREDENTIALS,
+    P1001: AdapterErrorCode.CONNECTION_FAILED,
+    P1002: AdapterErrorCode.TIMEOUT,
+    P1008: AdapterErrorCode.TIMEOUT,
+    P1010: AdapterErrorCode.ACCESS_DENIED,
+    P1011: AdapterErrorCode.CONNECTION_FAILED,
+    P1017: 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,
+    P2000: AdapterErrorCode.VALUE_TOO_LONG,
+    P2001: AdapterErrorCode.NOT_FOUND,
+    P2002: AdapterErrorCode.UNIQUE_CONSTRAINT_VIOLATION,
+    P2003: AdapterErrorCode.FOREIGN_KEY_VIOLATION,
+    P2004: AdapterErrorCode.CONSTRAINT_VIOLATION,
+    P2005: AdapterErrorCode.CONVERSION_ERROR,
+    P2006: AdapterErrorCode.INVALID_DATA,
+    P2007: AdapterErrorCode.INVALID_DATA,
+    P2010: AdapterErrorCode.INVALID_QUERY,
+    P2011: AdapterErrorCode.NOT_NULL_VIOLATION,
+    P2012: AdapterErrorCode.INVALID_DATA,
+    P2014: AdapterErrorCode.CONSTRAINT_VIOLATION,
+    P2015: AdapterErrorCode.NOT_FOUND,
+    P2016: AdapterErrorCode.INVALID_QUERY,
+    P2017: AdapterErrorCode.NOT_FOUND,
+    P2018: AdapterErrorCode.NOT_FOUND,
+    P2019: AdapterErrorCode.INVALID_DATA,
+    P2020: AdapterErrorCode.CONVERSION_ERROR,
+    P2021: AdapterErrorCode.TABLE_OR_COLUMN_NOT_FOUND,
+    P2022: AdapterErrorCode.TABLE_OR_COLUMN_NOT_FOUND,
+    P2023: AdapterErrorCode.CONVERSION_ERROR,
+    P2024: AdapterErrorCode.CONNECTION_POOL_EXHAUSTED,
+    P2025: AdapterErrorCode.NOT_FOUND,
+    P2026: AdapterErrorCode.NOT_SUPPORTED,
+    P2028: AdapterErrorCode.TRANSACTION_CLOSED,
+    P2030: AdapterErrorCode.NOT_SUPPORTED,
+    P2031: AdapterErrorCode.NOT_SUPPORTED,
+    P2033: AdapterErrorCode.CONVERSION_ERROR,
+    P2034: AdapterErrorCode.TRANSACTION_CONFLICT,
+    P2037: 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)
+export function mapPrismaError(error, operation) {
+    if (error instanceof 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);
+            const code = prismaError.code ? KNOWN_REQUEST_ERROR_CODE_MAP[prismaError.code] : undefined;
+            return new VSRepoAdapterError(`'${operation}' failed (Prisma code: ${prismaError.code ?? "unknown"})`, code ?? AdapterErrorCode.UNKNOWN, error);
         }
         case "PrismaClientInitializationError":
-            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed to initialize/connect to the database`, vsrepo_1.AdapterErrorCode.CONNECTION_FAILED, error);
+            return new VSRepoAdapterError(`'${operation}' failed to initialize/connect to the database`, 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);
+            return new VSRepoAdapterError(`'${operation}' failed due to an internal Prisma engine panic`, AdapterErrorCode.INTERNAL, error);
         case "PrismaClientValidationError":
-            return new vsrepo_1.VSRepoAdapterError(`'${operation}' received invalid data/arguments`, vsrepo_1.AdapterErrorCode.INVALID_DATA, error);
+            return new VSRepoAdapterError(`'${operation}' received invalid data/arguments`, AdapterErrorCode.INVALID_DATA, error);
         case "PrismaClientUnknownRequestError":
-            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed with an unrecognized Prisma error`, vsrepo_1.AdapterErrorCode.UNKNOWN, error);
+            return new VSRepoAdapterError(`'${operation}' failed with an unrecognized Prisma error`, AdapterErrorCode.UNKNOWN, error);
         default:
-            return new vsrepo_1.VSRepoAdapterError(`'${operation}' failed: ${prismaError?.message ?? "unknown error"}`, vsrepo_1.AdapterErrorCode.UNKNOWN, error);
+            return new VSRepoAdapterError(`'${operation}' failed: ${prismaError?.message ?? "unknown error"}`, AdapterErrorCode.UNKNOWN, error);
     }
 }
-//# sourceMappingURL=map-prisma-error.resolver.js.map

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

@@ -1,19 +1,15 @@
+import { AdapterRelations } from "../types/adapter-relations.type.js";
+import { PlainObject } from "../types/plain-object.type.js";
 /**
- * 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.
+ * Merges `obj` into `result` WITHOUT mutating either of them.
  *
- * 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).
+ * - Fields of `obj` that are `undefined` are ignored (they never erase a value).
+ * - Only the fields configured in `relations` are merged: a to-one relation
+ *   has its fields merged with the existing related object (`null` clears it),
+ *   and a to-many relation is merged item by item, matching them by the
+ *   relation's `pk`.
+ * - Every other value — including objects and arrays that are not configured
+ *   as relations, and the nested values of a merged related object — is
+ *   replaced as a whole, never deep merged nor concatenated.
  */
-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;

package/dist/resolvers/merge-entities.resolver.js

@@ -1,27 +1,17 @@
-"use strict";
+import { isPlainObject } from "../validators/is-plain-object.validator.js";
 /**
- * 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).
+ * Shallow-merges `source` into a copy of `target`, skipping `undefined` values
+ * so they never erase an existing field. Values (objects, arrays, `Date`,
+ * `Decimal`...) are assigned by reference, never cloned nor merged.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeEntities = mergeEntities;
-const deepmerge_1 = __importDefault(require("deepmerge"));
-const is_plain_object_validator_1 = require("../validators/is-plain-object.validator");
+function assignDefined(target, source) {
+    const merged = { ...target };
+    for (const [key, value] of Object.entries(source)) {
+        if (value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
+}
 function mergeToManyRelation(target, source, relationPk) {
     const targetMap = new Map();
     const targetWithoutPk = [];
@@ -40,32 +30,34 @@ function mergeToManyRelation(target, source, relationPk) {
             continue;
         }
         const targetItem = targetMap.get(item[relationPk]);
-        targetMap.set(item[relationPk], targetItem ? (0, deepmerge_1.default)(targetItem, item) : item);
+        targetMap.set(item[relationPk], targetItem ? assignDefined(targetItem, item) : item);
     }
     return [...targetMap.values(), ...targetWithoutPk, ...sourceWithoutPk];
 }
-function mergeEntities(result, obj, relations) {
-    if (!relations) {
-        const definedObj = {};
-        for (const key of Object.keys(obj)) {
-            if (obj[key] !== undefined)
-                definedObj[key] = obj[key];
-        }
-        return (0, deepmerge_1.default)(result, definedObj, {
-            arrayMerge: (target, source) => target.concat(source),
-        });
-    }
+/**
+ * Merges `obj` into `result` WITHOUT mutating either of them.
+ *
+ * - Fields of `obj` that are `undefined` are ignored (they never erase a value).
+ * - Only the fields configured in `relations` are merged: a to-one relation
+ *   has its fields merged with the existing related object (`null` clears it),
+ *   and a to-many relation is merged item by item, matching them by the
+ *   relation's `pk`.
+ * - Every other value — including objects and arrays that are not configured
+ *   as relations, and the nested values of a merged related object — is
+ *   replaced as a whole, never deep merged nor concatenated.
+ */
+export function mergeEntities(result, obj, relations) {
     const merged = { ...result };
     for (const [key, field] of Object.entries(obj)) {
         if (field === undefined)
             continue;
-        const relation = relations[key];
+        const relation = relations?.[key];
         if (!relation) {
             merged[key] = field;
             continue;
         }
-        if ((relation.mode === "oto" || relation.mode === "mto") && (0, is_plain_object_validator_1.isPlainObject)(merged[key])) {
-            merged[key] = field === null ? null : (0, deepmerge_1.default)(merged[key], field);
+        if ((relation.mode === "oto" || relation.mode === "mto") && isPlainObject(merged[key])) {
+            merged[key] = field === null ? null : assignDefined(merged[key], field);
             continue;
         }
         if ((relation.mode === "mtm" || relation.mode === "otm") && Array.isArray(merged[key])) {
@@ -76,4 +68,3 @@ function mergeEntities(result, obj, relations) {
     }
     return merged;
 }
-//# sourceMappingURL=merge-entities.resolver.js.map

package/dist/resolvers/resolve-provider.resolver.d.ts

@@ -1,24 +1,4 @@
-import { PrismaProvider } from "../types/prisma-provider.type";
+import { PrismaProvider } from "../types/prisma-provider.type.js";
 export declare const PRISMA_PROVIDERS: string[];
 export declare const PrismaProvidersSet: Set<string>;
-/**
- * Resolves the Prisma datasource provider of a Prisma Client, in the following
- * precedence order:
- *
- * 1. `override` — the `provider` explicitly configured by the user in the
- *    adapter config (wins over everything);
- * 2. `prisma._engineConfig?.activeProvider` — the schema provider baked into
- *    the generated client at compile time (e.g. `"postgresql"` from
- *    `datasource db { provider = "postgresql" }`). This is what Prisma itself
- *    uses internally to select the query compiler and validate the driver
- *    adapter, so it is the most reliable signal available — even though it is
- *    a private/underscored API, with no semver guarantee;
- * 3. `prisma._engineConfig?.adapter?.provider` — the runtime driver adapter's
- *    declared provider (e.g. `"postgres"` for `PrismaPg`), as a secondary
- *    source when `activeProvider` isn't present.
- *
- * Returns `undefined` when none of the sources yield a known provider — the
- * caller decides what to do with that (e.g. `getPlaceholder` throws a
- * `NOT_SUPPORTED` error only when it actually needs to know the provider).
- */
-export declare function resolveProvider(prisma: unknown, override?: PrismaProvider): PrismaProvider | undefined;
+export declare function resolveProvider(prisma: unknown, override?: PrismaProvider): PrismaProvider;

package/dist/resolvers/resolve-provider.resolver.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrismaProvidersSet = exports.PRISMA_PROVIDERS = void 0;
-exports.resolveProvider = resolveProvider;
-exports.PRISMA_PROVIDERS = ["postgresql", "cockroachdb", "mysql", "sqlite", "sqlserver"];
-exports.PrismaProvidersSet = new Set(exports.PRISMA_PROVIDERS);
+import { AdapterErrorCode, VSRepoAdapterError } from "vsrepo";
+export const PRISMA_PROVIDERS = ["postgresql", "cockroachdb", "mysql", "sqlite", "sqlserver"];
+export const PrismaProvidersSet = new Set(PRISMA_PROVIDERS);
 const ADAPTER_PROVIDER_TO_PRISMA_PROVIDER = {
     postgres: "postgresql",
     mysql: "mysql",
@@ -11,41 +8,21 @@ const ADAPTER_PROVIDER_TO_PRISMA_PROVIDER = {
     sqlserver: "sqlserver",
 };
 function isPrismaProvider(value) {
-    return exports.PrismaProvidersSet.has(value);
+    return PrismaProvidersSet.has(value);
 }
-/**
- * Resolves the Prisma datasource provider of a Prisma Client, in the following
- * precedence order:
- *
- * 1. `override` — the `provider` explicitly configured by the user in the
- *    adapter config (wins over everything);
- * 2. `prisma._engineConfig?.activeProvider` — the schema provider baked into
- *    the generated client at compile time (e.g. `"postgresql"` from
- *    `datasource db { provider = "postgresql" }`). This is what Prisma itself
- *    uses internally to select the query compiler and validate the driver
- *    adapter, so it is the most reliable signal available — even though it is
- *    a private/underscored API, with no semver guarantee;
- * 3. `prisma._engineConfig?.adapter?.provider` — the runtime driver adapter's
- *    declared provider (e.g. `"postgres"` for `PrismaPg`), as a secondary
- *    source when `activeProvider` isn't present.
- *
- * Returns `undefined` when none of the sources yield a known provider — the
- * caller decides what to do with that (e.g. `getPlaceholder` throws a
- * `NOT_SUPPORTED` error only when it actually needs to know the provider).
- */
-function resolveProvider(prisma, override) {
+export function resolveProvider(prisma, override) {
     if (override !== undefined) {
         return override;
     }
     const engineConfig = prisma._engineConfig;
-    if (isPrismaProvider(engineConfig?.activeProvider)) {
+    if (typeof engineConfig?.activeProvider === "string" && isPrismaProvider(engineConfig.activeProvider)) {
         return engineConfig.activeProvider;
     }
     const adapterProvider = engineConfig?.adapter?.provider;
-    if (typeof adapterProvider === "string" &&
-        adapterProvider in ADAPTER_PROVIDER_TO_PRISMA_PROVIDER) {
+    if (typeof adapterProvider === "string" && adapterProvider in ADAPTER_PROVIDER_TO_PRISMA_PROVIDER) {
         return ADAPTER_PROVIDER_TO_PRISMA_PROVIDER[adapterProvider];
     }
-    return undefined;
+    throw new VSRepoAdapterError(`Could not detect the Prisma datasource provider from the provided client. ` +
+        `Set the 'provider' option in the adapter config explicitly ` +
+        `(one of: ${PRISMA_PROVIDERS.join(", ")}).`, AdapterErrorCode.NOT_SUPPORTED, null);
 }
-//# sourceMappingURL=resolve-provider.resolver.js.map

package/dist/types/adapter-config.type.d.ts

@@ -1,21 +1,21 @@
 import type { VSLogLevel } from "vsrepo";
-import { AdapterRelations } from "./adapter-relations.type";
-import { Prisma7ClientLike } from "./prisma7-client-like.type";
-import { PrismaClientModels } from "./prisma-client-models.type";
-import { PrismaProvider } from "./prisma-provider.type";
+import { AdapterRelations } from "./adapter-relations.type.js";
+import { Prisma7ClientLike } from "./prisma7-client-like.type.js";
+import { PrismaClientModels } from "./prisma-client-models.type.js";
+import { PrismaProvider } from "./prisma-provider.type.js";
 /**
  * Configuration accepted by `VSRepoPrisma7Adapter`'s constructor, as the
  * second parameter.
  *
  * @publicApi
  */
-export interface VSRepoPrisma7AdapterConfig<T = any, K extends Prisma7ClientLike = Prisma7ClientLike> {
+export interface Prisma7AdapterConfig<T = any, K extends Prisma7ClientLike = Prisma7ClientLike> {
     /** Name of the Prisma Client model/delegate (e.g. `"user"`, as in `prisma.user`). */
-    tableName: [PrismaClientModels<K>] extends [never] ? string : PrismaClientModels<K>;
+    modelName: [PrismaClientModels<K>] extends [never] ? string : PrismaClientModels<K>;
     /** Name of the entity's primary key field (e.g. `"id"`). */
     pkName: keyof T;
     /**
-     * The entity's relation configuration, needed by the `create`/`update`/`merge`
+     * The entity's relation configuration, needed by the `create`/`update`
      * parsers to correctly resolve relation fields (see `Relation`/`AdapterRelations`).
      * Optional: without it, relation fields are passed through to Prisma as-is (raw).
      */
@@ -30,9 +30,4 @@ export interface VSRepoPrisma7AdapterConfig<T = any, K extends Prisma7ClientLike
     provider?: PrismaProvider;
     /** Minimum log level for the adapter's internal `VSLogger`. @default VSLogLevel.WARN */
     logLevel?: VSLogLevel;
-    /**
-     * Duration (in ms) above which a finished operation is logged as `WARN`, flagging a potentially slow query, instead of the usual
-     * `DEBUG` line. Pass `false` to disable slow-operation warnings entirely (every operation is then only ever logged at `DEBUG`); `true` (or omitting the field) uses the default of 300ms.
-     */
-    logSlowThresholdMs?: number | boolean;
 }

package/dist/types/adapter-config.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=adapter-config.type.js.map
+export {};

package/dist/types/adapter-relations.type.d.ts

@@ -1,7 +1,7 @@
 import type { RelationKeys } from "vsrepo";
-import { Relation } from "./relation.type";
+import { Relation } from "./relation.type.js";
 /**
- * Relation configuration for entity `T`, used by the `create`/`update`/`merge`
+ * Relation configuration for entity `T`, used by the `create`/`update`
  * parsers to resolve relation fields according to the v1 behavior (see
  * `Relation`).
  *

package/dist/types/adapter-relations.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=adapter-relations.type.js.map
+export {};

package/dist/types/plain-object.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=plain-object.type.js.map
+export {};

package/dist/types/prisma-arg-like.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=prisma-arg-like.type.js.map
+export {};

package/dist/types/prisma-client-models.type.d.ts

@@ -1,17 +1,17 @@
-import { Prisma7ClientLike } from "./prisma7-client-like.type";
+import { Prisma7ClientLike } from "./prisma7-client-like.type.js";
 /**
  * Extracts the model/delegate names from a Prisma Client instance type,
  * excluding all built-in `$`-prefixed methods (`$connect`, `$transaction`, etc.).
  *
  * The resulting union contains only the keys that represent actual Prisma model
  * delegates (e.g. `"user"`, `"post"`, `"comment"`), enabling type-safe
- * auto-complete when configuring `tableName` in `VSRepoPrisma7AdapterConfig`.
+ * auto-complete when configuring `modelName` in `Prisma7AdapterConfig`.
  *
  * @template T - A Prisma Client type that extends `Prisma7ClientLike`.
  *
  * @example
  * ```ts
- * import { PrismaClient } from "@prisma/client";
+ * import { PrismaClient } from "../generated/prisma/client";
  *
  * // Resolves to: "user" | "post" | "comment" | ...
  * type Models = PrismaClientModels<PrismaClient>;
@@ -19,4 +19,4 @@ import { Prisma7ClientLike } from "./prisma7-client-like.type";
  *
  * @publicApi
  */
-export type PrismaClientModels<T extends Prisma7ClientLike> = Exclude<keyof T, "$connect" | "$disconnect" | "$executeRaw" | "$executeRawUnsafe" | "$extends" | "$on" | "$queryRaw" | "$queryRawUnsafe" | "$transaction" | symbol>;
+export type PrismaClientModels<T extends Prisma7ClientLike> = Exclude<keyof T, "$connect" | "$disconnect" | "$executeRaw" | "$executeRawUnsafe" | "$extends" | "$on" | "$queryRaw" | "$queryRawUnsafe" | "$transaction" | symbol | number>;

package/dist/types/prisma-client-models.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=prisma-client-models.type.js.map
+export {};

package/dist/types/prisma-provider.type.d.ts

@@ -1,5 +1,5 @@
 /**
- * The Prisma schema datasource providers supported by this adapter.
+ * Datasource providers supported by Prisma.
  *
  * @publicApi
  */

package/dist/types/prisma-provider.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=prisma-provider.type.js.map
+export {};

package/dist/types/prisma-repository-like.type.d.ts

@@ -1,4 +1,4 @@
-import { PrismaArgLike } from "./prisma-arg-like.type";
+import { PrismaArgLike } from "./prisma-arg-like.type.js";
 type AnyFn = (arg: PrismaArgLike) => Promise<any>;
 /** `count` do Prisma resolve pra um `number` (na forma simples, sem `select` de agregação). */
 type CountFn = (arg: PrismaArgLike) => Promise<number>;

package/dist/types/prisma-repository-like.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=prisma-repository-like.type.js.map
+export {};

package/dist/types/prisma7-client-like.type.d.ts

@@ -1,12 +1,5 @@
 /**
- * Minimal shape of a Prisma Client (or transaction client) required by the
- * adapter for raw queries (`@QueryMethod`) and for telling a root client
- * apart from an active transaction client.
- *
- * `$on` is only present on the root `PrismaClient` — Prisma's interactive
- * transaction client doesn't expose it — so the adapter uses it to detect
- * whether a `db` passed in `AdapterMethodOptions` is already a transaction
- * (see `Prisma7OrmTypes`).
+ * Duck-typing for a PrismaClient.
  *
  * @publicApi
  */

package/dist/types/prisma7-client-like.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=prisma7-client-like.type.js.map
+export {};

package/dist/types/prisma7-orm-types.type.d.ts

@@ -1,4 +1,4 @@
-import { Prisma7ClientLike } from "./prisma7-client-like.type";
+import { Prisma7ClientLike } from "./prisma7-client-like.type.js";
 /**
  * Helper used to type a `VSRepository`'s `OrmTypes` generic when using
  * `VSRepoPrisma7Adapter`, tying the repository's `getDbClient()`/`transaction()`
@@ -6,7 +6,7 @@ import { Prisma7ClientLike } from "./prisma7-client-like.type";
  *
  * @example
  * ```typescript
- * type MyOrmTypes = Prisma7OrmTypes<PrismaClient, Prisma.TransactionClient>;
+ * type MyOrmTypes = Prisma7OrmTypes<PrismaClient>;
  *
  * class UserRepository extends VSRepository<User, string, MyOrmTypes> { ... }
  * ```

package/dist/types/prisma7-orm-types.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=prisma7-orm-types.type.js.map
+export {};

package/dist/types/relation.type.d.ts

@@ -1,29 +1,35 @@
 /**
- * Configuration of a single relation field, using the same shape the v1 of
- * VSRepository used.
- *
- * - `mode`: cardinality of the relation from the point of view of the entity
- *   that owns the field (`oto` = one-to-one, `mto` = many-to-one,
- *   `otm` = one-to-many, `mtm` = many-to-many).
- * - `restriction`: how `save`/`update`/`upsert` handle to-many relations
- *   (`otm`/`mtm`) and to-one relations pointing to an already-existing record
- *   (matched by `pk`) — `"add"` only creates/connects the items that were
- *   sent (upsert per item), `"set"` also removes/disconnects whatever wasn't
- *   sent.
- * - `pk`: name of the field used as the identifier of the related record,
- *   used to decide between `create` (no pk in the payload) and
- *   `connectOrCreate`/`upsert` (pk present).
- * - `nullable`: for `oto`/`mto` relations, whether the field accepts being set
- *   to `null`. When `true`, sending `null` on update resolves to `delete`
- *   (`oto` + `restriction: "set"`) or `disconnect` (`oto` + `restriction:
- *   "add"`, and `mto`). When `false`/omitted, sending `null` for a to-one
- *   relation throws a `VSRepoAdapterError` (code `INVALID_DATA`).
+ * Configuration of a single relation field.
  *
  * @publicApi
  */
 export interface Relation<T = any> {
+    /**
+     * Cardinality of the relation from the point of view of the entity
+     * that owns the field (`oto` = one-to-one, `mto` = many-to-one,
+     * `otm` = one-to-many, `mtm` = many-to-many).
+     */
     mode: "otm" | "mtm" | "mto" | "oto";
+    /**
+     * How `save`/`update`/`upsert` handle to-many relations
+     * (`otm`/`mtm`) and to-one relations pointing to an already-existing record
+     * (matched by `pk`) — `"add"` only creates/connects the items that were
+     * sent (upsert per item), `"set"` also removes/disconnects whatever wasn't
+     * sent.
+     */
     restriction: "set" | "add";
+    /**
+     * Name of the field used as the identifier of the related record,
+     * used to decide between `create` (no pk in the payload) and
+     * `connectOrCreate`/`upsert` (pk present).
+     */
     pk: keyof T;
+    /**
+     * For `oto`/`mto` relations, whether the field accepts being set
+     * to `null`. When `true`, sending `null` on update resolves to `delete`
+     * (`oto` + `restriction: "set"`) or `disconnect` (`oto` + `restriction:
+     * "add"`, and `mto`). When `false`/omitted, sending `null` for a to-one
+     * relation throws a `VSRepoAdapterError` (code `INVALID_DATA`).
+     */
     nullable?: boolean;
 }

package/dist/types/relation.type.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=relation.type.js.map
+export {};