@vsrepo/prisma7-adapter 1.3.1 → 2.0.0-dev

package/dist/constants/provider-capabilities.constant.d.ts

@@ -0,0 +1,17 @@
+import { PrismaProvider } from "../types/prisma-provider.type.js";
+/**
+ * Providers where Prisma accepts the `mode: "insensitive"` filter, which is
+ * what `ignoreCase` is translated to (see the README's provider support table).
+ */
+export declare const INSENSITIVE_MODE_PROVIDERS: ReadonlySet<PrismaProvider>;
+/**
+ * Providers that expose `createManyAndReturn` and `updateManyAndReturn`, which
+ * `createManyReturning` and `updateManyReturning` are built on.
+ */
+export declare const RETURNING_MANY_PROVIDERS: ReadonlySet<PrismaProvider>;
+/**
+ * Providers that support Prisma's `skipDuplicates` (`INSERT ... ON CONFLICT DO NOTHING`
+ * or equivalent), which is what `ignoreConflicts` is translated to on `createMany` and
+ * `createManyReturning`.
+ */
+export declare const SKIP_DUPLICATES_PROVIDERS: ReadonlySet<PrismaProvider>;

package/dist/constants/provider-capabilities.constant.js

@@ -0,0 +1,27 @@
+/**
+ * Providers where Prisma accepts the `mode: "insensitive"` filter, which is
+ * what `ignoreCase` is translated to (see the README's provider support table).
+ */
+export const INSENSITIVE_MODE_PROVIDERS = new Set([
+    "postgresql",
+    "cockroachdb",
+]);
+/**
+ * Providers that expose `createManyAndReturn` and `updateManyAndReturn`, which
+ * `createManyReturning` and `updateManyReturning` are built on.
+ */
+export const RETURNING_MANY_PROVIDERS = new Set([
+    "postgresql",
+    "cockroachdb",
+    "sqlite",
+]);
+/**
+ * Providers that support Prisma's `skipDuplicates` (`INSERT ... ON CONFLICT DO NOTHING`
+ * or equivalent), which is what `ignoreConflicts` is translated to on `createMany` and
+ * `createManyReturning`.
+ */
+export const SKIP_DUPLICATES_PROVIDERS = new Set([
+    "postgresql",
+    "mysql",
+    "cockroachdb",
+]);

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export { VSRepoPrisma7Adapter, VSRepoPrisma7Adapter as Prisma7Adapter } from "./prisma7.adapter";
-export type { Relation } from "./types/relation.type";
-export type { Prisma7OrmTypes } from "./types/prisma7-orm-types.type";
-export type { Prisma7ClientLike } from "./types/prisma7-client-like.type";
-export type { AdapterRelations } from "./types/adapter-relations.type";
-export type { VSRepoPrisma7AdapterConfig } from "./types/adapter-config.type";
-export type { PrismaClientModels } from "./types/prisma-client-models.type";
-export type { PrismaProvider } from "./types/prisma-provider.type";
+export { VSRepoPrisma7Adapter, VSRepoPrisma7Adapter as Prisma7Adapter } from "./prisma7.adapter.js";
+export type { Relation } from "./types/relation.type.js";
+export type { Prisma7OrmTypes } from "./types/prisma7-orm-types.type.js";
+export type { Prisma7ClientLike } from "./types/prisma7-client-like.type.js";
+export type { AdapterRelations } from "./types/adapter-relations.type.js";
+export type { Prisma7AdapterConfig } from "./types/adapter-config.type.js";
+export type { PrismaClientModels } from "./types/prisma-client-models.type.js";
+export type { PrismaProvider } from "./types/prisma-provider.type.js";

package/dist/index.js

@@ -1,7 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Prisma7Adapter = exports.VSRepoPrisma7Adapter = void 0;
-var prisma7_adapter_1 = require("./prisma7.adapter");
-Object.defineProperty(exports, "VSRepoPrisma7Adapter", { enumerable: true, get: function () { return prisma7_adapter_1.VSRepoPrisma7Adapter; } });
-Object.defineProperty(exports, "Prisma7Adapter", { enumerable: true, get: function () { return prisma7_adapter_1.VSRepoPrisma7Adapter; } });
-//# sourceMappingURL=index.js.map
+export { VSRepoPrisma7Adapter, VSRepoPrisma7Adapter as Prisma7Adapter } from "./prisma7.adapter.js";

package/dist/parsers/data.parser.d.ts

@@ -1,37 +1,7 @@
-/**
- * Parser que converte um `DeepPartial<T>` (formato "cru" vindo do vsrepo) nos
- * payloads `create`/`update` esperados pelo Prisma para escritas com relations,
- * replicando o comportamento da v1 (`resolveCreateUpdatePayloadsWithRelations`).
- *
- * Sem `relations` configurado no adapter, cada campo é repassado como está —
- * exceto `pkName`, que é omitido do `update` (não faz sentido reatribuir a PK
- * num update parcial).
- *
- * Com `relations`, cada campo de relação é resolvido de acordo com seu `mode`/
- * `restriction` (ver `Relation`):
- *  - to-one (`oto`/`mto`) sem PK no valor enviado -> `create` (e `upsert` no
- *    update, a não ser que `restriction: "add"`, que usa só `create`)
- *  - to-one com PK no valor enviado               -> `connectOrCreate` (e
- *    `upsert` no update, a não ser que `restriction: "add"`)
- *  - to-one enviado como `null` com `nullable`     -> `delete` (`oto` +
- *    `restriction: "set"`) ou `disconnect` (`oto` com `restriction: "add"` /
- *    `mto`; um `oto` não "desconecta" no `update`, a linha possuída é apagada)
- *  - to-one enviado como `null` sem `nullable`     -> lança `VSRepoAdapterError`
- *    (code `INVALID_DATA`)
- *  - to-many (`otm`/`mtm`) — itens são separados entre "com PK" e "sem PK":
- *    os sem PK viram `create`, os com PK viram `connectOrCreate` no create e
- *    `upsert` no update; com `restriction: "set"`, itens de `otm` que não
- *    vieram no array são removidos (`deleteMany`) e itens de `mtm` têm o
- *    vínculo resetado (`set: []`) antes de reconectar
- *
- * Essa mesma saída `{ create, update }` é reaproveitada em todos os métodos de
- * escrita do adapter: `create()` usa só `.create`, `update()`/`updateMany()`
- * usam só `.update`, e `save()`/`upsert()` usam os dois.
- */
-import { AdapterRelations } from "../types/adapter-relations.type";
-import { PlainObject } from "../types/plain-object.type";
+import { AdapterRelations } from "../types/adapter-relations.type.js";
+import { PlainObject } from "../types/plain-object.type.js";
 export interface PrismaWriteData {
     create: PlainObject;
     update: PlainObject;
 }
-export declare function parsePrismaWriteData<T>(obj: PlainObject, pkName: string, relations?: AdapterRelations<T>): PrismaWriteData;
+export declare function parsePrismaWriteData<T>(obj: PlainObject, pkName: string, relations?: AdapterRelations<T>, omitPkInUpdate?: boolean): PrismaWriteData;

package/dist/parsers/data.parser.js

@@ -1,37 +1,4 @@
-"use strict";
-/**
- * Parser que converte um `DeepPartial<T>` (formato "cru" vindo do vsrepo) nos
- * payloads `create`/`update` esperados pelo Prisma para escritas com relations,
- * replicando o comportamento da v1 (`resolveCreateUpdatePayloadsWithRelations`).
- *
- * Sem `relations` configurado no adapter, cada campo é repassado como está —
- * exceto `pkName`, que é omitido do `update` (não faz sentido reatribuir a PK
- * num update parcial).
- *
- * Com `relations`, cada campo de relação é resolvido de acordo com seu `mode`/
- * `restriction` (ver `Relation`):
- *  - to-one (`oto`/`mto`) sem PK no valor enviado -> `create` (e `upsert` no
- *    update, a não ser que `restriction: "add"`, que usa só `create`)
- *  - to-one com PK no valor enviado               -> `connectOrCreate` (e
- *    `upsert` no update, a não ser que `restriction: "add"`)
- *  - to-one enviado como `null` com `nullable`     -> `delete` (`oto` +
- *    `restriction: "set"`) ou `disconnect` (`oto` com `restriction: "add"` /
- *    `mto`; um `oto` não "desconecta" no `update`, a linha possuída é apagada)
- *  - to-one enviado como `null` sem `nullable`     -> lança `VSRepoAdapterError`
- *    (code `INVALID_DATA`)
- *  - to-many (`otm`/`mtm`) — itens são separados entre "com PK" e "sem PK":
- *    os sem PK viram `create`, os com PK viram `connectOrCreate` no create e
- *    `upsert` no update; com `restriction: "set"`, itens de `otm` que não
- *    vieram no array são removidos (`deleteMany`) e itens de `mtm` têm o
- *    vínculo resetado (`set: []`) antes de reconectar
- *
- * Essa mesma saída `{ create, update }` é reaproveitada em todos os métodos de
- * escrita do adapter: `create()` usa só `.create`, `update()`/`updateMany()`
- * usam só `.update`, e `save()`/`upsert()` usam os dois.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaWriteData = parsePrismaWriteData;
-const vsrepo_1 = require("vsrepo");
+import { AdapterErrorCode, VSRepoAdapterError } from "vsrepo";
 function omitKey(item, key) {
     const clone = { ...item };
     delete clone[key];
@@ -48,7 +15,7 @@ function splitByPk(items, pk) {
 function parseToOneRelation(field, relation) {
     if (field === null) {
         if (!relation.nullable) {
-            throw new vsrepo_1.VSRepoAdapterError(`You cannot provide null for a to-one relation when it is not nullable.`, vsrepo_1.AdapterErrorCode.INVALID_DATA, null);
+            throw new VSRepoAdapterError(`You cannot provide null for a to-one relation when it is not nullable.`, AdapterErrorCode.INVALID_DATA, null);
         }
         if (relation.mode === "oto") {
             if (relation.restriction === "set") {
@@ -60,12 +27,10 @@ function parseToOneRelation(field, relation) {
         return { update: { disconnect: true } };
     }
     const pkValue = field[relation.pk];
-    if (pkValue == undefined) {
+    if (pkValue === undefined) {
         return {
             create: { create: field },
-            update: relation.restriction === "add"
-                ? { create: field }
-                : { upsert: { create: field, update: field } },
+            update: relation.restriction === "add" ? { create: field } : { upsert: { create: field, update: field } },
         };
     }
     const connectOrCreate = { where: { [relation.pk]: pkValue }, create: field };
@@ -99,9 +64,7 @@ function parseToManyRelation(field, relation) {
     if (relation.restriction === "add") {
         return {
             create,
-            update: relation.mode === "mtm"
-                ? { create: withoutPk, connectOrCreate }
-                : { create: withoutPk, upsert },
+            update: relation.mode === "mtm" ? { create: withoutPk, connectOrCreate } : { create: withoutPk, upsert },
         };
     }
     return {
@@ -117,7 +80,7 @@ function parseToManyRelation(field, relation) {
             },
     };
 }
-function parsePrismaWriteData(obj, pkName, relations) {
+export function parsePrismaWriteData(obj, pkName, relations, omitPkInUpdate = false) {
     const create = {};
     const update = {};
     for (const [key, field] of Object.entries(obj)) {
@@ -126,7 +89,7 @@ function parsePrismaWriteData(obj, pkName, relations) {
         const relation = relations?.[key];
         if (!relation) {
             create[key] = field;
-            if (key !== pkName)
+            if (!omitPkInUpdate || key !== pkName)
                 update[key] = field;
             continue;
         }
@@ -144,4 +107,3 @@ function parsePrismaWriteData(obj, pkName, relations) {
     }
     return { create, update };
 }
-//# sourceMappingURL=data.parser.js.map

package/dist/parsers/include.parser.d.ts

@@ -1,3 +1,3 @@
 import { VSRepoRelations } from "vsrepo";
-import { PlainObject } from "../types/plain-object.type";
+import { PlainObject } from "../types/plain-object.type.js";
 export declare function parsePrismaInclude<T>(relations: VSRepoRelations<T>): PlainObject;

package/dist/parsers/include.parser.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaInclude = parsePrismaInclude;
-const is_plain_object_validator_1 = require("../validators/is-plain-object.validator");
-function parsePrismaInclude(relations) {
+import { isPlainObject } from "../validators/is-plain-object.validator.js";
+export function parsePrismaInclude(relations) {
     const include = {};
     for (const [key, value] of Object.entries(relations)) {
-        if ((0, is_plain_object_validator_1.isPlainObject)(value)) {
+        if (isPlainObject(value)) {
             include[key] = { include: parsePrismaInclude(value) };
         }
         else {
@@ -14,4 +11,3 @@ function parsePrismaInclude(relations) {
     }
     return include;
 }
-//# sourceMappingURL=include.parser.js.map

package/dist/parsers/order-by.parser.d.ts

@@ -1,15 +1,7 @@
-/**
- * Parser que converte um `Ordering<T>` (formato "amigável" do vsrepo) num
- * `orderBy` válido de qualquer modelo do Prisma.
- *
- * Suporta:
- *  - Direção em qualquer caixa:  { name: "ASC" } / { name: "asc" } -> { name: "asc" }
- *  - Ordenação encadeada:        [{ name: "asc" }, { createdAt: "desc" }]
- *  - Ordenação aninhada em relations to-one: { address: { city: "asc" } }
- */
 import { Ordering } from "vsrepo";
+import { PlainObject } from "../types/plain-object.type.js";
 /**
  * Use o segundo generic para tipar o retorno com o `OrderByInput`
  * do Prisma correspondente ao modelo.
  */
-export declare function parsePrismaOrderBy<T, O = any>(order: Ordering<T> | undefined | null): O | undefined;
+export declare function parsePrismaOrderBy<T>(order: Ordering<T> | undefined): PlainObject | PlainObject[] | undefined;

package/dist/parsers/order-by.parser.js

@@ -1,16 +1,4 @@
-"use strict";
-/**
- * Parser que converte um `Ordering<T>` (formato "amigável" do vsrepo) num
- * `orderBy` válido de qualquer modelo do Prisma.
- *
- * Suporta:
- *  - Direção em qualquer caixa:  { name: "ASC" } / { name: "asc" } -> { name: "asc" }
- *  - Ordenação encadeada:        [{ name: "asc" }, { createdAt: "desc" }]
- *  - Ordenação aninhada em relations to-one: { address: { city: "asc" } }
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaOrderBy = parsePrismaOrderBy;
-const is_plain_object_validator_1 = require("../validators/is-plain-object.validator");
+import { isPlainObject } from "../validators/is-plain-object.validator.js";
 function isSortDirection(value) {
     return value === "asc" || value === "desc" || value === "ASC" || value === "DESC";
 }
@@ -21,7 +9,7 @@ function parseOrderByField(order) {
             continue;
         result[key] = isSortDirection(value)
             ? value.toLowerCase()
-            : (0, is_plain_object_validator_1.isPlainObject)(value)
+            : isPlainObject(value)
                 ? parseOrderByField(value)
                 : value;
     }
@@ -31,9 +19,8 @@ function parseOrderByField(order) {
  * Use o segundo generic para tipar o retorno com o `OrderByInput`
  * do Prisma correspondente ao modelo.
  */
-function parsePrismaOrderBy(order) {
-    if (order === undefined || order === null)
-        return undefined;
-    return (Array.isArray(order) ? order.map(o => parseOrderByField(o)) : parseOrderByField(order));
+export function parsePrismaOrderBy(order) {
+    if (!order)
+        return;
+    return Array.isArray(order) ? order.map(o => parseOrderByField(o)) : parseOrderByField(order);
 }
-//# sourceMappingURL=order-by.parser.js.map

package/dist/parsers/select.parser.d.ts

@@ -1,3 +1,3 @@
 import { VSRepoSelect } from "vsrepo";
-import { PlainObject } from "../types/plain-object.type";
+import { PlainObject } from "../types/plain-object.type.js";
 export declare function parsePrismaSelect<T>(relations: VSRepoSelect<T>): PlainObject;

package/dist/parsers/select.parser.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaSelect = parsePrismaSelect;
-const is_plain_object_validator_1 = require("../validators/is-plain-object.validator");
-function parsePrismaSelect(relations) {
+import { isPlainObject } from "../validators/is-plain-object.validator.js";
+export function parsePrismaSelect(relations) {
     const select = {};
     for (const [key, value] of Object.entries(relations)) {
-        if ((0, is_plain_object_validator_1.isPlainObject)(value)) {
+        if (isPlainObject(value)) {
             select[key] = { select: parsePrismaSelect(value) };
         }
         else {
@@ -14,4 +11,3 @@ function parsePrismaSelect(relations) {
     }
     return select;
 }
-//# sourceMappingURL=select.parser.js.map

package/dist/parsers/where.parser.d.ts

@@ -1,31 +1,7 @@
-/**
- * Parser que converte um `VSRepoWhere<T>` (formato "amigável" da aplicação)
- * em um `where` válido de qualquer modelo do Prisma.
- *
- * Suporta:
- *  - Valor direto:               { name: "Ana" }
- *  - Operadores de campo:        { age: { gte: 18, lte: 65 } }
- *  - `between`:                  { age: { between: [18, 65] } } -> { gte: 18, lte: 65 }
- *  - `not` (valor ou operador):  { name: { not: "Ana" } }
- *                                { name: { not: { contains: "an" } } }
- *  - Strings case-insensitive:   { name: { contains: "ana", ignoreCase: true } }
- *                                -> { contains: "ana", mode: "insensitive" }
- *  - Relação lista (array):      { posts: { _some: { title: "x" } } } -> { posts: { some: {...} } }
- *  - Relação objeto (to-one):    { author: { _with: { id: 1 } } }    -> { author: { is: {...} } }
- *                                { author: { _without: { id: 1 } } } -> { author: { isNot: {...} } }
- *  - Lógicos no nível raiz:      { AND: [...] , OR: [...], NOT: {...} }
- *
- * Reflete a tipagem atual: `AND`/`OR`/`NOT` só existem em `VSRepoWhere<T>`
- * (nível raiz). Dentro de relações (`_some`/`_every`/`_none`/`_with`/
- * `_without`), o tipo usado é `VSRepoWherePlain<U>`, que NÃO tem esses
- * operadores lógicos — por isso a recursão para relações usa
- * `parsePlainWhere`, e não `parseWhere`.
- */
 import { VSRepoWhere } from "vsrepo";
+import { PlainObject } from "../types/plain-object.type.js";
+import { PrismaProvider } from "../types/prisma-provider.type.js";
 /**
- * API pública. Use o segundo generic para tipar o retorno com o `WhereInput`
- * do Prisma correspondente ao modelo, ex:
- *
- *   parseVSRepoWhere<User, Prisma.UserWhereInput>(where)
+ * Converts a `VSRepoWhere` into a Prisma `where`.
  */
-export declare function parsePrismaWhere<T, W = any>(where: VSRepoWhere<T> | undefined | null): W | undefined;
+export declare function parsePrismaWhere<T>(where: VSRepoWhere<T> | undefined, provider?: PrismaProvider): PlainObject | undefined;

package/dist/parsers/where.parser.js

@@ -1,73 +1,27 @@
-"use strict";
-/**
- * Parser que converte um `VSRepoWhere<T>` (formato "amigável" da aplicação)
- * em um `where` válido de qualquer modelo do Prisma.
- *
- * Suporta:
- *  - Valor direto:               { name: "Ana" }
- *  - Operadores de campo:        { age: { gte: 18, lte: 65 } }
- *  - `between`:                  { age: { between: [18, 65] } } -> { gte: 18, lte: 65 }
- *  - `not` (valor ou operador):  { name: { not: "Ana" } }
- *                                { name: { not: { contains: "an" } } }
- *  - Strings case-insensitive:   { name: { contains: "ana", ignoreCase: true } }
- *                                -> { contains: "ana", mode: "insensitive" }
- *  - Relação lista (array):      { posts: { _some: { title: "x" } } } -> { posts: { some: {...} } }
- *  - Relação objeto (to-one):    { author: { _with: { id: 1 } } }    -> { author: { is: {...} } }
- *                                { author: { _without: { id: 1 } } } -> { author: { isNot: {...} } }
- *  - Lógicos no nível raiz:      { AND: [...] , OR: [...], NOT: {...} }
- *
- * Reflete a tipagem atual: `AND`/`OR`/`NOT` só existem em `VSRepoWhere<T>`
- * (nível raiz). Dentro de relações (`_some`/`_every`/`_none`/`_with`/
- * `_without`), o tipo usado é `VSRepoWherePlain<U>`, que NÃO tem esses
- * operadores lógicos — por isso a recursão para relações usa
- * `parsePlainWhere`, e não `parseWhere`.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePrismaWhere = parsePrismaWhere;
-const is_decimal_validator_1 = require("../validators/is-decimal.validator");
-const is_plain_object_validator_1 = require("../validators/is-plain-object.validator");
-/** Chaves reconhecidas como operadores de campo do VSRepoFieldOperators */
-const FIELD_OPERATOR_KEYS = new Set([
-    "equals",
-    "not",
-    "in",
-    "notIn",
-    "gt",
-    "gte",
-    "lt",
-    "lte",
-    "between",
-    "contains",
-    "startsWith",
-    "endsWith",
-    "ignoreCase",
-]);
-/** Chaves de operadores de string que aceitam `mode: 'insensitive'` no Prisma */
-const CASE_SENSITIVE_STRING_KEYS = ["equals", "contains", "startsWith", "endsWith"];
+import { AdapterErrorCode, VSRepoAdapterError } from "vsrepo";
+import { INSENSITIVE_MODE_PROVIDERS } from "../constants/provider-capabilities.constant.js";
+import { isPlainObject } from "../validators/is-plain-object.validator.js";
 const LOGICAL_KEYS = new Set(["AND", "OR", "NOT"]);
-/** Verifica se um objeto "parece" um VSRepoFieldOperators (e não um filtro de relação/nested where) */
-function isFieldOperatorObject(value) {
-    return Object.keys(value).some(key => FIELD_OPERATOR_KEYS.has(key));
-}
-function isArrayRelationFilter(value) {
-    return "_some" in value || "_every" in value || "_none" in value;
-}
-function isObjectRelationFilter(value) {
-    return "_with" in value || "_without" in value;
-}
-/**
- * Converte um VSRepoFieldOperators<V> em um filtro de campo do Prisma.
- */
-function parseFieldOperators(value) {
+function parseFieldValue(value, provider) {
+    if (!isPlainObject(value)) {
+        return value;
+    }
     const result = {};
-    const ignoreCase = value.ignoreCase === true;
     for (const [key, val] of Object.entries(value)) {
         if (val === undefined)
             continue;
         switch (key) {
-            case "ignoreCase":
-                // tratado à parte, no final (vira `mode`)
+            case "ignoreCase": {
+                if (val !== true)
+                    break;
+                if (provider && !INSENSITIVE_MODE_PROVIDERS.has(provider)) {
+                    throw new VSRepoAdapterError(`The 'ignoreCase' option is not supported by the '${provider}' provider, since Prisma only ` +
+                        `supports case-insensitive filtering on PostgreSQL and CockroachDB. ` +
+                        `Remove 'ignoreCase' to filter using the database's own collation rules.`, AdapterErrorCode.NOT_SUPPORTED, null);
+                }
+                result.mode = "insensitive";
                 break;
+            }
             case "between": {
                 const [min, max] = val;
                 if (min !== undefined)
@@ -77,112 +31,56 @@ function parseFieldOperators(value) {
                 break;
             }
             case "not": {
-                result.not =
-                    (0, is_plain_object_validator_1.isPlainObject)(val) && isFieldOperatorObject(val)
-                        ? parseFieldOperators(val)
-                        : val;
+                result.not = isPlainObject(val) ? parseFieldValue(val, provider) : val;
+                break;
+            }
+            case "_some": {
+                result.some = parsePrismaWhere(value._some, provider);
+                break;
+            }
+            case "_every": {
+                result.every = parsePrismaWhere(value._every, provider);
                 break;
             }
+            case "_none": {
+                result.none = parsePrismaWhere(value._none, provider);
+                break;
+            }
+            case "_with": {
+                result.is = parsePrismaWhere(value._with, provider);
+                break;
+            }
+            case "_without": {
+                result.isNot = parsePrismaWhere(value._without, provider);
+                break;
+            }
+            case "like": {
+                throw new VSRepoAdapterError(`The 'like' operator is not supported by the Prisma adapter, since Prisma has no equivalent. ` +
+                    `Use 'contains', 'startsWith' or 'endsWith' instead.`, AdapterErrorCode.NOT_SUPPORTED, null);
+            }
             default:
                 result[key] = val;
         }
     }
-    if (ignoreCase) {
-        const hasCaseSensitiveKey = CASE_SENSITIVE_STRING_KEYS.some(k => k in result);
-        if (hasCaseSensitiveKey) {
-            result.mode = "insensitive";
-        }
-    }
     return result;
 }
-/** Converte { _some, _every, _none } em { some, every, none } (VSRepoWherePlain — sem AND/OR/NOT) */
-function parseArrayRelationFilter(value) {
-    const result = {};
-    if (value._some !== undefined) {
-        result.some = parsePlainWhere(value._some);
-    }
-    if (value._every !== undefined) {
-        result.every = parsePlainWhere(value._every);
-    }
-    if (value._none !== undefined) {
-        result.none = parsePlainWhere(value._none);
-    }
-    return result;
-}
-/** Converte { _with, _without } em { is, isNot } (VSRepoWherePlain — sem AND/OR/NOT) */
-function parseObjectRelationFilter(value) {
-    if (value._with !== undefined) {
-        return { is: parsePlainWhere(value._with) };
-    }
-    if (value._without !== undefined) {
-        return { isNot: parsePlainWhere(value._without) };
-    }
-    return {};
-}
-/** Decide como interpretar o valor de um campo do where */
-function parseFieldValue(value) {
-    // valores primitivos (string, number, boolean, Date, null, bigint, Decimal) passam direto
-    if (value === null || typeof value !== "object" || value instanceof Date || (0, is_decimal_validator_1.isDecimal)(value)) {
-        return value;
-    }
-    // arrays (usados em `in`/`notIn` no nível mais alto, ex: { status: ["A","B"] })
-    if (Array.isArray(value)) {
-        return value;
-    }
-    const obj = value;
-    if (isArrayRelationFilter(obj)) {
-        return parseArrayRelationFilter(obj);
-    }
-    if (isObjectRelationFilter(obj)) {
-        return parseObjectRelationFilter(obj);
-    }
-    if (isFieldOperatorObject(obj)) {
-        return parseFieldOperators(obj);
-    }
-    // fallback: nested where (não deveria ocorrer para campos primitivos bem tipados)
-    return parsePlainWhere(obj);
-}
 /**
- * Converte um `VSRepoWherePlain<T>` (sem AND/OR/NOT) — usado para o corpo de
- * relações (`_some`/`_every`/`_none`/`_with`/`_without`).
+ * Converts a `VSRepoWhere` into a Prisma `where`.
  */
-function parsePlainWhere(where) {
-    if (where === undefined || where === null)
-        return undefined;
-    const result = {};
-    for (const [key, value] of Object.entries(where)) {
-        if (value === undefined)
-            continue;
-        result[key] = parseFieldValue(value);
-    }
-    return result;
-}
-/**
- * Converte um `VSRepoWhere<T>` completo (nível raiz, com AND/OR/NOT) em um
- * where do Prisma.
- */
-function parseWhere(where) {
-    if (where === undefined || where === null)
+export function parsePrismaWhere(where, provider) {
+    if (where === undefined)
         return undefined;
     const result = {};
     for (const [key, value] of Object.entries(where)) {
         if (value === undefined)
             continue;
         if (LOGICAL_KEYS.has(key)) {
-            result[key] = Array.isArray(value) ? value.map(v => parseWhere(v)) : parseWhere(value);
+            result[key] = Array.isArray(value)
+                ? value.map(v => parsePrismaWhere(v, provider))
+                : parsePrismaWhere(value, provider);
             continue;
         }
-        result[key] = parseFieldValue(value);
+        result[key] = parseFieldValue(value, provider);
     }
     return result;
 }
-/**
- * API pública. Use o segundo generic para tipar o retorno com o `WhereInput`
- * do Prisma correspondente ao modelo, ex:
- *
- *   parseVSRepoWhere<User, Prisma.UserWhereInput>(where)
- */
-function parsePrismaWhere(where) {
-    return parseWhere(where);
-}
-//# sourceMappingURL=where.parser.js.map