vsrepo 1.1.5 → 1.1.7

package/README.md

@@ -1,7 +1,7 @@
 # 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.
@@ -35,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)
@@ -334,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`)  |
@@ -357,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)
@@ -721,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";
@@ -743,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:**
@@ -774,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">()({
@@ -1011,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/VSRepository.d.ts

@@ -197,7 +197,7 @@ export type MethodOptions<S> = {
     /**
      * Select model a ser aplicado na operação.
      *
-     * Use `false` para retornar o payload completo do Prisma, sem select.
+     * @note Use `false` para retornar o payload completo do Prisma, sem select.
      */
     selectModel?: S | false;
     /**
@@ -329,7 +329,7 @@ export type MethodConfig<M extends Prisma.ModelName, SelectModels = any> = {
     readonly map: boolean;
     /** Sobrescreve o `defaultSelectModel` apenas para este método. */
     readonly selectModel?: keyof SelectModels | false;
-    /** Controla se o método combina ou sobrescreve o `requiredWhere`. */
+    /** Controla se o método combina (`extending`) ou sobrescreve (`overwrite`) o `requiredWhere`. */
     readonly whereType?: 'overwrite' | 'extending';
     /** Redireciona a lógica para outro padrão de método válido. */
     readonly proxyTo?: ValidMethodPatterns;
@@ -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 
@@ -413,6 +415,12 @@ type InjectedGet<
     TDefault = ExtractDefaultSelect<Config>,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { get: { active: false } } } ? {} : {
+    /**
+     * Busca um registro pela chave primária (PK).
+     * @param pk Chave primária do registro.
+     * @param options Opções adicionais (por exemplo `selectModel` ou `db`).
+     * @returns O registro selecionado ou `null` se não encontrado.
+     */
     get<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'get', TSelects>>(
         pk: T[TPk extends keyof T ? TPk : never], options?: MethodOptions<S>
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault> | null>;
@@ -424,6 +432,12 @@ type InjectedGetOrThrow<
     TDefault = ExtractDefaultSelect<Config>,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { getOrThrow: { active: false } } } ? {} : {
+    /**
+     * Busca um registro pela chave primária (PK) e lança erro se não encontrado.
+     * @param pk Chave primária do registro.
+     * @param options Opções adicionais (por exemplo `selectModel` ou `db`).
+     * @returns O registro selecionado.
+     */
     getOrThrow<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'getOrThrow', TSelects>>(
         pk: T[TPk extends keyof T ? TPk : never], options?: MethodOptions<S>
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault>>;
@@ -435,6 +449,12 @@ type InjectedRemove<
     TDefault = ExtractDefaultSelect<Config>,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { remove: { active: false } } } ? {} : {
+    /**
+     * Remove um registro identificado pela chave primária (PK).
+     * @param pk Chave primária do registro a ser removido.
+     * @param options Opções adicionais (por exemplo `selectModel` ou `db`).
+     * @returns O registro removido.
+     */
     remove<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'remove', TSelects>>(
         pk: T[TPk extends keyof T ? TPk : never], options?: MethodOptions<S>
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault>>;
@@ -474,6 +494,12 @@ type InjectedSave<
     TDefault = ExtractDefaultSelect<Config>,
     TRelations = ExtractRelations<Config>
 > = C extends { baseMethods: { save: { active: false } } } ? {} : {
+    /**
+     * Insere ou atualiza (save/upsert) um registro, aceita os campos de relações definidas nas `relations`.
+     * @param obj Payload para criação/atualização.
+     * @param options Opções adicionais (por exemplo `selectModel` ou `db`).
+     * @returns O registro salvo com tipos refinados conforme a entrada.
+     */
     save<
         O extends UpsertWithRelations<T, M, TRelations>, 
         S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'save', TSelects>
@@ -483,11 +509,40 @@ 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 (patch) um registro existente pela chave primária (PK), aceita os campos de relações definidas nas `relations`.
+     * @param pk Chave primária do registro.
+     * @param obj Objeto parcial com os campos a atualizar.
+     * @param options Opções adicionais (por exemplo `selectModel` ou `db`).
+     * @returns O registro atualizado refinado conforme a entrada.
+     */
+    patch<
+        O extends (I extends { updateInput: infer U } ? U : Record<string, any>),
+        S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'patch', TSelects>
+    >(
+        pk: T[TPk extends keyof T ? TPk : never],
+        obj: O & (I extends { updateInput: infer U } ? U : Record<string, any>),
+        options?: MethodOptions<S>
+    ): Promise<RefineSaveResult<ResolveCurrentReturn<M, TSelects, S, TDefault>, O>>;
+};
+
 type InjectedRemoveList<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { removeList: { active: false } } } ? {} : {
-    /** Remove múltiplos registros de uma vez pelas suas chaves primárias. */
+    /**
+     * Remove múltiplos registros pelas suas chaves primárias.
+     * @param pks Lista de chaves primárias a remover.
+     * @param options Opções adicionais (por exemplo `db`).
+     * @returns Objeto com a contagem de registros removidos.
+     */
     removeList(
         pks: T[TPk extends keyof T ? TPk : never][], 
         options?: { db?: ClientOrTransaction }
@@ -500,7 +555,11 @@ type InjectedGetAll<
     TDefault = ExtractDefaultSelect<Config>,
     I = PrismaModelInputs<M>
 > = C extends { baseMethods: { getAll: { active: false } } } ? {} : {
-    /** Busca todos os registros, respeitando o `requiredWhere` se houver. */
+    /**
+     * Busca todos os registros (respeita `requiredWhere` quando aplicado).
+     * @param options Opções adicionais, incluindo paginação, ordenação e `db`/`selectModel`.
+     * @returns Lista dos registros encontrados`.
+     */
     getAll<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'getAll', TSelects>>(
         options?: MethodOptions<S> & { 
             pagination?: PaginationOptions<I extends { cursorInput: infer Curs } ? Curs : unknown>;
@@ -512,7 +571,11 @@ type InjectedGetAll<
 type InjectedTotal<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined
 > = C extends { baseMethods: { total: { active: false } } } ? {} : {
-    /** Retorna a quantidade total de registros, respeitando o `requiredWhere` se houver. */
+    /**
+     * Retorna a quantidade total de registros, respeitando `requiredWhere` quando aplicado.
+     * @param options Opções adicionais (por exemplo `db`).
+     * @returns Número total de registros.
+     */
     total(options?: { db?: ClientOrTransaction }): Promise<number>;
 };
 
@@ -520,7 +583,12 @@ type InjectedHas<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
     TPk = ExtractPkName<T, Config>
 > = C extends { baseMethods: { has: { active: false } } } ? {} : {
-    /** Verifica de forma otimizada se um registro existe pela chave primária. */
+    /**
+     * Verifica se um registro existe pela chave primária (PK).
+     * @param pk Chave primária a verificar.
+     * @param options Opções adicionais (por exemplo `db`).
+     * @returns `true` se existir, caso contrário `false`.
+     */
     has(
         pk: T[TPk extends keyof T ? TPk : never], 
         options?: { db?: ClientOrTransaction }
@@ -532,18 +600,63 @@ 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> &
     InjectedHas<T, M, Config, C>;
 
+/**
+ * Configuração de relação para One-to-Many ou Many-to-Many.
+ *
+ * @template TItem O tipo da entidade relacionada.
+ */
+export type ManyRelationConfig<TItem> = {
+    /** A chave primária (Primary Key) do entidade relacionada. */
+    pk: keyof TItem;
+    /** Tipo de relação: `otm` (One-to-Many) ou `mtm` (Many-to-Many). */
+    mode: 'otm' | 'mtm';
+    /** Comportamento de mutação: `set` (substitui tudo) ou `add` (adiciona aos existentes). */
+    restriction: 'set' | 'add';
+};
+
+/**
+ * Configuração de relação One-to-One.
+ *
+ * @template TItem O tipo da entidade relacionada.
+ */
+export type OneToOneRelationConfig<TItem> = {
+    /** A chave primária (Primary Key) do entidade relacionada. */
+    pk: keyof TItem;
+    /** Tipo de relação: `oto` (One-to-One). */
+    mode: 'oto';
+    /** Comportamento de mutação permitido para salvar. */
+    restriction: 'set' | 'add';
+};
+
+/**
+ * Configuração de relação Many-to-One.
+ *
+ * @template TItem O tipo da entidade relacionada.
+ */
+export type ManyToOneRelationConfig<TItem> = {
+    /** A chave primária (Primary Key) da entidade relacionada. */
+    pk: keyof TItem;
+    /** Tipo de relação: `mto` (Many-to-One). */
+    mode: 'mto';
+    /** Comportamento de mutação permitido para salvar. */
+    restriction: 'set' | 'add';
+    /** Habilita a possibilidade de desvincular a relação, tornando a chave estrangeira nula. */
+    nullAble?: boolean;
+};
+
 /**
  * Infere automaticamente a configuração de relação possível a partir de um campo.
  */
 export type ExtractRelationConfig<TField> = NonNullable<TField> extends infer NonNull
     ? NonNull extends Date | Buffer | Uint8Array ? never
-    : NonNull extends any[] ? (NonNull[number] extends object ? { pk: keyof NonNull[number]; mode: 'otm' | 'mtm'; restriction: 'set' | 'add' } : never)
-    : NonNull extends object ? ({ pk: keyof NonNull; mode: 'oto'; restriction: 'set' | 'add' } | { pk: keyof NonNull; mode: 'mto'; restriction: 'set' | 'add'; nullAble?: boolean })
+    : NonNull extends any[] ? (NonNull[number] extends object ? ManyRelationConfig<NonNull[number]> : never)
+    : NonNull extends object ? (OneToOneRelationConfig<NonNull> | ManyToOneRelationConfig<NonNull>)
     : never
     : never;
 
@@ -634,11 +747,11 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
     pkName: keyof T;
     /** Mapa de select models disponíveis. */
     selectModels?: SelectModels<M>;
-    /** Chave do select model padrão. */
+    /** Select model padrão. */
     defaultSelectModel?: Config extends { selectModels: infer SM } ? (keyof SM extends never ? string : Extract<keyof SM, string>) : string;
     /** Filtros globais aplicados às queries do repository. */
     requiredWhere?: WhereModel<M>;
-    /** Relações gerenciadas automaticamente pelo `save`. */
+    /** Relações gerenciadas automaticamente pelo `save` e pelo `patch`. */
     relations?: RepositoryRelations<T>;
     /** Mapa dos métodos dinâmicos e suas regras de validação. */
     methods?: {
@@ -651,16 +764,12 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
 };
 
 /**
- * Cria uma fábrica tipada para definir repositories fortemente tipados com Prisma.
- *
- * Use esta função para declarar `tableName`, `pkName`, `selectModels`,
- * `requiredWhere`, `relations` e `methods` do seu repository.
+ * Função para inicializar e configurar o `repository`.
+ * As configurações passadas nele são as que serão lidas ao executar o `.build()`.
  */
 export declare function setupVSRepo<T extends object, M extends Prisma.ModelName>(): <
     const SM extends Record<string, SelectModel<M>>,
     const Config extends RepoConfig<T, M, SM>
 >(
-  config: Config extends ValidateRepoConfig<T, M, Config> 
-    ? Config 
-    : ValidateRepoConfig<T, M, Config>
+  config: Config & ValidateRepoConfig<T, M, Config>
 ) => VSRepository<T, M, Config>;

package/VSRepository/VSRepository.js

@@ -1055,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.5",
+  "version": "1.1.7",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {