vsrepo 1.1.4 → 1.1.6

package/README.md

@@ -1,7 +1,8 @@
 # VSRepository
 
 ![npm](https://img.shields.io/npm/v/vsrepo?style=flat-square)
-![license](https://img.shields.io/github/license/jaobrabo123/vsrepository?style=flat-square)
+![license](https://img.shields.io/github/license/jaobrabo123/vsrepository?style=flat-square&v=1)
+![NPM Downloads](https://img.shields.io/npm/d18m/vsrepo.svg)
 
 Biblioteca de repository pattern para projetos que usam **Prisma**, com suporte completo a **TypeScript** e **type inference** automático.
 
@@ -34,7 +35,7 @@ O VSRepository permite criar repositories fortemente tipados com:
   - [Configuração de métodos](#configuração-de-métodos)
 - [Relações no save](#relações-no-save)
 - [Transações](#transações)
-- [Extendendo um repository](#extendendo-um-repository)
+- [Estendendo um repository](#estendendo-um-repository)
 - [Tratamento de erros](#tratamento-de-erros)
 - [Tipos utilitários](#tipos-utilitários)
 - [API Reference](#api-reference)
@@ -333,6 +334,7 @@ Ao chamar `.build(prisma)` os métodos base abaixo são automaticamente disponib
 | `get(pk)`    | Busca um registro pela primary key         |
 | `getOrThrow(pk)` | Busca um registro pela primary key e lança erro se não encontrar |
 | `save(obj)`  | Cria ou atualiza (se o objeto passado tiver a `pk` faz `upsert`, se não faz `create`) |
+| `patch(pk, obj)` | Atualiza parcialmente um registro pela primary key (equivalente ao `update` com payload parcial) |
 | `remove(pk)` | Remove um registro pela primary key        |
 | `removeList(pks)`  | Remove vários registros pela lista de primary keys — retorna `{ count }`   |
 | `getAll()` | Retorna todos os registros (aceita `pagination` e `order` no `options`)  |
@@ -356,9 +358,13 @@ usuarioVSRepo.build(prisma, {
     remove: {
       active: true,
       defaultSelect: "minimal",
+      ignoreRequiredWhere: false, // Aplica o requiredWhere no remove (padrão = false)
     },
     save: {
-      ignoreRequiredWhere: true, // Não aplica requiredWhere no save
+      ignoreRequiredWhere: true,  // Não aplica requiredWhere no save
+    },
+    patch: {
+      defaultSelect: "minimal",
     },
     has: {
       active: false, // Desativa o 'has' (padrão = true)
@@ -720,7 +726,7 @@ methods: {
 
 ## Relações no save
 
-Configure relações para que o `save` as gerencie automaticamente. Para que as relações apareçam no autocomplete, o tipo genérico deve incluir as relações usando `GetPayload`:
+Configure relações para que o `save` as gerencie automaticamente. Essas mesmas relações também são usadas no `patch`. Para que as relações apareçam no autocomplete, o tipo genérico deve incluir as relações usando `GetPayload`:
 
 ```ts
 import type { Prisma } from "../../generated/prisma/client";
@@ -742,12 +748,39 @@ const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
     postagens: {
       pk: "id",
       mode: "otm",
-      restriction: "set",
+      restriction: "add",
     },
   },
 }).build(prisma);
 ```
 
+Exemplos de uso com relações:
+
+```ts
+await usuarioRepository.save({
+  nome: "Maria",
+  email: "maria@email.com",
+  senha: "password",
+  perfil: {
+    id: 1,
+    bio: "Bio da Maria",
+  },
+  postagens: [
+    { titulo: "Primeiro post", conteudo: "Olá!" },
+  ],
+});
+
+await usuarioRepository.patch(1, {
+  perfil: {
+    id: 1,
+    bio: "Bio atualizada",
+  },
+  postagens: [
+    { id: 10, titulo: "Post revisado", conteudo: "Conteúdo ajustado" },
+  ],
+});
+```
+
 > **Dica:** Se o tipo genérico não incluir `include: { relação: true }`, o VSRepository ainda funcionará, mas o autocomplete não sugerirá as relações no `save`. O tipo recomendado é sempre `GetPayload<{ include: { /* suas relações */ } }>` para melhor experiência de desenvolvimento.
 
 **Modos de relação:**
@@ -773,23 +806,24 @@ const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
 Todos os métodos aceitam `options.db` para participar de uma transação:
 
 ```ts
-await prisma.$transaction(async (tx) => {
+await usuarioRepository.prisma.$transaction(async (tx) => {
   const usuario = await usuarioRepository.save(
     { nome: "Maria", email: "maria@email.com", senha: "password" },
     { db: tx }
   );
 
-  await usuarioRepository.updateById(
-    usuario.id,
-    { ativo: true },
+  await usuarioLogsRepository.save(
+    { acao: "Cadastro de usuário", data: { usuarioCadastrado: usuario.id } },
     { db: tx }
   );
 });
 ```
 
+Observe que é possível diferentes repositories participarem da mesma transação.
+
 ---
 
-## Extendendo um repository
+## Estendendo um repository
 
 ```ts
 const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
@@ -1010,6 +1044,7 @@ vsRepo.build(prisma, {
     getOrThrow?:{ active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
     remove?:    { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
     save?:      { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
+    patch?:     { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
     getAll?:    { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
 
     // Métodos que NÃO aceitam `defaultSelect`

package/VSRepository/VSRepoUtils.js

@@ -1,6 +1,29 @@
 import z from "zod";
 import { VSRepoConfigError, VSRepoBuildError } from "./VSRepoError.js";
 
+export function mergeWheres(currentWhere, restrictWhere) {
+    const restrictWhereKeys = Object.keys(restrictWhere);
+    for (let i = 0; i < restrictWhereKeys.length; i++) {
+        const restrictWhereKey = restrictWhereKeys[i];
+        const restrictWhereField = restrictWhere[restrictWhereKey];
+
+        if (restrictWhereField === null || typeof restrictWhereField !== "object") {
+            currentWhere[restrictWhereKey] = restrictWhereField;
+        } else if (Array.isArray(restrictWhereField)) {
+            currentWhere[restrictWhereKey] = Array.isArray(currentWhere[restrictWhereKey]) ?
+                restrictWhereField.concat(currentWhere[restrictWhereKey]) :
+                restrictWhereField;
+        } else {
+            currentWhere[restrictWhereKey] = 
+                currentWhere[restrictWhereKey] != null &&
+                typeof currentWhere[restrictWhereKey] === "object" &&
+                !Array.isArray(currentWhere[restrictWhereKey]) ?
+                    Object.assign(currentWhere[restrictWhereKey], restrictWhereField) :
+                    restrictWhereField;
+        }
+    }
+}
+
 const stringSchema = z.string().trim().nonempty();
 const objectSchema = z.looseObject({});
 const booleanSchema = z.boolean();

package/VSRepository/VSRepository.d.ts

@@ -372,6 +372,8 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
         remove?: BaseMethodConfig<TSelectKeys>;
         /** Configuração do método `save`. */
         save?: BaseMethodConfig<TSelectKeys>;
+        /** Configuração do método `patch`. */
+        patch?: BaseMethodConfig<TSelectKeys>;
         /** Configuração do método `removeList` (exclusão em lote). Não aceita select. */
         removeList?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
         /** Configuração do método `getAll` (listagem total). */
@@ -383,7 +385,7 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
     };
 };
 
-type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'getOrThrow' | 'remove' | 'save' | 'getAll', TSelects = ExtractSelectModels<Config>> =
+type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'getOrThrow' | 'remove' | 'save' | 'getAll' | 'patch', TSelects = ExtractSelectModels<Config>> =
     C extends { baseMethods?: { [_ in Method]?: { defaultSelect?: infer D } } }
         ? D extends keyof TSelects 
             ? D 
@@ -483,6 +485,21 @@ type InjectedSave<
     ): Promise<RefineSaveResult<ResolveCurrentReturn<M, TSelects, S, TDefault>, O>>;
 };
 
+type InjectedPatch<
+    T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
+    TSelects = ExtractSelectModels<Config>,
+    TDefault = ExtractDefaultSelect<Config>,
+    TPk = ExtractPkName<T, Config>,
+    I = PrismaModelInputs<M>
+> = C extends { baseMethods: { patch: { active: false } } } ? {} : {
+    /** Atualiza parcialmente um registro existente através da sua chave primária (PK). */
+    patch<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'patch', TSelects>>(
+        pk: T[TPk extends keyof T ? TPk : never],
+        obj: I extends { updateInput: infer U } ? U : Record<string, any>,
+        options?: MethodOptions<S>
+    ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault>>;
+};
+
 type InjectedRemoveList<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
     TPk = ExtractPkName<T, Config>
@@ -532,6 +549,7 @@ type InjectedBaseMethods<T, M extends Prisma.ModelName, Config, C extends BuildC
     InjectedGetOrThrow<T, M, Config, C> & 
     InjectedRemove<T, M, Config, C> & 
     InjectedSave<T, M, Config, C> &
+    InjectedPatch<T, M, Config, C> &
     InjectedRemoveList<T, M, Config, C> &
     InjectedGetAll<T, M, Config, C> &
     InjectedTotal<T, M, Config, C> &

package/VSRepository/VSRepository.js

@@ -9,7 +9,7 @@ export * from "./VSRepoError.js";
 
 // * Importando classes de erro
 import { VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
-import { validateBuildConfig, validateConfig } from "./VSRepoUtils.js";
+import { mergeWheres, validateBuildConfig, validateConfig } from "./VSRepoUtils.js";
 
 // * Essa é a classe pincipal, é a partir dela que serão criados os objetos dos repositories
 export class VSRepository {
@@ -593,15 +593,11 @@ export class VSRepository {
                 const assignWhere = (where) => {
                     if(whereType==='extending' && buildInstance.requiredWhere) {
                         let safeRequiredWhere = structuredClone(buildInstance.requiredWhere);
-                        if(where.OR && safeRequiredWhere.OR) safeRequiredWhere.OR = safeRequiredWhere.OR.concat(where.OR)
-                        if(where.AND && safeRequiredWhere.AND) safeRequiredWhere.AND = safeRequiredWhere.AND.concat(where.AND)
-                        Object.assign(where, safeRequiredWhere);
+                        mergeWheres(where, safeRequiredWhere);
                     }
                     if(pushWhere !== undefined) {
                         let safePushWhere = structuredClone(pushWhere);
-                        if(where.OR && safePushWhere.OR) safePushWhere.OR = safePushWhere.OR.concat(where.OR)
-                        if(where.AND && safePushWhere.AND) safePushWhere.AND = safePushWhere.AND.concat(where.AND)
-                        Object.assign(where, safePushWhere);
+                        mergeWheres(where, safePushWhere);
                     }
                 }
 
@@ -1059,138 +1055,287 @@ export class VSRepository {
                     console.log(`[VSRepository] (runtime) Fatal error when trying to save on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
                     throw err;
                 }
-            }
-            if(config.baseMethods?.removeList?.active !== false) {
-                buildInstance.removeList = async (pks, options = {}) => {
-                    let db = options?.db ?? prisma;
-                    const prismaArgs = {};
-                    
-                    const where = { [buildInstance.pkName]: { in: pks } };
-                    if(buildInstance.requiredWhere && !config.baseMethods?.removeList?.ignoreRequiredWhere) {
-                        Object.assign(where, buildInstance.requiredWhere);
-                    }
-                    prismaArgs.where = where;
+            } 
+        }
+        if(config.baseMethods?.removeList?.active !== false) {
+            buildInstance.removeList = async (pks, options = {}) => {
+                let db = options?.db ?? prisma;
+                const prismaArgs = {};
+                
+                const where = { [buildInstance.pkName]: { in: pks } };
+                if(buildInstance.requiredWhere && !config.baseMethods?.removeList?.ignoreRequiredWhere) {
+                    Object.assign(where, buildInstance.requiredWhere);
+                }
+                prismaArgs.where = where;
 
-                    let start;
-                    if(showWorking){
-                        console.log(`[VSRepository] (runtime) Executing removeList on ${buildInstance.tableName}.`);
-                        console.log(`[VSRepository] (runtime) Built arguments to removeList on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
-                        start = performance.now();
-                    }
-                    try {
-                        const result = await db[buildInstance.tableName].deleteMany(prismaArgs);
-                        if(showWorking) {
-                            const end = performance.now();
-                            console.log(`[VSRepository] (runtime) Executed removeList on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
-                        }
-                        return result;
-                    } catch (err) {
-                        console.log(`[VSRepository] (runtime) Fatal error when trying to removeList on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
-                        throw err;
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing removeList on ${buildInstance.tableName}.`);
+                    console.log(`[VSRepository] (runtime) Built arguments to removeList on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
+                    start = performance.now();
+                }
+                try {
+                    const result = await db[buildInstance.tableName].deleteMany(prismaArgs);
+                    if(showWorking) {
+                        const end = performance.now();
+                        console.log(`[VSRepository] (runtime) Executed removeList on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
                     }
+                    return result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to removeList on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
                 }
             }
-            if(config.baseMethods?.getAll?.active !== false) {
-                buildInstance.getAll = async (options = {}) => {
-                    let db = options?.db ?? prisma;
-                    const prismaArgs = {};
+        }
+        if(config.baseMethods?.getAll?.active !== false) {
+            buildInstance.getAll = async (options = {}) => {
+                let db = options?.db ?? prisma;
+                const prismaArgs = {};
 
-                    if(buildInstance.requiredWhere && !config.baseMethods?.getAll?.ignoreRequiredWhere) {
-                        prismaArgs.where = { ...buildInstance.requiredWhere };
-                    }
+                if(buildInstance.requiredWhere && !config.baseMethods?.getAll?.ignoreRequiredWhere) {
+                    prismaArgs.where = { ...buildInstance.requiredWhere };
+                }
 
-                    let selectModelKey = options?.selectModel ?? config.baseMethods?.getAll?.defaultSelect ?? buildInstance.defaultSelectModel;
-                    if(selectModelKey){
-                        prismaArgs.select = buildInstance.selectModels[selectModelKey];
-                    }
+                let selectModelKey = options?.selectModel ?? config.baseMethods?.getAll?.defaultSelect ?? buildInstance.defaultSelectModel;
+                if(selectModelKey){
+                    prismaArgs.select = buildInstance.selectModels[selectModelKey];
+                }
 
-                    if(options.pagination) {
-                        prismaArgs.skip = options.pagination.skip;
-                        prismaArgs.take = options.pagination.take;
-                        prismaArgs.cursor = options.pagination.cursor;
-                    }
-                    if(options.order) {
-                        prismaArgs.orderBy = options.order;
-                    }
+                if(options.pagination) {
+                    prismaArgs.skip = options.pagination.skip;
+                    prismaArgs.take = options.pagination.take;
+                    prismaArgs.cursor = options.pagination.cursor;
+                }
+                if(options.order) {
+                    prismaArgs.orderBy = options.order;
+                }
 
-                    let start;
-                    if(showWorking){
-                        console.log(`[VSRepository] (runtime) Executing getAll on ${buildInstance.tableName}.`);
-                        console.log(`[VSRepository] (runtime) Built arguments to getAll on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
-                        start = performance.now();
-                    }
-                    try {
-                        const result = await db[buildInstance.tableName].findMany(prismaArgs);
-                        if(showWorking) {
-                            const end = performance.now();
-                            console.log(`[VSRepository] (runtime) Executed getAll on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
-                        }
-                        return result;
-                    } catch (err) {
-                        console.log(`[VSRepository] (runtime) Fatal error when trying to getAll on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
-                        throw err;
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing getAll on ${buildInstance.tableName}.`);
+                    console.log(`[VSRepository] (runtime) Built arguments to getAll on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
+                    start = performance.now();
+                }
+                try {
+                    const result = await db[buildInstance.tableName].findMany(prismaArgs);
+                    if(showWorking) {
+                        const end = performance.now();
+                        console.log(`[VSRepository] (runtime) Executed getAll on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
                     }
+                    return result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to getAll on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
                 }
             }
-            if(config.baseMethods?.total?.active !== false) {
-                buildInstance.total = async (options = {}) => {
-                    let db = options?.db ?? prisma;
-                    const prismaArgs = {};
+        }
+        if(config.baseMethods?.total?.active !== false) {
+            buildInstance.total = async (options = {}) => {
+                let db = options?.db ?? prisma;
+                const prismaArgs = {};
 
-                    if(buildInstance.requiredWhere && !config.baseMethods?.total?.ignoreRequiredWhere) {
-                        prismaArgs.where = { ...buildInstance.requiredWhere };
-                    }
+                if(buildInstance.requiredWhere && !config.baseMethods?.total?.ignoreRequiredWhere) {
+                    prismaArgs.where = { ...buildInstance.requiredWhere };
+                }
 
-                    let start;
-                    if(showWorking){
-                        console.log(`[VSRepository] (runtime) Executing total on ${buildInstance.tableName}.`);
-                        console.log(`[VSRepository] (runtime) Built arguments to total on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
-                        start = performance.now();
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing total on ${buildInstance.tableName}.`);
+                    console.log(`[VSRepository] (runtime) Built arguments to total on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
+                    start = performance.now();
+                }
+                try {
+                    const result = await db[buildInstance.tableName].count(prismaArgs);
+                    if(showWorking) {
+                        const end = performance.now();
+                        console.log(`[VSRepository] (runtime) Executed total on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
                     }
-                    try {
-                        const result = await db[buildInstance.tableName].count(prismaArgs);
-                        if(showWorking) {
-                            const end = performance.now();
-                            console.log(`[VSRepository] (runtime) Executed total on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
-                        }
-                        return result;
-                    } catch (err) {
-                        console.log(`[VSRepository] (runtime) Fatal error when trying to total on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
-                        throw err;
+                    return result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to total on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
+                }
+            }
+        }
+        if(config.baseMethods?.has?.active !== false) {
+            buildInstance.has = async (pk, options = {}) => {
+                let db = options?.db ?? prisma;
+                const prismaArgs = {};
+                
+                const where = { [buildInstance.pkName]: pk };
+                if(buildInstance.requiredWhere && !config.baseMethods?.has?.ignoreRequiredWhere) {
+                    Object.assign(where, buildInstance.requiredWhere);
+                }
+                prismaArgs.where = where;
+                prismaArgs.select = { [buildInstance.pkName]: true };
+
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing has on ${buildInstance.tableName}.`);
+                    console.log(`[VSRepository] (runtime) Built arguments to has on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
+                    start = performance.now();
+                }
+                try {
+                    const result = await db[buildInstance.tableName].findUnique(prismaArgs);
+                    if(showWorking) {
+                        const end = performance.now();
+                        console.log(`[VSRepository] (runtime) Executed has on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
                     }
+                    return !!result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to has on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
                 }
             }
-            if(config.baseMethods?.has?.active !== false) {
-                buildInstance.has = async (pk, options = {}) => {
-                    let db = options?.db ?? prisma;
-                    const prismaArgs = {};
-                    
+        }
+        if(config.baseMethods?.patch?.active !== false) {
+            buildInstance.patch = async (pk, obj, options = {}) => {
+                let db = options?.db ?? prisma;
+                const prismaArgs = {};
+
+                let selectModelKey = options?.selectModel ?? config.baseMethods?.patch?.defaultSelect ?? buildInstance.defaultSelectModel;
+                if(selectModelKey){
+                    prismaArgs.select = buildInstance.selectModels[selectModelKey];
+                }
+
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing patch on ${buildInstance.tableName}.`);
+                    start = performance.now();
+                }
+
+                try {
+                    let result;
+                    prismaArgs.data = {};
+
+                    const keys = Object.keys(obj);
+                    for (let i = 0; i < keys.length; i++) {
+                        const key = keys[i];
+                        const field = obj[key];
+
+                        if(field === undefined) continue;
+
+                        if(relationsKeys.includes(key)){
+                            const relation = buildInstance.relations[key];
+                            const relationMode = relation.mode;
+                            const relationRestriction = relation.restriction;
+                            const relationPk = relation.pk;
+
+                            if(relationMode === 'oto' || relationMode === 'mto') {
+                                if(field === null) {
+                                    if(relationMode === 'oto' && relationRestriction === 'set') {
+                                        prismaArgs.data[key] = { delete: true };
+                                    } else if(relationMode === 'mto' && relation.nullAble) {
+                                        prismaArgs.data[key] = { disconnect: true };
+                                    }
+                                } else if (field !== undefined) {
+                                    const relationFieldPk = field[relationPk];
+                                    if(relationFieldPk){
+                                        const connectOrCreate = {
+                                            where: { [relationPk]: relationFieldPk },
+                                            create: field
+                                        };
+
+                                        if(relationRestriction === 'add') {
+                                            prismaArgs.data[key] = { connectOrCreate };
+                                        } else {
+                                            const update = {...field};
+                                            delete update[relationPk];
+
+                                            prismaArgs.data[key] = {
+                                                upsert: {
+                                                    where: { [relationPk]: relationFieldPk },
+                                                    create: field,
+                                                    update: update
+                                                }
+                                            };
+                                        }
+                                    } else {
+                                        prismaArgs.data[key] = { create: field };
+                                    }
+                                }
+                            } else if(Array.isArray(field)) {
+                                const dataWithPk = field.filter(data=>data[relationPk]!==undefined);
+                                const dataWithoutPk = field.filter(data=>data[relationPk]===undefined);
+
+                                const connectOrCreate = dataWithPk.map(data=>({
+                                    where: { [relationPk]: data[relationPk] },
+                                    create: data
+                                }));
+
+                                if(relationRestriction === 'add') {
+                                    if(relationMode === 'mtm') {
+                                        prismaArgs.data[key] = {
+                                            create: dataWithoutPk,
+                                            connectOrCreate
+                                        }
+                                    } else {
+                                        prismaArgs.data[key] = {
+                                            create: dataWithoutPk,
+                                            upsert: dataWithPk.map(data=>{
+                                                const update = { ...data };
+                                                delete update[relationPk];
+                                                return {
+                                                    where: { [relationPk]: data[relationPk] },
+                                                    create: data, update
+                                                }
+                                            })
+                                        }
+                                    }
+                                } else {
+                                    if(relationMode === 'mtm') {
+                                        prismaArgs.data[key] = {
+                                            set: [],
+                                            create: dataWithoutPk,
+                                            connectOrCreate
+                                        }
+                                    } else {
+                                        prismaArgs.data[key] = {
+                                            deleteMany: { [relationPk]: { notIn: dataWithPk.map(data=>data[relationPk]) } },
+                                            create: dataWithoutPk,
+                                            upsert: dataWithPk.map(data=>{
+                                                const update = { ...data };
+                                                delete update[relationPk];
+                                                return {
+                                                    where: { [relationPk]: data[relationPk] },
+                                                    create: data, update
+                                                }
+                                            })
+                                        }
+                                    }
+                                }
+                            }
+                        } else {
+                            if (key !== buildInstance.pkName) {
+                                prismaArgs.data[key] = field;
+                            }
+                        }
+                    }
+
                     const where = { [buildInstance.pkName]: pk };
-                    if(buildInstance.requiredWhere && !config.baseMethods?.has?.ignoreRequiredWhere) {
+                    if(buildInstance.requiredWhere && !config.baseMethods?.patch?.ignoreRequiredWhere) {
                         Object.assign(where, buildInstance.requiredWhere);
                     }
                     prismaArgs.where = where;
-                    prismaArgs.select = { [buildInstance.pkName]: true };
 
-                    let start;
-                    if(showWorking){
-                        console.log(`[VSRepository] (runtime) Executing has on ${buildInstance.tableName}.`);
-                        console.log(`[VSRepository] (runtime) Built arguments to has on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
-                        start = performance.now();
+                    if(showWorking) {
+                        console.log(`[VSRepository] (runtime) Built arguments to patch on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
                     }
-                    try {
-                        const result = await db[buildInstance.tableName].findUnique(prismaArgs);
-                        if(showWorking) {
-                            const end = performance.now();
-                            console.log(`[VSRepository] (runtime) Executed has on ${buildInstance.tableName} (took: ${(end - start).toFixed(2)}ms).`);
-                        }
-                        return !!result;
-                    } catch (err) {
-                        console.log(`[VSRepository] (runtime) Fatal error when trying to has on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
-                        throw err;
+
+                    result = await db[buildInstance.tableName].update(prismaArgs);
+
+                    if(showWorking) {
+                        const end = performance.now();
+                        const duration = (end - start).toFixed(2);
+                        console.log(`[VSRepository] (runtime) Executed patch on ${buildInstance.tableName} (took: ${duration}ms).`);
                     }
+
+                    return result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to patch on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
                 }
-            }
+            } 
         }
 
         buildInstance.prisma = prisma;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {