vsrepo 1.2.0 → 1.2.1

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`:

package/VSRepository/VSRepository.d.ts

@@ -51,8 +51,9 @@ 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}`;
+    | `deleteBy${string}` | `countBy${string}` | `count${string}` | `countWhere${string}`
+    | `findWhere${string}` | `findListWhere${string}`
+    | 'aggregate' | 'groupBy';
 
 type StringModifiers = 
     | 'NotStartsWith' | 'StartsWith' | 'NotEndsWith' | 'EndsWith' 
@@ -150,7 +151,7 @@ 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 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]
@@ -158,7 +159,7 @@ type ExtraArgs<M extends string, R extends string, I> = [
       : 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 'findWhere' | 'findListWhere' | 'countWhere' ? [where: I extends { whereInput: infer W } ? NonNullable<W> : unknown]
       : []),
     ...(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>]
@@ -217,10 +218,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 +232,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 +265,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;
       }
     : {};
@@ -775,8 +806,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`. */

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