@vsrepo/prisma7-adapter 1.3.2 → 2.0.0-dev.1

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,9 @@
-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, DisconnectStrategy, RelationMode, ToManyStrategy, ToOneStrategy, } 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";
+export type { Prisma7GlobalConfig } from "./types/prisma7-global-config.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, allowOmitPkWhenNeeded?: 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];
@@ -45,44 +12,53 @@ function splitByPk(items, pk) {
     }
     return { withPk, withoutPk };
 }
+/** `Relation.onUpdate` of a to-one relation when the config doesn't set one. */
+const DEFAULT_TO_ONE_STRATEGY = "connect";
+/** `Relation.onUpdate` of a to-many relation when the config doesn't set one. */
+const DEFAULT_TO_MANY_STRATEGY = "add";
+/** `Relation.onDisconnect` of a to-one relation when the config doesn't set one. */
+const DEFAULT_DISCONNECT_STRATEGY = "disconnect";
+/**
+ * `update` half of a to-one relation whose related object has its `pk`,
+ * according to the relation's `onUpdate` ({@link ToOneStrategy}).
+ */
+function resolveExistingToOneUpdate(strategy, pk, where, field) {
+    switch (strategy) {
+        case "connect":
+            return { connect: where };
+        case "connectOrCreate":
+            return { connectOrCreate: { where, create: field } };
+        case "upsert":
+            return { upsert: { where, create: field, update: omitKey(field, pk) } };
+    }
+}
 function parseToOneRelation(field, relation) {
+    const updateStrategy = relation.onUpdate ?? DEFAULT_TO_ONE_STRATEGY;
     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);
-        }
-        if (relation.mode === "oto") {
-            if (relation.restriction === "set") {
-                return { update: { delete: true } };
-            }
-            return { update: { disconnect: true } };
-        }
-        // relation.mode === "mto"
-        return { update: { disconnect: true } };
+        const disconnectStrategy = relation.onDisconnect ?? DEFAULT_DISCONNECT_STRATEGY;
+        return disconnectStrategy === "delete" ? { update: { delete: true } } : { update: { disconnect: true } };
+    }
+    if (relation.fkThere !== undefined) {
+        field = omitKey(field, relation.fkThere);
     }
     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: updateStrategy === "upsert" ? { upsert: { create: field, update: field } } : { create: field },
         };
     }
-    const connectOrCreate = { where: { [relation.pk]: pkValue }, create: field };
+    const where = { [relation.pk]: pkValue };
     return {
-        create: { connectOrCreate },
-        update: relation.restriction === "add"
-            ? { connectOrCreate }
-            : {
-                upsert: {
-                    where: { [relation.pk]: pkValue },
-                    create: field,
-                    update: omitKey(field, relation.pk),
-                },
-            },
+        create: { connectOrCreate: { where, create: field } },
+        update: resolveExistingToOneUpdate(updateStrategy, relation.pk, where, field),
     };
 }
 function parseToManyRelation(field, relation) {
+    const updateStrategy = relation.onUpdate ?? DEFAULT_TO_MANY_STRATEGY;
+    if (relation.fkThere !== undefined) {
+        field = field.map(f => omitKey(f, relation.fkThere));
+    }
     const { withPk, withoutPk } = splitByPk(field, relation.pk);
     const connectOrCreate = withPk.map(item => ({
         where: { [relation.pk]: item[relation.pk] },
@@ -96,12 +72,10 @@ function parseToManyRelation(field, relation) {
             update: omitKey(item, relation.pk),
         }));
     const create = { create: withoutPk, connectOrCreate };
-    if (relation.restriction === "add") {
+    if (updateStrategy === "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,20 +91,29 @@ function parseToManyRelation(field, relation) {
             },
     };
 }
-function parsePrismaWriteData(obj, pkName, relations) {
-    const create = {};
-    const update = {};
+export function parsePrismaWriteData(obj, pkName, relations, omitPkInUpdate = false, allowOmitPkWhenNeeded = false) {
+    let create = {};
+    let update = {};
+    /** Relation fields that hold their FK in this entity, and those FK fields. */
+    const fkHereRelations = [];
+    const keysToOmit = [];
     for (const [key, field] of Object.entries(obj)) {
         if (field === undefined)
             continue;
         const relation = relations?.[key];
         if (!relation) {
             create[key] = field;
-            if (key !== pkName)
+            if (!omitPkInUpdate || key !== pkName)
                 update[key] = field;
             continue;
         }
+        if (relation === "ignore")
+            continue;
         if (relation.mode === "oto" || relation.mode === "mto") {
+            if (relation.fkHere !== undefined) {
+                fkHereRelations.push(key);
+                keysToOmit.push(relation.fkHere);
+            }
             const parsed = parseToOneRelation(field, relation);
             if (parsed.create !== undefined)
                 create[key] = parsed.create;
@@ -142,6 +125,24 @@ function parsePrismaWriteData(obj, pkName, relations) {
         create[key] = parsed.create;
         update[key] = parsed.update;
     }
+    if (fkHereRelations.length) {
+        if (obj[pkName] !== undefined) {
+            if (!allowOmitPkWhenNeeded) {
+                const fields = fkHereRelations.map(name => `'${name}'`).join(", ");
+                throw new VSRepoAdapterError(`Cannot send the primary key '${pkName}' together with the relation field(s) ${fields}: ` +
+                    `they hold their foreign key in this same entity, and Prisma rejects the primary key ` +
+                    `in a nested write of that kind ("Unknown argument"). ` +
+                    `Either remove '${pkName}' from the payload, or set 'allowOmitPk: true' (in the adapter ` +
+                    `config, or globally through 'setGlobalConfig') so the adapter drops it. Note that, with ` +
+                    `'allowOmitPk', a record that doesn't exist yet is created with a database-generated ` +
+                    `'${pkName}' instead of the one you sent.`, AdapterErrorCode.INVALID_DATA, null);
+            }
+            keysToOmit.push(pkName);
+        }
+        for (const key of keysToOmit) {
+            create = omitKey(create, key);
+            update = omitKey(update, key);
+        }
+    }
     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,14 +1,5 @@
-/**
- * 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";
+import { PlainObject } from "../types/plain-object.type.js";
 /**
  * Use o segundo generic para tipar o retorno com o `OrderByInput`
  * do Prisma correspondente ao modelo.

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) {
+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,32 +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";
+import { PlainObject } from "../types/plain-object.type.js";
+import { PrismaProvider } from "../types/prisma-provider.type.js";
 /**
- * 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>(where: VSRepoWhere<T> | undefined): PlainObject | undefined;
+export declare function parsePrismaWhere<T>(where: VSRepoWhere<T> | undefined, provider?: PrismaProvider): PlainObject | undefined;