vsrepo 1.2.0 → 1.2.2

package/README.md

@@ -33,6 +33,7 @@ O VSRepository permite criar repositories fortemente tipados com:
   - [Filtros de relação](#filtros-de-relação)
   - [Sufixos de paginação e ordenação](#sufixos-de-paginação-e-ordenação)
   - [Configuração de métodos](#configuração-de-métodos)
+  - [Aggregate e GroupBy](#aggregate-e-groupby)
 - [Relações no save](#relações-no-save)
 - [Transações](#transações)
 - [Estendendo um repository](#estendendo-um-repository)
@@ -460,6 +461,7 @@ O prefixo do nome do método determina qual operação Prisma será chamada e qu
 | `findListWhere`           | `findMany`               | `T[]`                  | Recebe um objeto `where` explícito como argumento        |
 | `existsBy`                | `findFirst`              | `boolean`              | Retorna `true` se encontrar, `false` caso contrário      |
 | `countBy`                 | `count`                  | `number`               | Aceita campos como filtro                                |
+| `countWhere`              | `count`                  | `number`               | Recebe um objeto `where` explícito como argumento        |
 | `count`                   | `count`                  | `number`               | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`           |
 | `create`                  | `create`                 | `T`                    | Recebe `data` como argumento                             |
 | `createMany`              | `createMany`             | `{ count: number }`    | Recebe `data` como argumento; suporta `SkipDuplicates`                            |
@@ -470,6 +472,8 @@ O prefixo do nome do método determina qual operação Prisma será chamada e qu
 | `upsertBy`                | `upsert`                 | `T`                    | Recebe `update` e `create` como argumentos               |
 | `deleteBy`                | `delete`                 | `T`                    |                                                          |
 | `deleteManyBy`            | `deleteMany`             | `{ count: number }`    |                                                          |
+| `aggregate`               | `aggregate`              | `Dinâmico`               | Nome deve ser exato; recebe args nativos do Prisma; ignora `selectModels`, `pushWhere` e `requiredWhere` |
+| `groupBy`               | `groupBy`              | `Dinâmico[]`               | Nome deve ser exato; recebe args nativos do Prisma; ignora `selectModels`, `pushWhere` e `requiredWhere` |
 
 ---
 
@@ -724,6 +728,81 @@ methods: {
 
 ---
 
+### Aggregate e GroupBy
+
+Para utilizar operações de agrupamento e agregação do Prisma (`aggregate` e `groupBy`), você deve expô-las explicitamente na configuração dos métodos dinâmicos (`methods`):
+
+```ts
+const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
+  tableName: "usuario",
+  pkName: "id",
+  methods: {
+    aggregate: { map: true },
+    groupBy: { map: true },
+  },
+}).build(prisma);
+```
+
+> [!NOTE]
+> Estes métodos devem ter exatamente esses nomes (`aggregate` e `groupBy`).
+> Ao contrário dos outros métodos dinâmicos, eles recebem argumentos nativos do Prisma e **ignoram** as configurações de `selectModels`, `pushWhere` e `requiredWhere`.
+
+#### Exemplo de uso do `aggregate`
+
+O método `aggregate` permite calcular valores agregados (como média, soma, mínimo, máximo, contagem) sobre os registros:
+
+```ts
+const resultado = await usuarioRepository.aggregate({
+  _count: {
+    _all: true,
+  },
+  _avg: {
+    idade: true,
+  },
+  _sum: {
+    saldo: true,
+  },
+  where: {
+    ativo: true,
+  },
+});
+
+console.log(resultado._count._all); // Total de usuários ativos
+console.log(resultado._avg.idade);   // Média de idade dos usuários ativos
+console.log(resultado._sum.saldo);   // Soma dos saldos dos usuários ativos
+```
+
+#### Exemplo de uso do `groupBy`
+
+O método `groupBy` permite agrupar registros por um ou mais campos para realizar operações de agregação em cada grupo:
+
+```ts
+const grupos = await usuarioRepository.groupBy({
+  by: ["status"],
+  _count: {
+    status: true,
+  },
+  _avg: {
+    idade: true,
+  },
+  having: {
+    idade: {
+      _avg: {
+        gt: 18,
+      },
+    },
+  },
+});
+
+for (const grupo of grupos) {
+  console.log(`Status: ${grupo.status}`);
+  console.log(`Quantidade: ${grupo._count.status}`);
+  console.log(`Média de Idade: ${grupo._avg.idade}`);
+}
+```
+
+---
+
 ## Relações no save
 
 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`:
@@ -939,8 +1018,9 @@ import type { MethodOptions, MethodOptionsModel } from "../../generated/vsrepo";
 // S = chave do select model ou false
 type Opts = MethodOptions<"public" | "minimal">;
 
-// MethodOptionsModel<T> — versão derivada do tipo do repository
-type OptsModel = MethodOptionsModel<typeof usuarioSelectModels>;
+// MethodOptionsModel<TRepo> — derivado diretamente de uma instância VSRepository configurada
+const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()(config);
+type OptsModel = MethodOptionsModel<typeof usuarioVSRepo>;
 ```
 
 ### Tipos de configuração
@@ -952,7 +1032,6 @@ import type {
   BuildConfig,
   RepositoryRelations,
   ExtractRelationConfig,
-  UpsertWithRelations,
 } from "../../generated/vsrepo";
 
 // Configuração de um método dinâmico
@@ -969,18 +1048,12 @@ type UsuarioRelations = RepositoryRelations<Usuario>;
 
 // Configuração de relação inferida a partir de um campo
 type PerfilRelationConfig = ExtractRelationConfig<Usuario["perfil"]>;
-
-// Payload do save com relações
-type UsuarioComRelacoes = UpsertWithRelations<Usuario, "usuario", typeof relations>;
 ```
 
 ### Tipo do repository construído
 
 ```ts
-import type { BuiltRepository, RepositoryOf } from "../../generated/vsrepo";
-
-// Tipo completo de um repository construído
-type MeuRepo = BuiltRepository<Usuario, "usuario", typeof config, typeof buildConfig>;
+import type { RepositoryOf } from "../../generated/vsrepo";
 
 // Inferência a partir de uma instância VSRepository (útil para injeção de dependência)
 const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()({ ... });
@@ -1001,15 +1074,31 @@ const extension = { buscarPorDominio: (dominio: string) => Promise<Usuario[]> };
 type UsuarioRepositoryExtended = RepositoryOf<typeof usuarioVSRepo, undefined, typeof extension>;
 ```
 
-### Tipo auxiliar
+### Tipos do payload dos métodos `save` e `patch`
+
+Use `SaveObject` e `PatchObject` para extrair o tipo do payload esperado pelos métodos `save` e `patch` diretamente a partir de uma instância `VSRepository` configurada. Esses tipos já levam em conta as relações configuradas.
 
 ```ts
-import type { DistributiveOmit } from "../../generated/vsrepo";
+import type { SaveObject, PacthObject } from "../../generated/vsrepo";
+
+const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()({
+  tableName: "usuario",
+  pkName: "id",
+  relations: {
+    perfil: { pk: "id", mode: "oto", restriction: "set" },
+    postagens: { pk: "id", mode: "otm", restriction: "add" },
+  },
+});
+
+// Tipo do objeto aceito pelo .save()
+type UsuarioSavePayload = SaveObject<typeof usuarioVSRepo>;
 
-// Omit distributivo — preserva unions ao omitir propriedades
-type SemEmail = DistributiveOmit<Usuario | Perfil, "email">;
+// Tipo do objeto aceito pelo .patch()
+type UsuarioPatchPayload = PacthObject<typeof usuarioVSRepo>;
 ```
 
+> Útil para tipar DTOs, funções auxiliares ou serviços que chamam `save`/`patch` e precisam do tipo correto do payload sem referenciar diretamente os tipos internos do Prisma.
+
 ---
 
 ## API Reference

package/VSRepository/VSRepository.d.ts

@@ -51,15 +51,22 @@ type ValidMethodPatterns =
     | `createManyAndReturn${string}` | `createMany${string}`
     | `create${string}` | `updateManyAndReturnBy${string}` | `updateManyBy${string}`
     | `updateBy${string}` | `upsertBy${string}` | `deleteManyBy${string}`
-    | `deleteBy${string}` | `countBy${string}` | `count${string}`
-    | `findWhere${string}` | `findListWhere${string}`;
-
-type StringModifiers = 
-    | 'NotStartsWith' | 'StartsWith' | 'NotEndsWith' | 'EndsWith' 
-    | 'NotContains' | 'Contains' | 'NotIn' | 'In' | 'Not';
+    | `deleteBy${string}` | `countBy${string}` | `count${string}` | `countWhere${string}`
+    | `findWhere${string}` | `findListWhere${string}`
+    | 'aggregate' | 'groupBy';
 
 type StripModifier<S extends string> =
-  S extends `${infer Base}${StringModifiers}Insensitive` ? Base :
+  // Expansão explícita para resolver o problema do 'Insensitive'
+  S extends `${infer Base}NotStartsWithInsensitive` ? Base :
+  S extends `${infer Base}StartsWithInsensitive` ? Base :
+  S extends `${infer Base}NotEndsWithInsensitive` ? Base :
+  S extends `${infer Base}EndsWithInsensitive` ? Base :
+  S extends `${infer Base}NotContainsInsensitive` ? Base :
+  S extends `${infer Base}ContainsInsensitive` ? Base :
+  S extends `${infer Base}NotInInsensitive` ? Base :
+  S extends `${infer Base}InInsensitive` ? Base :
+  S extends `${infer Base}NotInsensitive` ? Base :
+  // Modificadores normais
   S extends `${infer Base}NotStartsWith` ? Base :
   S extends `${infer Base}StartsWith` ? Base :
   S extends `${infer Base}NotEndsWith` ? Base :
@@ -93,7 +100,7 @@ type GetFieldType<T, S extends string, I> = ExtractFieldName<S> extends infer Fi
             ? T[FieldName][]
             : NonNullable<T[FieldName]> extends object | any[]
               ? I extends { whereInput: infer W }
-                  ? FieldName extends keyof NonNullable<W> ? NonNullable<W>[FieldName] : T[FieldName]
+                  ? FieldName extends keyof NonNullable<W> ? Exclude<NonNullable<W>[FieldName], undefined> : T[FieldName]
                   : T[FieldName]
               : T[FieldName]
         : ParseRelation<S> extends [infer Rel extends keyof T, any, infer Rest extends string]
@@ -124,8 +131,6 @@ type MapToContractTypes<T, Arr extends string[], I> =
                 : never
         : [];
 
-type HasMultipleANDs<S extends string> = S extends `${string}AND${string}AND${string}` ? true : false;
-
 type SplitAllTokens<S extends string> =
     S extends `${infer L}AND${infer R}` ? [...SplitAllTokens<L>, ...SplitAllTokens<R>] :
     S extends `${infer L}And${infer R}` ? [...SplitAllTokens<L>, ...SplitAllTokens<R>] :
@@ -150,20 +155,28 @@ type ResolveReturnType<M extends string, TSelected> =
     M extends 'findMany' | 'createManyAndReturn' | 'updateManyAndReturnBy' | 'findListWhere' | 'findByList' ? TSelected[] :
     M extends 'findUnique' | 'findFirst' | 'findWhere' | 'findByOne' ? TSelected | null :
     M extends 'findUniqueOrThrow' | 'findFirstOrThrow' | 'create' | 'updateBy' | 'upsertBy' | 'deleteBy' ? TSelected :
-    M extends 'count' ? number : never;
+    M extends 'count' | 'countWhere' ? number : never;
+
+type GetUpdateInput<I> = I extends { updateInput: infer U } ? U : unknown;
+type GetCreateInput<I> = I extends { createInput: infer C } ? C : unknown;
+type GetCreateManyInput<I> = I extends { createManyInput: infer CM } ? CM : unknown;
+type GetUpdateManyInput<I> = I extends { updateManyInput: infer UM } ? UM : unknown;
+type GetWhereInput<I> = I extends { whereInput: infer W } ? NonNullable<W> : unknown;
+type GetCursorInput<I> = I extends { cursorInput: infer C } ? C : unknown;
+type GetOrderByInput<I> = I extends { orderByInput: infer OB } ? OB : OrderOptions;
 
 type ExtraArgs<M extends string, R extends string, I> = [
-    ...(M extends 'upsertBy' ? [update: I extends { updateInput: infer U } ? U : unknown, create: I extends { createInput: infer C } ? C : unknown]
-      : M extends 'create' ? [data: I extends { createInput: infer C } ? C : unknown]
-      : M extends 'updateBy' ? [data: I extends { updateInput: infer U } ? U : unknown]
-      : M extends 'createMany' | 'createManyAndReturn' ? [data: I extends { createManyInput: infer CM } ? CM : unknown]
-      : M extends 'updateManyBy' | 'updateManyAndReturnBy' ? [data: I extends { updateManyInput: infer UM } ? UM : unknown]
-      : M extends 'findWhere' | 'findListWhere' ? [where: I extends { whereInput: infer W } ? NonNullable<W> : unknown]
+    ...(M extends 'upsertBy' ? [update: GetUpdateInput<I>, create: GetCreateInput<I>]
+      : M extends 'create' ? [data: GetCreateInput<I>]
+      : M extends 'updateBy' ? [data: GetUpdateInput<I>]
+      : M extends 'createMany' | 'createManyAndReturn' ? [data: GetCreateManyInput<I>]
+      : M extends 'updateManyBy' | 'updateManyAndReturnBy' ? [data: GetUpdateManyInput<I>]
+      : M extends 'findWhere' | 'findListWhere' | 'countWhere' ? [where: GetWhereInput<I>]
       : []),
-    ...(R extends `${string}PaginatedAndOrdered` ? [pagination: PaginationOptions<I extends { cursorInput: infer C } ? C : unknown>, order: I extends { orderByInput: infer OB } ? OB : OrderOptions]
-      : R extends `${string}OrderedAndPaginated` ? [order: I extends { orderByInput: infer OB } ? OB : OrderOptions, pagination: PaginationOptions<I extends { cursorInput: infer C } ? C : unknown>]
-      : R extends `${string}Paginated` ? [pagination: PaginationOptions<I extends { cursorInput: infer C } ? C : unknown>]
-      : R extends `${string}Ordered` ? [order: I extends { orderByInput: infer OB } ? OB : OrderOptions]
+    ...(R extends `${string}PaginatedAndOrdered` ? [pagination: PaginationOptions<GetCursorInput<I>>, order: GetOrderByInput<I>]
+      : R extends `${string}OrderedAndPaginated` ? [order: GetOrderByInput<I>, pagination: PaginationOptions<GetCursorInput<I>>]
+      : R extends `${string}Paginated` ? [pagination: PaginationOptions<GetCursorInput<I>>]
+      : R extends `${string}Ordered` ? [order: GetOrderByInput<I>]
       : [])
 ];
 
@@ -172,13 +185,17 @@ type PrismaDelegate<M extends Prisma.ModelName> = Uncapitalize<M> extends keyof
 type FullModelType<M extends Prisma.ModelName> = 
   Prisma.Result<PrismaDelegate<M>, {}, 'findMany'> extends Array<infer U> ? U : never;
 
+type PrecomputedSelects<M extends Prisma.ModelName, SelectModels> = {
+    [S in keyof SelectModels]: Prisma.Result<PrismaDelegate<M>, { select: SelectModels[S] }, 'findMany'> extends Array<infer U> ? U : never
+};
+
 type SelectedModel<M extends Prisma.ModelName, S, SelectModels> = 
     [S] extends [false] 
         ? FullModelType<M>
         : [S] extends [never] 
             ? FullModelType<M> 
             : [S] extends [keyof SelectModels] 
-                ? (Prisma.Result<PrismaDelegate<M>, { select: SelectModels[S] }, 'findMany'> extends Array<infer U> ? U : never)
+                ? PrecomputedSelects<M, SelectModels>[S]
                 : FullModelType<M>;
 
 type CleanFields<R extends string> =
@@ -207,9 +224,18 @@ export type MethodOptions<S> = {
 };
 
 /**
- * Versão de `MethodOptions` derivada de um mapa de select models.
+ * Versão de `MethodOptions` derivada diretamente de uma instância configurada de `VSRepository`.
+ *
+ * @template TRepo Instância de `VSRepository` configurada (use `typeof meuVSRepo`).
+ *
+ * @example
+ * const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()(config);
+ * type Opts = MethodOptionsModel<typeof usuarioVSRepo>;
  */
-export type MethodOptionsModel<T> = MethodOptions<keyof T | false>;
+export type MethodOptionsModel<TRepo> =
+    TRepo extends VSRepository<any, any, infer Config>
+        ? MethodOptions<keyof ExtractSelectModels<Config> | false>
+        : never;
 
 type MethodFn<MethodName extends string, T, M extends Prisma.ModelName, R extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I> = 
     <S extends keyof SelectModels | false = DefaultSelect>(...args: [...ExtractFields<T, CleanFields<R>, I>, ...ExtraArgs<MethodName, R, I>, options?: MethodOptions<S>]) => Promise<ResolveReturnType<MethodName, SelectedModel<M, S, SelectModels>>>;
@@ -217,10 +243,10 @@ type MethodFn<MethodName extends string, T, M extends Prisma.ModelName, R extend
 type GetMappedMethod<K extends string, MethodConf> = 
     K extends `findBy${string}` ? (MethodConf extends { fbMode: 'one' } ? 'findByOne' : 'findByList') :
     K extends `existsBy${string}` ? 'existsBy' :
-    K extends `findUniqueBy${string}` ? 'findUnique' :
     K extends `findUniqueOrThrowBy${string}` ? 'findUniqueOrThrow' :
-    K extends `findFirstBy${string}` | `findFirst${string}` ? 'findFirst' :
+    K extends `findUniqueBy${string}` ? 'findUnique' :
     K extends `findFirstOrThrowBy${string}` | `findFirstOrThrow${string}` ? 'findFirstOrThrow' :
+    K extends `findFirstBy${string}` | `findFirst${string}` ? 'findFirst' :
     K extends `findManyBy${string}` | `findMany${string}` ? 'findMany' :
     K extends `createManyAndReturn${string}` ? 'createManyAndReturn' :
     K extends `createMany${string}` ? 'createMany' :
@@ -231,14 +257,26 @@ type GetMappedMethod<K extends string, MethodConf> =
     K extends `upsertBy${string}` ? 'upsertBy' :
     K extends `deleteManyBy${string}` ? 'deleteManyBy' :
     K extends `deleteBy${string}` ? 'deleteBy' :
+    K extends `countWhere${string}` ? 'countWhere' :
     K extends `countBy${string}` | `count${string}` ? 'count' :
     K extends `findListWhere${string}` ? 'findListWhere' :
     K extends `findWhere${string}` ? 'findWhere' :
+    K extends 'aggregate' ? 'aggregate' :
+    K extends 'groupBy' ? 'groupBy' :
     never;
 
 type ExtractPatternBase<K extends string> = 
     K extends `${string}By${infer R}` ? R :
-    K extends `findFirst${infer R}` | `findFirstOrThrow${infer R}` | `findMany${infer R}` | `createManyAndReturn${infer R}` | `createMany${infer R}` | `create${infer R}` | `count${infer R}` | `findWhere${infer R}` | `findListWhere${infer R}` ? R : '';
+    K extends `findFirstOrThrow${infer R}` ? R :
+    K extends `findFirst${infer R}` ? R :
+    K extends `findMany${infer R}` ? R :
+    K extends `createManyAndReturn${infer R}` ? R :
+    K extends `createMany${infer R}` ? R :
+    K extends `create${infer R}` ? R :
+    K extends `countWhere${infer R}` ? R :
+    K extends `count${infer R}` ? R :
+    K extends `findListWhere${infer R}` ? R :
+    K extends `findWhere${infer R}` ? R : '';
 
 type MethodFactory<T, M extends Prisma.ModelName, K extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, MethodConf> = 
     MethodFn<GetMappedMethod<K, MethodConf>, T, M, ExtractPatternBase<K>, SelectModels, DefaultSelect, I>;
@@ -252,10 +290,28 @@ type ExtractSelectModels<Config> = Config extends { selectModels: infer SM } ? S
 type ExtractDefaultSelect<Config> = Config extends { defaultSelectModel: infer D } ? D : never;
 type ExtractRelations<Config> = Config extends { relations: infer R } ? (R extends object ? R : {}) : {};
 
+type AggregateMethod<M extends Prisma.ModelName> = <A extends Prisma.TypeMap['model'][M]['operations']['aggregate']['args']>(
+    prismaArgs: A, 
+    options?: { db?: ClientOrTransaction }
+) => Promise<Prisma.Result<PrismaDelegate<M>, A, 'aggregate'>>;
+
+type GroupByMethod<M extends Prisma.ModelName> = <A extends Prisma.TypeMap['model'][M]['operations']['groupBy']['args']>(
+    prismaArgs: A, 
+    options?: { db?: ClientOrTransaction }
+) => Promise<Prisma.Result<PrismaDelegate<M>, A, 'groupBy'>>;
+
 type DynamicMethods<T, M extends Prisma.ModelName, Config, I> = Config extends { methods: infer Methods }
     ? {
           [K in keyof Methods as Methods[K] extends { map: true } ? K : never]: K extends string
-              ? MethodFactory<T, M, Methods[K] extends { proxyTo: infer P extends string } ? P : K, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K]>
+              ? (Methods[K] extends { proxyTo: infer P extends string } ? P : K) extends infer ResolvedKey
+                  ? ResolvedKey extends 'aggregate'
+                      ? AggregateMethod<M>
+                      : ResolvedKey extends 'groupBy'
+                      ? GroupByMethod<M>
+                      : ResolvedKey extends string
+                      ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K]>
+                      : never
+                  : never
               : never;
       }
     : {};
@@ -463,7 +519,7 @@ type InjectedRemove<
 /**
  * Versão distributiva de `Omit`, preservando unions ao remover propriedades.
  */
-export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 type ExtractUnionProp<T, K extends PropertyKey> = T extends any ? (K extends keyof T ? T[K] : never) : never;
 
 type ExtractNestedCreateInput<M extends Prisma.ModelName, K extends PropertyKey> = 
@@ -483,7 +539,7 @@ type RelationPayload<TField, TRelationConfig, M extends Prisma.ModelName, K exte
  * Substitui os campos relacionais pelo formato compatível com os modos
  * configurados em `relations`.
  */
-export type UpsertWithRelations<T, M extends Prisma.ModelName, TRelations> = 
+type UpsertWithRelations<T, M extends Prisma.ModelName, TRelations> = 
     DistributiveOmit<ModelUpsertInput<M>, keyof TRelations> & {
         [K in Extract<keyof TRelations, keyof T>]?: RelationPayload<T[K], TRelations[K], M, K>;
     };
@@ -511,11 +567,27 @@ type RelationUpdatePayload<TField, TRelationConfig, M extends Prisma.ModelName,
  * Substitui os campos relacionais pelo formato compatível com os modos
  * configurados em `relations` para fluxos de Update.
  */
-export type UpdateWithRelations<T, M extends Prisma.ModelName, TRelations> = 
+type UpdateWithRelations<T, M extends Prisma.ModelName, TRelations> = 
     DistributiveOmit<PrismaModelInputs<M>['updateInput'], keyof TRelations> & {
         [K in Extract<keyof TRelations, keyof T>]?: RelationUpdatePayload<T[K], TRelations[K], M, K>;
     };
 
+/**
+ * Extrai o tipo de payload do método `save` a partir de uma instância de VSRepository configurada.
+ */
+export type SaveObject<TRepo> = 
+    TRepo extends VSRepository<infer T, infer M, infer Config>
+        ? UpsertWithRelations<T, M, Config extends { relations: infer R } ? (R extends object ? R : {}) : {}>
+        : never;
+
+/**
+ * Extrai o tipo de payload do método `patch` a partir de uma instância de VSRepository configurada.
+ */
+export type PacthObject<TRepo> = 
+    TRepo extends VSRepository<infer T, infer M, infer Config>
+        ? UpdateWithRelations<T, M, Config extends { relations: infer R } ? (R extends object ? R : {}) : {}>
+        : never;
+
 type InjectedSave<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
     TSelects = ExtractSelectModels<Config>,
@@ -529,7 +601,7 @@ type InjectedSave<
      * @returns O registro salvo com tipos refinados conforme a entrada.
      */
     save<
-        O extends UpsertWithRelations<T, M, TRelations>, 
+        O, 
         S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'save', TSelects>
     >(
         obj: O & UpsertWithRelations<T, M, TRelations>, 
@@ -552,7 +624,7 @@ type InjectedPatch<
      * @returns O registro atualizado refinado conforme a entrada.
      */
     patch<
-        O extends UpdateWithRelations<T, M, TRelations>,
+        O,
         S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'patch', TSelects>
     >(
         pk: T[TPk extends keyof T ? TPk : never],
@@ -726,7 +798,7 @@ export type RepoConfig<T, M extends Prisma.ModelName, SM extends Record<string,
  *
  * Combina métodos dinâmicos, métodos base e extensões personalizadas.
  */
-export type BuiltRepository<T extends object, M extends Prisma.ModelName, Config extends RepoConfig<T, M, any>, C extends BuildConfig<any> | undefined> = {
+type BuiltRepository<T extends object, M extends Prisma.ModelName, Config extends RepoConfig<T, M, any>, C extends BuildConfig<any> | undefined> = {
     /**
      * Estende o repository com métodos personalizados sem perder a tipagem.
      */
@@ -775,8 +847,8 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
     pkName: keyof T;
     /** Mapa de select models disponíveis. */
     selectModels?: SelectModels<M>;
-    /** Select model padrão. */
-    defaultSelectModel?: Config extends { selectModels: infer SM } ? (keyof SM extends never ? string : Extract<keyof SM, string>) : string;
+    /** Select model padrão. Deve ser uma chave dos `selectModels`. */
+    defaultSelectModel?: string;
     /** Filtros globais aplicados às queries do repository. */
     requiredWhere?: WhereModel<M>;
     /** Relações gerenciadas automaticamente pelo `save` e pelo `patch`. */
@@ -784,9 +856,7 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
     /** Mapa dos métodos dinâmicos e suas regras de validação. */
     methods?: {
         [K in keyof (Config extends { methods: infer Meth } ? Meth : {})]: K extends string
-            ? HasMultipleANDs<K> extends true
-                ? MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> & { proxyTo: ValidMethodPatterns }
-                : MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> & (K extends ValidMethodPatterns ? {} : { proxyTo: ValidMethodPatterns })
+            ? MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> & (K extends ValidMethodPatterns ? {} : { proxyTo: ValidMethodPatterns })
             : never;
     };
 };

package/VSRepository/VSRepository.js

@@ -96,7 +96,8 @@ export class VSRepository {
             let existsMode = false;
             let skipDuplicates;
             let ignoreSkipDuplicates = true;
-            let whereIndex
+            let whereIndex;
+            let prismaArgsIndex;
             const whereParams = [];
             const otherParams = [];
 
@@ -131,6 +132,16 @@ export class VSRepository {
                 ignoreOrderByAndPagination = false;
                 ignoreSelect = true;
                 method = 'count';
+            } else if(keyToMap.startsWith('countWhere')) {
+                keyToMapReplaced = keyToMap.replace('countWhere', '');
+                ignoreOrderByAndPagination = false;
+                ignoreWhere = true;
+                onlyBaseWheres = true;
+                ignoreSelect = true;
+                method = 'count';
+                whereIndex = 0;
+                otherParams.push('where');
+                argsCount += 1;
             } else if(keyToMap.startsWith('count')) {
                 keyToMapReplaced = keyToMap.replace('count', '');
                 ignoreOrderByAndPagination = false;
@@ -233,6 +244,22 @@ export class VSRepository {
                 keyToMapReplaced = keyToMap.replace('findBy', '');
                 ignoreOrderByAndPagination = false;
                 method = methods[originalKey].fbMode === 'one' ? 'findFirst' : 'findMany';
+            } else if(keyToMap === 'aggregate') {
+                keyToMapReplaced = keyToMap.replace('aggregate', '')
+                ignoreSelect = true;
+                ignoreWhere = true;
+                method = 'aggregate';
+                prismaArgsIndex = 0;
+                otherParams.push('prismaArgs');
+                argsCount++;
+            } else if(keyToMap === 'groupBy') {
+                keyToMapReplaced = keyToMap.replace('groupBy', '')
+                ignoreSelect = true;
+                ignoreWhere = true;
+                method = 'groupBy';
+                prismaArgsIndex = 0;
+                otherParams.push('prismaArgs');
+                argsCount++;
             } else {
                 throw new VSRepoBuildError(`[VSRepository] (build) Unknown method: ${keyToMap}.`);
             }
@@ -559,6 +586,8 @@ export class VSRepository {
             }
 
             buildInstance.vsrepocache.set(originalKey, (args, optionsSelectModel) => {
+                if (prismaArgsIndex !== undefined) return args.at(prismaArgsIndex);
+
                 const prismaArgs = {};
 
                 if(!ignoreSelect) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {
@@ -38,8 +38,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "vsrepo": "node ./scripts/configure-prisma-import.mjs",
-    "configure:prisma-import": "node ./scripts/configure-prisma-import.mjs"
+    "vsrepo": "node ./scripts/configure-prisma-import.mjs"
   },
   "keywords": [
     "prisma",
@@ -47,7 +46,8 @@
     "orm",
     "typescript",
     "vsrepo",
-    "vsrepository"
+    "vsrepository",
+    "jparepository"
   ],
   "author": "João Pedro Azevedo Freire Mecenas",
   "license": "MIT",