@vsrepo/prisma7-adapter 1.0.0 → 1.0.3

package/README.md

@@ -34,6 +34,7 @@
   - [`relations` in method options (read)](#relations-in-method-options-read)
 - [`merge`](#merge)
 - [`createMany`/`createManyReturning`/`updateMany`/`updateManyReturning` don't support nested writes](#createmanycreatemanyreturningupdatemanyupdatemanyreturning-dont-support-nested-writes)
+- [Provider-specific limitations](#provider-specific-limitations)
 - [Transactions](#transactions)
 - [Logging](#logging)
 - [Requirements](#requirements)
@@ -202,6 +203,18 @@ For to-many relations (`otm`/`mtm`), items in the stored record and items in `ob
 
 > Note on return order: `createManyReturning` don't guarantee the returned records follow the order of the input payload (`objs`). Their result comes from a second `findMany` (re-querying the inserted/updated rows by primary key), so the order is only guaranteed when you pass `order` in the options.
 
+## Provider-specific limitations
+
+Some Prisma features this adapter relies on aren't available on every database provider. If you use one of these features on an unsupported provider, Prisma itself will throw a validation error (or, in future versions, the adapter may validate this upfront — see below).
+
+| Feature | Supported providers | Not supported |
+| --- | --- | --- |
+| `mode: "insensitive"` (used by `findByXIgnoreCase` dynamic methods) | PostgreSQL, MongoDB | MySQL, SQLite, SQL Server, CockroachDB — MySQL and SQL Server are case-insensitive by default, so no `mode` is needed there; SQLite is only case-insensitive for ASCII characters |
+| `createManyReturning` / `updateManyReturning` (built on Prisma's `createManyAndReturn`/`updateManyAndReturn`) | PostgreSQL, CockroachDB, SQLite | MySQL, SQL Server, MongoDB |
+| `skipDuplicates` on `createManyIgnoreConflicts` / `createManyReturningIgnoreConflicts` | PostgreSQL, MySQL, CockroachDB | MongoDB, SQL Server, SQLite |
+
+> These limitations come from Prisma itself, not from this adapter — see [Prisma's case sensitivity docs](https://www.prisma.io/docs/orm/v7/reference/prisma-client-reference#mode) and [CRUD reference](https://www.prisma.io/docs/orm/v7/prisma-client/queries/crud) for details.
+
 ## Transactions
 
 **Every** method accepts `options.db` and runs its operation on the client/transaction you pass — the difference is in **how** each one treats it:
@@ -223,6 +236,36 @@ await userRepository.transaction(async tx => {
 });
 ```
 
+### Concurrency in `deleteManyReturning`
+
+`deleteManyReturning` runs a `findMany` on the given `where` (to capture the records it will return) and then **re-applies the same `where`** to a `deleteMany`. Prisma has no native `deleteManyAndReturn`, which is why the delete is driven by the `where` instead of by the records fetched in the `findMany`.
+
+Because of this two-step shape, a concurrent change between the `findMany` and the `deleteMany` can make them diverge:
+
+- a row **inserted after** the `findMany` that matches the `where` will still be deleted, even though it wasn't returned;
+- a row that **stops matching** the `where` before the `deleteMany` runs won't be deleted, even though it was returned.
+
+In other words, the returned records and the rows actually deleted are not guaranteed to be identical under concurrency.
+
+If you need to guarantee there are no concurrency issues, run this method inside a `repository.transaction()` at a higher isolation level — e.g. `SERIALIZABLE`:
+
+```typescript
+import { VSRepository, TransactionIsolationLevel } from "vsrepo";
+
+await userRepository.transaction(async tx => {
+    // Atomic: no concurrent insert/update can slip between the findMany
+    // and the deleteMany, since SERIALIZABLE isolates this transaction.
+    // `deleteManyReturning` is reached through the dynamic method you mapped
+    // to the adapter (e.g. a `@DynamicMethod()` exposing `deleteManyReturning`),
+    // always passing `{ db: tx }` so it runs inside this transaction.
+    const deleted = await userRepository.deleteManyReturningByIdIn([...], { db: tx });
+}, {
+    isolationLevel: TransactionIsolationLevel.SERIALIZABLE,
+});
+```
+
+> The isolation level applies only when the repository call actually runs **inside** that transaction (i.e. with `{ db: tx }`). When `deleteManyReturning` starts its own internal transaction (no `options.db` passed), it falls back to the default isolation level.
+
 ## Logging
 
 The adapter uses `VSLogger` (from `vsrepo`) internally: every method logs a `DEBUG` line with the resolved Prisma arg, and start/end performance logs (surfacing a `WARN` for slow operations). Set `logLevel` in the constructor config to control verbosity; it defaults to `VSLogLevel.WARN`.

package/README.pt-BR.md

@@ -34,6 +34,7 @@ Implementação de `VSRepoAdapter` para o [VSRepository v2](https://github.com/j
   - [`relations` nas options (leitura)](#relations-nas-options-leitura)
 - [`merge`](#merge)
 - [`createMany`/`createManyReturning`/`updateMany`/`updateManyReturning` não suportam nested writes](#createmanycreatemanyreturningupdatemanyupdatemanyreturning-não-suportam-nested-writes)
+- [Limitações por provider](#limitações-por-provider)
 - [Transactions](#transactions)
 - [Logging](#logging)
 - [Requisitos](#requisitos)
@@ -202,6 +203,18 @@ Pra relations to-many (`otm`/`mtm`), os itens do registro salvo e os itens de `o
 
 > Nota sobre a ordem de retorno: `createManyReturning` não garante que os registros devolvidos seguem a ordem do payload de entrada (`objs`). O resultado vem de um segundo `findMany` (re-buscando as linhas inseridas/atualizadas pela primary key), então a ordem só é garantida quando você passa `order` nas options.
 
+## Limitações por provider
+
+Alguns recursos do Prisma que esse adapter usa não estão disponíveis em todo banco. Se você usar um desses recursos num provider sem suporte, o próprio Prisma lança um erro de validação (ou, em versões futuras, o adapter pode validar isso antecipadamente — ver abaixo).
+
+| Recurso | Providers com suporte | Sem suporte |
+| --- | --- | --- |
+| `mode: "insensitive"` (usado pelos métodos dinâmicos `findByXIgnoreCase`) | PostgreSQL, MongoDB | MySQL, SQLite, SQL Server, CockroachDB — MySQL e SQL Server já são case-insensitive por padrão, então não precisam de `mode`; SQLite só é case-insensitive pra caracteres ASCII |
+| `createManyReturning` / `updateManyReturning` (baseados no `createManyAndReturn`/`updateManyAndReturn` do Prisma) | PostgreSQL, CockroachDB, SQLite | MySQL, SQL Server, MongoDB |
+| `skipDuplicates` no `createManyIgnoreConflicts` / `createManyReturningIgnoreConflicts` | PostgreSQL, MySQL, CockroachDB | MongoDB, SQL Server, SQLite |
+
+> Essas limitações vêm do próprio Prisma, não do adapter — veja a [doc de case sensitivity](https://www.prisma.io/docs/orm/v7/reference/prisma-client-reference#mode) e a [referência de CRUD](https://www.prisma.io/docs/orm/v7/prisma-client/queries/crud) do Prisma pra mais detalhes.
+
 ## Transactions
 
 **Todos** os métodos aceitam `options.db` e executam a operação no client/transaction passado — a diferença está em **como** cada um o trata:
@@ -223,6 +236,36 @@ await userRepository.transaction(async tx => {
 });
 ```
 
+### Concorrência em `deleteManyReturning`
+
+O `deleteManyReturning` roda um `findMany` no `where` informado (pra capturar os registros que vai devolver) e depois **re-aplica o mesmo `where`** num `deleteMany`. Como o Prisma não tem um `deleteManyAndReturn` nativo, o delete é guiado pelo `where` — e não pelos registros retornados no `findMany`.
+
+Por causa desse formato em duas etapas, uma alteração concorrente entre o `findMany` e o `deleteMany` pode fazer os dois divergirem:
+
+- uma linha **inserida depois** do `findMany` que bate com o `where` ainda será deletada, mesmo não tendo sido retornada;
+- uma linha que **deixa de bater** com o `where` antes do `deleteMany` rodar não será deletada, mesmo tendo sido retornada.
+
+Ou seja: os registros retornados e as linhas realmente deletadas não têm garantia de serem idênticos sob concorrência.
+
+Se você quiser garantir que não haverá problemas de concorrência, rode esse método **dentro** de um `repository.transaction()` num nível de isolamento mais alto — ex.: `SERIALIZABLE`:
+
+```typescript
+import { VSRepository, TransactionIsolationLevel } from "vsrepo";
+
+await userRepository.transaction(async tx => {
+    // Atômico: nenhum insert/update concorrente consegue entrar entre o
+    // findMany e o deleteMany, pois o SERIALIZABLE isola esta transaction.
+    // O `deleteManyReturning` é acessado através do método dinâmico que você
+    // mapeou pro adapter (ex.: um `@DynamicMethod()` expondo `deleteManyReturning`),
+    // sempre passando `{ db: tx }` pra rodar dentro desta transaction.
+    const deleted = await userRepository.deleteManyReturningByIdIn([...], { db: tx });
+}, {
+    isolationLevel: TransactionIsolationLevel.SERIALIZABLE,
+});
+```
+
+> O nível de isolamento só se aplica quando a chamada roda **dentro** daquela transaction (ou seja, com `{ db: tx }`). Quando o `deleteManyReturning` inicia a própria transaction interna (sem `options.db`), ele usa o nível de isolamento padrão.
+
 ## Logging
 
 O adapter usa o `VSLogger` (de `vsrepo`) internamente: todo método loga uma linha `DEBUG` com o arg resolvido do Prisma, além de logs de performance de início/fim (com `WARN` pra operações lentas). Configure `logLevel` na config do construtor pra controlar a verbosidade; o default é `VSLogLevel.WARN`.

package/dist/prisma7.adapter.d.ts

@@ -79,10 +79,18 @@ export declare class VSRepoPrisma7Adapter<T> extends VSRepoAdapter<T> {
     deleteMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
     /**
      * 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.
+     *
+     * 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`).
+     *
+     * Because the delete is driven by the same `where` (not by the fetched
+     * records), a concurrent change between the two operations can make them
+     * diverge — e.g. a row inserted after the `findMany` matching the `where`
+     * would still be deleted, while a row changed to stop matching wouldn't.
+     * If you need to guarantee no concurrency issues, run this method inside a
+     * `repository.transaction()` with a higher isolation level, e.g.
+     * `TransactionIsolationLevel.SERIALIZABLE`.
      */
     deleteManyReturning(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
     /** Updates a single record matching `where`. */

package/dist/prisma7.adapter.js

@@ -40,7 +40,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
         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 = 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(", ")}]` : ""})`);
     }
     getPrismaRepository(db) {
@@ -121,7 +121,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Fetches a single record matching `where`. */
     async findOne(where, options) {
-        const start = this.logger.startPerformLog("findOne");
+        const start = this.logger.startPerformLog("run findOne");
         try {
             const arg = { ...this.resolveReadArg(options), where: (0, where_parser_1.parsePrismaWhere)(where) };
             this.logger.logDebug("Resolved Prisma arg for 'findOne'", arg);
@@ -136,7 +136,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Fetches a single record matching `where`, throwing if none is found. */
     async findOneOrThrow(where, options) {
-        const start = this.logger.startPerformLog("findOneOrThrow");
+        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);
@@ -151,7 +151,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Fetches all records matching `where`. */
     async findMany(where, options) {
-        const start = this.logger.startPerformLog("findMany");
+        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);
@@ -166,7 +166,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Creates or updates (upsert) a single record. */
     async save(obj, options) {
-        const start = this.logger.startPerformLog("save");
+        const start = this.logger.startPerformLog("run save");
         try {
             const objAny = obj;
             const pkValue = objAny[this.pkName];
@@ -197,7 +197,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
      * `runTransactional`).
      */
     async saveMany(objs, options) {
-        const start = this.logger.startPerformLog("saveMany");
+        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, tx => Promise.all(objs.map(obj => this.save(obj, { ...options, db: tx }))));
@@ -211,7 +211,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Deletes a single record matching `where`. */
     async delete(where, options) {
-        const start = this.logger.startPerformLog("delete");
+        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);
@@ -226,7 +226,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Deletes every record matching `where`, returning the count of affected rows. */
     async deleteMany(where, options) {
-        const start = this.logger.startPerformLog("deleteMany");
+        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);
@@ -241,13 +241,21 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /**
      * 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.
+     *
+     * 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`).
+     *
+     * 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`.
      */
     async deleteManyReturning(where, options) {
-        const start = this.logger.startPerformLog("deleteManyReturning");
+        const start = this.logger.startPerformLog("run deleteManyReturning");
         try {
             const prismaWhere = (0, where_parser_1.parsePrismaWhere)(where);
             const findArg = { ...this.resolveReadArg(options), where: prismaWhere };
@@ -272,7 +280,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Updates a single record matching `where`. */
     async update(where, obj, options) {
-        const start = this.logger.startPerformLog("update");
+        const start = this.logger.startPerformLog("run update");
         try {
             const { update } = (0, data_parser_1.parsePrismaWriteData)(obj, this.pkName, this.relations);
             const arg = {
@@ -292,7 +300,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Updates every record matching `where`, returning the count of affected rows. */
     async updateMany(where, obj, options) {
-        const start = this.logger.startPerformLog("updateMany");
+        const start = this.logger.startPerformLog("run updateMany");
         try {
             const data = this.stripRelationFields(obj);
             const arg = { where: (0, where_parser_1.parsePrismaWhere)(where), data };
@@ -308,7 +316,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Updates every record matching `where`, returning the updated records. */
     async updateManyReturning(where, obj, options) {
-        const start = this.logger.startPerformLog("updateManyReturning");
+        const start = this.logger.startPerformLog("run updateManyReturning");
         try {
             const data = this.stripRelationFields(obj);
             const readArg = this.resolveReadArg(options);
@@ -341,7 +349,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Returns the number of records matching `where`. */
     async count(where, options) {
-        const start = this.logger.startPerformLog("count");
+        const start = this.logger.startPerformLog("run count");
         try {
             const arg = { where: (0, where_parser_1.parsePrismaWhere)(where) };
             this.logger.logDebug("Resolved Prisma arg for 'count'", arg);
@@ -356,7 +364,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Checks whether at least one record matching `where` exists. */
     async exists(where, options) {
-        const start = this.logger.startPerformLog("exists");
+        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);
@@ -391,7 +399,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Creates a single record. */
     async create(obj, options) {
-        const start = this.logger.startPerformLog("create");
+        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 };
@@ -411,7 +419,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
      * support nested writes.
      */
     async createMany(objs, options) {
-        const start = this.logger.startPerformLog("createMany");
+        const start = this.logger.startPerformLog("run createMany");
         try {
             const data = objs.map(obj => this.stripRelationFields(obj));
             const arg = { data, skipDuplicates: options?.ignoreConflicts };
@@ -429,7 +437,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
      * Creates multiple records in a single operation, returning the created records.
      */
     async createManyReturning(objs, options) {
-        const start = this.logger.startPerformLog("createManyReturning");
+        const start = this.logger.startPerformLog("run createManyReturning");
         try {
             const data = objs.map(obj => this.stripRelationFields(obj));
             const readArg = this.resolveReadArg(options);
@@ -463,7 +471,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
      * what to do with the result (e.g. call `save` next).
      */
     async merge(where, obj, options) {
-        const start = this.logger.startPerformLog("merge");
+        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);
@@ -481,7 +489,7 @@ class VSRepoPrisma7Adapter extends vsrepo_1.VSRepoAdapter {
     }
     /** Creates a record if none matches `where`, otherwise updates it. */
     async upsert(where, create, update, options) {
-        const start = this.logger.startPerformLog("upsert");
+        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;

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

@@ -46,7 +46,12 @@ function mergeToManyRelation(target, source, relationPk) {
 }
 function mergeEntities(result, obj, relations) {
     if (!relations) {
-        return (0, deepmerge_1.default)(result, obj, {
+        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),
         });
     }

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

@@ -19,4 +19,8 @@ export interface VSRepoPrisma7AdapterConfig<T = any> {
     relations?: AdapterRelations<T>;
     /** Minimum log level for the adapter's internal `VSLogger`. @default VSLogLevel.WARN */
     logLevel?: VSLogLevel;
+    /**
+     * Duration (in ms) above which a finished operation is logged, flagging potentially slow queries. Defaults to 300ms.
+     */
+    logSlowThresholdMs?: number;
 }

package/dist/validators/adapter-config.schema.d.ts

@@ -10,4 +10,5 @@ export declare const adapterConfigSchema: v.ObjectSchema<{
         readonly nullable: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>, undefined>, undefined>;
     readonly logLevel: v.OptionalSchema<v.EnumSchema<typeof VSLogLevel, undefined>, undefined>;
+    readonly logSlowThresholdMs: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.GtValueAction<number, 0, undefined>]>, undefined>;
 }, undefined>;

package/dist/validators/adapter-config.schema.js

@@ -42,4 +42,5 @@ exports.adapterConfigSchema = v.object({
     pkName: v.pipe(v.string(), v.minLength(1)),
     relations: v.optional(v.record(v.string(), relation_schema_1.relationSchema)),
     logLevel: v.optional(v.enum(vsrepo_1.VSLogLevel)),
+    logSlowThresholdMs: v.optional(v.pipe(v.number(), v.gtValue(0))),
 });

package/package.json

@@ -1,84 +1,84 @@
-{
-  "name": "@vsrepo/prisma7-adapter",
-  "version": "1.0.0",
-  "description": "VSRepository adapter implementation backed by Prisma 7, translating every VSRepository operation into Prisma Client calls.",
-  "homepage": "https://github.com/jaobrabo123/VSRepoPrisma7Adapter#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jaobrabo123/VSRepoPrisma7Adapter.git"
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.js"
-    }
-  },
-  "type": "commonjs",
-  "files": [
-    "dist",
-    "README.md",
-    "README.pt-BR.md"
-  ],
-  "engines": {
-    "node": ">=18"
-  },
-  "scripts": {
-    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
-    "build": "npm run clean && tsc -p tsconfig.build.json",
-    "prepack": "npm run build",
-    "typecheck": "tsc --noEmit -p tsconfig.build.json",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
-    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
-    "test:types": "tsc --noEmit -p tests/tsconfig.json"
-  },
-  "keywords": [
-    "prisma",
-    "prisma7",
-    "repository",
-    "orm",
-    "typescript",
-    "repository-pattern",
-    "vsrepo",
-    "vsrepository",
-    "adapter"
-  ],
-  "author": "João Pedro Azevedo Freire Mecenas",
-  "license": "MIT",
-  "peerDependencies": {
-    "@prisma/client": "^7.10.0",
-    "vsrepo": "^2.0.0"
-  },
-  "dependencies": {
-    "deepmerge": "^4.3.1",
-    "valibot": "^1.4.2"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.29.7",
-    "@babel/plugin-proposal-decorators": "^7.29.7",
-    "@babel/preset-env": "^7.29.7",
-    "@babel/preset-typescript": "^7.29.7",
-    "@jest/globals": "^30.5.0",
-    "@prisma/adapter-pg": "^7.10.0",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^26.4.0",
-    "@types/pg": "^8.23.1",
-    "babel-jest": "^30.5.0",
-    "cross-env": "^10.1.0",
-    "dotenv": "^17.4.2",
-    "jest": "^30.5.0",
-    "pg": "^8.23.0",
-    "prisma": "^7.10.0",
-    "tsx": "^4.23.12",
-    "typescript": "^7.0.2"
-  },
-  "allowScripts": {
-    "prisma@7.10.0": true,
-    "@parcel/watcher@2.6.0": true,
-    "unrs-resolver@1.12.2": true,
-    "@prisma/engines@7.10.0": true,
-    "esbuild@0.28.2": true
-  }
-}
+{
+  "name": "@vsrepo/prisma7-adapter",
+  "version": "1.0.3",
+  "description": "VSRepository adapter implementation backed by Prisma 7, translating every VSRepository operation into Prisma Client calls.",
+  "homepage": "https://github.com/jaobrabo123/VSRepoPrisma7Adapter#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaobrabo123/VSRepoPrisma7Adapter.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "type": "commonjs",
+  "files": [
+    "dist",
+    "README.md",
+    "README.pt-BR.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "clean": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "prepack": "npm run build",
+    "typecheck": "tsc --noEmit -p tsconfig.build.json",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:types": "tsc --noEmit -p tests/tsconfig.json"
+  },
+  "keywords": [
+    "prisma",
+    "prisma7",
+    "repository",
+    "orm",
+    "typescript",
+    "repository-pattern",
+    "vsrepo",
+    "vsrepository",
+    "adapter"
+  ],
+  "author": "João Pedro Azevedo Freire Mecenas",
+  "license": "MIT",
+  "peerDependencies": {
+    "@prisma/client": "^7.10.0",
+    "vsrepo": "^2.0.0"
+  },
+  "dependencies": {
+    "deepmerge": "^4.3.1",
+    "valibot": "^1.4.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.7",
+    "@babel/plugin-proposal-decorators": "^7.29.7",
+    "@babel/preset-env": "^7.29.7",
+    "@babel/preset-typescript": "^7.29.7",
+    "@jest/globals": "^30.5.0",
+    "@prisma/adapter-pg": "^7.10.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.4.0",
+    "@types/pg": "^8.23.1",
+    "babel-jest": "^30.5.0",
+    "cross-env": "^10.1.0",
+    "dotenv": "^17.4.2",
+    "jest": "^30.5.0",
+    "pg": "^8.23.0",
+    "prisma": "^7.10.0",
+    "tsx": "^4.23.12",
+    "typescript": "^7.0.2"
+  },
+  "allowScripts": {
+    "prisma@7.10.0": true,
+    "@parcel/watcher@2.6.0": true,
+    "unrs-resolver@1.12.2": true,
+    "@prisma/engines@7.10.0": true,
+    "esbuild@0.28.2": true
+  }
+}