@vsrepo/prisma7-adapter 1.0.0

package/dist/parsers/data.parser.js

@@ -0,0 +1,134 @@
+"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`                    -> `delete` (`oto` +
+ *    `restriction: "set"`) ou `disconnect` (`mto` + `nullable`)
+ *  - 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;
+function omitKey(item, key) {
+    const clone = { ...item };
+    delete clone[key];
+    return clone;
+}
+function splitByPk(items, pk) {
+    const withPk = [];
+    const withoutPk = [];
+    for (const item of items) {
+        (item[pk] !== undefined ? withPk : withoutPk).push(item);
+    }
+    return { withPk, withoutPk };
+}
+function parseToOneRelation(field, relation) {
+    if (field === null) {
+        if (relation.mode === "oto" && relation.restriction === "set") {
+            return { update: { delete: true } };
+        }
+        if (relation.mode === "mto" && relation.nullable) {
+            return { update: { disconnect: true } };
+        }
+        return {};
+    }
+    const pkValue = field[relation.pk];
+    if (pkValue == null) {
+        return {
+            create: { create: field },
+            update: relation.restriction === "add"
+                ? { create: field }
+                : { upsert: { create: field, update: field } },
+        };
+    }
+    const connectOrCreate = { where: { [relation.pk]: pkValue }, create: field };
+    return {
+        create: { connectOrCreate },
+        update: relation.restriction === "add"
+            ? { connectOrCreate }
+            : {
+                upsert: {
+                    where: { [relation.pk]: pkValue },
+                    create: field,
+                    update: omitKey(field, relation.pk),
+                },
+            },
+    };
+}
+function parseToManyRelation(field, relation) {
+    const { withPk, withoutPk } = splitByPk(field, relation.pk);
+    const connectOrCreate = withPk.map(item => ({
+        where: { [relation.pk]: item[relation.pk] },
+        create: item,
+    }));
+    const upsert = withPk.map(item => ({
+        where: { [relation.pk]: item[relation.pk] },
+        create: item,
+        update: omitKey(item, relation.pk),
+    }));
+    const create = { create: withoutPk, connectOrCreate };
+    if (relation.restriction === "add") {
+        return {
+            create,
+            update: relation.mode === "mtm"
+                ? { create: withoutPk, connectOrCreate }
+                : { create: withoutPk, upsert },
+        };
+    }
+    return {
+        create,
+        update: relation.mode === "mtm"
+            ? { set: [], create: withoutPk, connectOrCreate }
+            : {
+                deleteMany: { [relation.pk]: { notIn: withPk.map(item => item[relation.pk]) } },
+                create: withoutPk,
+                upsert,
+            },
+    };
+}
+function parsePrismaWriteData(obj, pkName, relations) {
+    const create = {};
+    const update = {};
+    for (const [key, field] of Object.entries(obj)) {
+        if (field === undefined)
+            continue;
+        const relation = relations?.[key];
+        if (!relation) {
+            create[key] = field;
+            if (key !== pkName)
+                update[key] = field;
+            continue;
+        }
+        if (relation.mode === "oto" || relation.mode === "mto") {
+            const parsed = parseToOneRelation(field, relation);
+            if (parsed.create !== undefined)
+                create[key] = parsed.create;
+            if (parsed.update !== undefined)
+                update[key] = parsed.update;
+            continue;
+        }
+        const parsed = parseToManyRelation(field, relation);
+        create[key] = parsed.create;
+        update[key] = parsed.update;
+    }
+    return { create, update };
+}

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

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

package/dist/parsers/include.parser.js

@@ -0,0 +1,16 @@
+"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) {
+    const include = {};
+    for (const [key, value] of Object.entries(relations)) {
+        if ((0, is_plain_object_validator_1.isPlainObject)(value)) {
+            include[key] = { include: parsePrismaInclude(value) };
+        }
+        else {
+            include[key] = value;
+        }
+    }
+    return include;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * 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";
+/**
+ * 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;

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

@@ -0,0 +1,38 @@
+"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");
+function isSortDirection(value) {
+    return value === "asc" || value === "desc" || value === "ASC" || value === "DESC";
+}
+function parseOrderByField(order) {
+    const result = {};
+    for (const [key, value] of Object.entries(order)) {
+        if (value === undefined)
+            continue;
+        result[key] = isSortDirection(value)
+            ? value.toLowerCase()
+            : (0, is_plain_object_validator_1.isPlainObject)(value)
+                ? parseOrderByField(value)
+                : value;
+    }
+    return result;
+}
+/**
+ * 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));
+}

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

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

package/dist/parsers/select.parser.js

@@ -0,0 +1,16 @@
+"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) {
+    const select = {};
+    for (const [key, value] of Object.entries(relations)) {
+        if ((0, is_plain_object_validator_1.isPlainObject)(value)) {
+            select[key] = { select: parsePrismaSelect(value) };
+        }
+        else {
+            select[key] = value;
+        }
+    }
+    return select;
+}

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

@@ -0,0 +1,31 @@
+/**
+ * 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";
+/**
+ * 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)
+ */
+export declare function parsePrismaWhere<T, W = any>(where: VSRepoWhere<T> | undefined | null): W | undefined;

package/dist/parsers/where.parser.js

@@ -0,0 +1,187 @@
+"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"];
+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) {
+    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`)
+                break;
+            case "between": {
+                const [min, max] = val;
+                if (min !== undefined)
+                    result.gte = min;
+                if (max !== undefined)
+                    result.lte = max;
+                break;
+            }
+            case "not": {
+                result.not =
+                    (0, is_plain_object_validator_1.isPlainObject)(val) && isFieldOperatorObject(val)
+                        ? parseFieldOperators(val)
+                        : val;
+                break;
+            }
+            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`).
+ */
+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)
+        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);
+            continue;
+        }
+        result[key] = parseFieldValue(value);
+    }
+    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);
+}

package/dist/prisma7.adapter.d.ts

@@ -0,0 +1,125 @@
+import { AdapterMethodOptions, AdapterQueryOptions, CountResult, DeepPartial, VSRepoAdapter, VSRepoWhere } from "vsrepo";
+import { VSRepoPrisma7AdapterConfig } from "./types/adapter-config.type";
+/**
+ * `VSRepoAdapter` implementation for Prisma 7. Translates every method of the
+ * adapter contract into Prisma Client calls, resolving `VSRepoWhere`/`Ordering`/
+ * `select`/`include` through the parsers, and — when a
+ * `relations` config is provided — resolving relation fields on `create`/
+ * `update`/`upsert`/`merge` the same way the v1 of VSRepository did (see
+ * `Relation`).
+ *
+ * Every method always rejects with a `VSRepoAdapterError` — any error raised
+ * by Prisma (or by the adapter itself) is translated through `mapPrismaError`
+ * before leaving the adapter, so callers never have to deal with a raw
+ * Prisma/driver error shape.
+ *
+ * @template T Entity type this adapter operates on.
+ *
+ * @publicApi
+ */
+export declare class VSRepoPrisma7Adapter<T> extends VSRepoAdapter<T> {
+    private readonly prisma;
+    private readonly tableName;
+    private readonly pkName;
+    private readonly relations?;
+    private readonly logger;
+    constructor(prisma: any, config: VSRepoPrisma7AdapterConfig<T>);
+    private getPrismaRepository;
+    /** Resolves the "read" part of a Prisma arg: select/include/orderBy/pagination. */
+    private resolveReadArg;
+    /**
+     * Strips relation fields from a payload — used by `createMany`/`updateMany`/
+     * `updateManyReturning`, since those Prisma operations don't support nested
+     * writes (scalar fields only). Throws a `VSRepoAdapterError` (code
+     * `NOT_SUPPORTED`) instead of silently ignoring the field, when a configured
+     * relation field is present in the payload.
+     */
+    private stripRelationFields;
+    /**
+     * Tells apart a root Prisma Client from an active transaction client: only
+     * the root client exposes `$on` (used for event listeners), Prisma's
+     * interactive transaction client doesn't (see `Prisma7ClientLike`).
+     */
+    private isRootClient;
+    /**
+     * Runs `fn` against a transaction, reusing `db` when it's already a
+     * transaction client (see `isRootClient`) instead of nesting a new one —
+     * this is what lets `saveMany`/`deleteManyReturning` participate in a
+     * transaction already started via `VSRepository.transaction()`.
+     * When `db` isn't provided, or is a root client, a new transaction is
+     * started on it (or on `this.prisma` when `db` isn't provided at all).
+     */
+    private runTransactional;
+    /** Returns the underlying ORM client instance used outside of transactions. */
+    getDbClient(): any;
+    /** Runs `fn` inside a native transaction of the underlying ORM/database. */
+    runInTransaction<R>(fn: (tx: any) => Promise<R>, options?: {
+        isolationLevel?: any;
+    }): Promise<R>;
+    /** Fetches a single record matching `where`. */
+    findOne(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T | null>;
+    /** Fetches a single record matching `where`, throwing if none is found. */
+    findOneOrThrow(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /** Fetches all records matching `where`. */
+    findMany(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T> & {
+        distinct?: (keyof T)[];
+    }): Promise<T[]>;
+    /** Creates or updates (upsert) a single record. */
+    save(obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Creates or updates (upsert) multiple records. Prisma has no native bulk
+     * upsert, so each record is saved individually inside a transaction —
+     * reusing `options.db` when it's already a transaction client (see
+     * `runTransactional`).
+     */
+    saveMany(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T>): Promise<T[]>;
+    /** Deletes a single record matching `where`. */
+    delete(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /** Deletes every record matching `where`, returning the count of affected rows. */
+    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.
+     */
+    deleteManyReturning(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
+    /** Updates a single record matching `where`. */
+    update(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /** Updates every record matching `where`, returning the count of affected rows. */
+    updateMany(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<CountResult>;
+    /** Updates every record matching `where`, returning the updated records. */
+    updateManyReturning(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T[]>;
+    /** Returns the number of records matching `where`. */
+    count(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<number>;
+    /** Checks whether at least one record matching `where` exists. */
+    exists(where: VSRepoWhere<T>, options?: AdapterMethodOptions<T>): Promise<boolean>;
+    /** Executes a raw query/statement against the underlying database, used by `@QueryMethod`. */
+    query<R = any>(query: string, options?: AdapterQueryOptions): Promise<R>;
+    /** Creates a single record. */
+    create(obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+    /**
+     * Creates multiple records in a single operation. Relation fields are
+     * stripped (see `stripRelationFields`), since Prisma's `createMany` doesn't
+     * support nested writes.
+     */
+    createMany(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T> & {
+        ignoreConflicts?: boolean;
+    }): Promise<CountResult>;
+    /**
+     * Creates multiple records in a single operation, returning the created records.
+     */
+    createManyReturning(objs: DeepPartial<T>[], options?: AdapterMethodOptions<T> & {
+        ignoreConflicts?: boolean;
+    }): Promise<T[]>;
+    /**
+     * Fetches the record matching `where` and returns it deep-merged with
+     * `obj`, WITHOUT persisting anything — same behavior the v1 of
+     * VSRepository had (see `mergeEntities`). It's on the caller to decide
+     * what to do with the result (e.g. call `save` next).
+     */
+    merge<K>(where: VSRepoWhere<T>, obj: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<K & T>;
+    /** Creates a record if none matches `where`, otherwise updates it. */
+    upsert(where: VSRepoWhere<T>, create: DeepPartial<T>, update: DeepPartial<T>, options?: AdapterMethodOptions<T>): Promise<T>;
+}