@vsrepo/prisma7-adapter 1.0.0

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

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * 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).
+ */
+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 mergeToManyRelation(target, source, relationPk) {
+    const targetMap = new Map();
+    const targetWithoutPk = [];
+    for (const item of target) {
+        if (item[relationPk] !== undefined) {
+            targetMap.set(item[relationPk], item);
+        }
+        else {
+            targetWithoutPk.push(item);
+        }
+    }
+    const sourceWithoutPk = [];
+    for (const item of source) {
+        if (item[relationPk] === undefined) {
+            sourceWithoutPk.push(item);
+            continue;
+        }
+        const targetItem = targetMap.get(item[relationPk]);
+        targetMap.set(item[relationPk], targetItem ? (0, deepmerge_1.default)(targetItem, item) : item);
+    }
+    return [...targetMap.values(), ...targetWithoutPk, ...sourceWithoutPk];
+}
+function mergeEntities(result, obj, relations) {
+    if (!relations) {
+        return (0, deepmerge_1.default)(result, obj, {
+            arrayMerge: (target, source) => target.concat(source),
+        });
+    }
+    const merged = { ...result };
+    for (const [key, field] of Object.entries(obj)) {
+        if (field === undefined)
+            continue;
+        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);
+            continue;
+        }
+        if ((relation.mode === "mtm" || relation.mode === "otm") && Array.isArray(merged[key])) {
+            merged[key] = mergeToManyRelation(merged[key], field, relation.pk);
+            continue;
+        }
+        merged[key] = field;
+    }
+    return merged;
+}

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

@@ -0,0 +1,22 @@
+import type { VSLogLevel } from "vsrepo";
+import { AdapterRelations } from "./adapter-relations.type";
+/**
+ * Configuration accepted by `VSRepoPrisma7Adapter`'s constructor, as the
+ * second parameter.
+ *
+ * @publicApi
+ */
+export interface VSRepoPrisma7AdapterConfig<T = any> {
+    /** Name of the Prisma Client model/delegate (e.g. `"user"`, as in `prisma.user`). */
+    tableName: string;
+    /** 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`
+     * parsers to correctly resolve relation fields (see `Relation`/`AdapterRelations`).
+     * Optional: without it, relation fields are passed through to Prisma as-is (raw).
+     */
+    relations?: AdapterRelations<T>;
+    /** Minimum log level for the adapter's internal `VSLogger`. @default VSLogLevel.WARN */
+    logLevel?: VSLogLevel;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,16 @@
+import type { RelationKeys } from "vsrepo";
+import { Relation } from "./relation.type";
+/**
+ * Relation configuration for entity `T`, used by the `create`/`update`/`merge`
+ * parsers to resolve relation fields according to the v1 behavior (see
+ * `Relation`).
+ *
+ * Keyed by the relation fields of `T` (`RelationKeys<T>`). Without this
+ * configuration (adapter built without `relations`), relation fields are
+ * passed through to Prisma as-is, with no special resolution.
+ *
+ * @publicApi
+ */
+export type AdapterRelations<T> = Partial<{
+    [P in RelationKeys<T>]: Relation<NonNullable<T[P]> extends Array<infer U> ? U : NonNullable<T[P]>>;
+}>;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/plain-object.type.d.ts

@@ -0,0 +1 @@
+export type PlainObject = Record<string, any>;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,14 @@
+export interface PrismaArgLike {
+    where?: object;
+    select?: object;
+    include?: object;
+    data?: any;
+    create?: any;
+    update?: any;
+    orderBy?: object | object[];
+    skip?: number;
+    take?: number;
+    cursor?: object;
+    skipDuplicates?: boolean;
+    distinct?: any[];
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,20 @@
+import { PrismaArgLike } from "./prisma-arg-like.type";
+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>;
+export type PrismaRepositoryLike = {
+    findFirst: AnyFn;
+    findFirstOrThrow: AnyFn;
+    findMany: AnyFn;
+    create: AnyFn;
+    createMany: AnyFn;
+    createManyAndReturn: AnyFn;
+    update: AnyFn;
+    updateMany: AnyFn;
+    updateManyAndReturn: AnyFn;
+    upsert: AnyFn;
+    delete: AnyFn;
+    deleteMany: AnyFn;
+    count: CountFn;
+};
+export {};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,19 @@
+/**
+ * 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`).
+ *
+ * @publicApi
+ */
+export type Prisma7ClientLike = {
+    $executeRaw: any;
+    $executeRawUnsafe: any;
+    $queryRaw: any;
+    $queryRawUnsafe: any;
+    $on: any;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,19 @@
+import { Prisma7ClientLike } from "./prisma7-client-like.type";
+/**
+ * Helper used to type a `VSRepository`'s `OrmTypes` generic when using
+ * `VSRepoPrisma7Adapter`, tying the repository's `getDbClient()`/`transaction()`
+ * return types to the real Prisma Client and transaction client types.
+ *
+ * @example
+ * ```typescript
+ * type MyOrmTypes = Prisma7OrmTypes<PrismaClient, Prisma.TransactionClient>;
+ *
+ * class UserRepository extends VSRepository<User, string, MyOrmTypes> { ... }
+ * ```
+ *
+ * @publicApi
+ */
+export type Prisma7OrmTypes<DB extends Prisma7ClientLike, TX extends Omit<Prisma7ClientLike, "$on">> = {
+    dbClient: DB;
+    dbTransaction: TX;
+};

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,26 @@
+/**
+ * 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 `mto` relations, whether the field accepts being set to
+ *   `null` (resolved as `disconnect`).
+ *
+ * @publicApi
+ */
+export interface Relation<T = any> {
+    mode: "otm" | "mtm" | "mto" | "oto";
+    restriction: "set" | "add";
+    pk: keyof T;
+    nullable?: boolean;
+}

package/dist/types/relation.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+import { VSLogLevel } from "vsrepo";
+export declare const adapterConfigSchema: v.ObjectSchema<{
+    readonly tableName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly pkName: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly relations: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<{
+        readonly mode: v.PicklistSchema<["otm", "mtm", "mto", "oto"], undefined>;
+        readonly restriction: v.PicklistSchema<["set", "add"], undefined>;
+        readonly pk: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+        readonly nullable: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>, undefined>;
+    readonly logLevel: v.OptionalSchema<v.EnumSchema<typeof VSLogLevel, undefined>, undefined>;
+}, undefined>;

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

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterConfigSchema = void 0;
+const v = __importStar(require("valibot"));
+const vsrepo_1 = require("vsrepo");
+const relation_schema_1 = require("./relation.schema");
+exports.adapterConfigSchema = v.object({
+    tableName: v.pipe(v.string(), v.minLength(1)),
+    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)),
+});

package/dist/validators/is-decimal.validator.d.ts

@@ -0,0 +1,5 @@
+export declare function isDecimal(value: any): value is {
+    toString(): string;
+    toNumber(): number;
+    toFixed(dp?: number): string;
+};

package/dist/validators/is-decimal.validator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDecimal = isDecimal;
+function isDecimal(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.toNumber === "function" &&
+        typeof value.toFixed === "function" &&
+        typeof value.toString === "function");
+}

package/dist/validators/is-plain-object.validator.d.ts

@@ -0,0 +1,2 @@
+import { PlainObject } from "../types/plain-object.type";
+export declare function isPlainObject(value: unknown): value is PlainObject;

package/dist/validators/is-plain-object.validator.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+const is_decimal_validator_1 = require("./is-decimal.validator");
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date) &&
+        !(0, is_decimal_validator_1.isDecimal)(value));
+}

package/dist/validators/relation.schema.d.ts

@@ -0,0 +1,8 @@
+import * as v from "valibot";
+/** Espelha o shape de `Relation`, incluindo os dois nomes de `nullable` da v1. */
+export declare const relationSchema: v.StrictObjectSchema<{
+    readonly mode: v.PicklistSchema<["otm", "mtm", "mto", "oto"], undefined>;
+    readonly restriction: v.PicklistSchema<["set", "add"], undefined>;
+    readonly pk: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
+    readonly nullable: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;

package/dist/validators/relation.schema.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationSchema = void 0;
+const v = __importStar(require("valibot"));
+/** Espelha o shape de `Relation`, incluindo os dois nomes de `nullable` da v1. */
+exports.relationSchema = v.strictObject({
+    mode: v.picklist(["otm", "mtm", "mto", "oto"]),
+    restriction: v.picklist(["set", "add"]),
+    pk: v.pipe(v.string(), v.minLength(1)),
+    nullable: v.optional(v.boolean()),
+});

package/dist/validators/validate-adapter-config.validator.d.ts

@@ -0,0 +1,8 @@
+import { VSRepoPrisma7AdapterConfig } from "../types/adapter-config.type";
+/**
+ * Valida a config recebida pelo construtor do `VSRepoPrisma7Adapter` (`tableName`,
+ * `pkName`, `relations` opcional e `logLevel` opcional) com valibot, lançando
+ * `VSRepoAdapterError` (code `INVALID_ADAPTER_CONFIG`) com uma mensagem apontando
+ * o campo inválido.
+ */
+export declare function validateAdapterConfig<T>(config: unknown): VSRepoPrisma7AdapterConfig<T>;

package/dist/validators/validate-adapter-config.validator.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAdapterConfig = validateAdapterConfig;
+const v = __importStar(require("valibot"));
+const vsrepo_1 = require("vsrepo");
+const adapter_config_schema_1 = require("./adapter-config.schema");
+/**
+ * Valida a config recebida pelo construtor do `VSRepoPrisma7Adapter` (`tableName`,
+ * `pkName`, `relations` opcional e `logLevel` opcional) com valibot, lançando
+ * `VSRepoAdapterError` (code `INVALID_ADAPTER_CONFIG`) com uma mensagem apontando
+ * o campo inválido.
+ */
+function validateAdapterConfig(config) {
+    const parsed = v.safeParse(adapter_config_schema_1.adapterConfigSchema, config);
+    if (!parsed.success) {
+        const issue = parsed.issues[0];
+        const path = issue?.path?.length ? issue.path.map(p => String(p.key)).join(".") : "config";
+        throw new vsrepo_1.VSRepoAdapterError(`Invalid constructor config (${path}): ${issue?.message ?? "validation failed"}`, vsrepo_1.AdapterErrorCode.INVALID_ADAPTER_CONFIG, null);
+    }
+    return parsed.output;
+}

package/package.json

@@ -0,0 +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
+  }
+}