vsrepo 1.1.0 → 1.1.2

package/README.md

@@ -7,7 +7,7 @@ Biblioteca de repository pattern para projetos que usam **Prisma**, com suporte
 
 O VSRepository permite criar repositories fortemente tipados com:
 
-- **Métodos base** automáticos: `get`, `save`, `remove`
+- **Métodos base** automáticos: `get`, `getOrThrow`, `save`, `remove`, `removeList`, `getAll`, `total`, `has`
 - **Métodos dinâmicos** inferidos pelo nome: `findByEmail`, `findManyPaginated`, `updateById`, `deleteManyByIdIn`
 - **Select models** reutilizáveis para diferentes projeções de dados
 - **Type safety** em 100% das operações
@@ -24,7 +24,7 @@ O VSRepository permite criar repositories fortemente tipados com:
 - [Integração com NestJS](#integração-com-nestjs)
 - [Métodos base](#métodos-base)
 - [Select Models](#select-models)
-- [requiredWhere](#requiredwhere)
+- [Required Where](#requiredwhere)
 - [Métodos dinâmicos](#métodos-dinâmicos)
   - [Prefixos disponíveis](#prefixos-disponíveis)
   - [Filtros de campo](#filtros-de-campo)
@@ -38,6 +38,7 @@ O VSRepository permite criar repositories fortemente tipados com:
 - [Tratamento de erros](#tratamento-de-erros)
 - [Tipos utilitários](#tipos-utilitários)
 - [API Reference](#api-reference)
+- [Contribuindo](#contribuindo)
 - [Requisitos](#requisitos)
 - [Troubleshooting](#troubleshooting)
 
@@ -94,9 +95,11 @@ src/generated/vsrepo/
 Após gerar, importe sempre a partir da pasta gerada:
 
 ```ts
+// CORRETO ✅
 import { setupVSRepo } from "../generated/vsrepo";
-// ou
-import { setupVSRepo, type SelectModels, type WhereModel } from "../generated/vsrepo";
+
+// ERRADO ❌
+import { setupVSRepo } from "vsrepo";
 ```
 
 ---
@@ -128,22 +131,11 @@ import type { Usuario } from "../generated/prisma/client";
 const usuarioRepository = setupVSRepo<Usuario, "usuario">()({
   tableName: "usuario",
   pkName: "id",
-
   selectModels: {
     public: { id: true, nome: true, email: true },
-    minimal: { id: true },
   },
   defaultSelectModel: "public",
-
   requiredWhere: { ativo: true },
-
-  methods: {
-    findByEmail: { map: true, fbMode: "one" },
-    findManyPaginated: { map: true },
-    updateById: { map: true },
-    deleteManyByIdIn: { map: true, whereType: "overwrite" },
-    count: { map: true },
-  },
 }).build(prisma);
 
 export default usuarioRepository;
@@ -163,9 +155,11 @@ const usuario = await usuarioRepository.save({
 });
 
 const encontrado = await usuarioRepository.get(usuario.id);
-const porEmail = await usuarioRepository.findByEmail("joao@email.com");
+const todos = await usuarioRepository.getAll();
+
+usuario.nome = "Joao Pedro";
 
-await usuarioRepository.updateById(usuario.id, { nome: "Joao Pedro" });
+await usuarioRepository.save(usuario);
 await usuarioRepository.remove(usuario.id);
 ```
 
@@ -182,7 +176,7 @@ O VSRepository pode ser facilmente integrado em projetos NestJS através de prov
 import { Provider } from "@nestjs/common";
 import { PrismaService } from "../../database/prisma.service";
 import { UserGetPayload } from "../../generated/prisma/models";
-import { RepositoryOf, setupVSRepo } from "../../generated/vsrepo";
+import { setupVSRepo } from "../../generated/vsrepo";
 
 const userVSRepo = setupVSRepo<
     UserGetPayload<{ include: { profile: true } }>,
@@ -220,19 +214,28 @@ const userVSRepo = setupVSRepo<
             proxyTo: "findUniqueByEmail",
             selectModel: "auth",
         },
+        findByEmailEndsWith: {
+            map: true,
+        }
     },
 });
 
-export type UserRepository = RepositoryOf<typeof userVSRepo>;
+const setupUserRepository = (prisma: PrismaService) => {
+    return userVSRepo.build(prisma).extend((repo) => ({
+        buscarPorDominio: async (dominio: string) => {
+            return repo.findByEmailEndsWith(`@${dominio}`);
+        },
+    }));
+};
+
+export type UserRepository = ReturnType<typeof setupUserRepository>;
 
 export const USER_REPOSITORY = Symbol("USER_REPOSITORY");
 
 export const UserRepositoryProvider: Provider = {
     provide: USER_REPOSITORY,
     inject: [PrismaService],
-    useFactory: (prisma: PrismaService) => {
-        return userVSRepo.build(prisma);
-    },
+    useFactory: setupUserRepository,
 };
 ```
 
@@ -323,22 +326,27 @@ export class UserController {
 
 ## Métodos base
 
-Ao chamar `.build(prisma)`, três métodos são automaticamente disponibilizados:
+Ao chamar `.build(prisma)` os métodos base abaixo são automaticamente disponibilizados:
 
 | Método       | Descrição                                  |
 | ------------ | ------------------------------------------ |
 | `get(pk)`    | Busca um registro pela primary key         |
-| `save(obj)`  | Cria ou atualiza (upsert 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`) |
 | `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`)  |
+| `total()`  | Retorna o total de registros |
+| `has(pk)`          | Verifica existência de um registro pela primary key — retorna `boolean`   |
 
-Todos aceitam `options?: { selectModel?, db? }` como último argumento.
+Todos aceitam `options` como último argumento.
 
 ### Configurando os métodos base
 
 ```ts
 usuarioVSRepo.build(prisma, {
-  freeze: true,        // Congela o objeto (padrão: true)
-  showWorking: false,  // Exibe logs do VSRepository no console, ótimo para debugar as queries criadas e os objetos passados para o prisma
+  freeze: true,        // Congela o objeto (padrão = true)
+  showWorking: true,  // Exibe logs do VSRepository no console, ótimo para debugar as queries criadas e os objetos passados para o prisma
 
   baseMethods: {
     get: {
@@ -350,9 +358,11 @@ usuarioVSRepo.build(prisma, {
       defaultSelect: "minimal",
     },
     save: {
-      active: true,
-      ignoreRequiredWhere: true, // Não aplica requiredWhere no upsert
+      ignoreRequiredWhere: true, // Não aplica requiredWhere no save
     },
+    has: {
+      active: false, // Desativa o 'has' (padrão = true)
+    }
   },
 });
 ```
@@ -388,7 +398,7 @@ const usuarioCompleto = await usuarioRepository.get(id, { selectModel: false });
 
 ---
 
-## requiredWhere
+## Required Where
 
 `requiredWhere` define filtros aplicados automaticamente em todas as queries do repository.
 
@@ -433,8 +443,11 @@ O prefixo do nome do método determina qual operação Prisma será chamada e qu
 | ------------------------- | ------------------------ | ---------------------- | -------------------------------------------------------- |
 | `findBy`                  | `findMany` / `findFirst` | `T[]` ou `T \| null`   | Padrão é lista; use `fbMode: "one"` para retorno único   |
 | `findUniqueBy`            | `findUnique`             | `T \| null`            |                                                          |
+| `findUniqueOrThrowBy`     | `findUniqueOrThrow`      | `T`                    | Lança erro se não encontrar                                  |
 | `findFirstBy`             | `findFirst`              | `T \| null`            | Aceita campos como filtro                                |
+| `findFirstOrThrowBy`      | `findFirstOrThrow`       | `T`                    | Aceita campos como filtro; lança erro se não encontrar       |
 | `findFirst`               | `findFirst`              | `T \| null`            | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`          |
+| `findFirstOrThrow`        | `findFirstOrThrow`       | `T`                    | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`; lança erro se não encontrar |
 | `findManyBy`              | `findMany`               | `T[]`                  | Aceita campos como filtro                                |
 | `findMany`                | `findMany`               | `T[]`                  | Sem filtros de campo; aplica só `requiredWhere` e `pushWhere`           |
 | `findWhere`               | `findFirst`              | `T \| null`            | Recebe um objeto `where` explícito como argumento        |
@@ -474,10 +487,10 @@ Os filtros são sufixos aplicados ao nome do campo dentro do método. O campo em
 | `GreaterThanEqual` | `gte`                 | sim                  |
 | `LessThan`         | `lt`                  | sim                  |
 | `LessThanEqual`    | `lte`                 | sim                  |
-| `IsNull`           | `null`                | não (zero-arg)       |
-| `IsNotNull`        | `not: null`           | não (zero-arg)       |
-| `IsTrue`           | `true`                | não (zero-arg)       |
-| `IsFalse`          | `false`               | não (zero-arg)       |
+| `IsNull`           | `null`                | não                  |
+| `IsNotNull`        | `not: null`           | não                  |
+| `IsTrue`           | `true`                | não                  |
+| `IsFalse`          | `false`               | não                  |
 | `Insensitive`      | `mode: 'insensitive'` | combinador           |
 
 `Insensitive` é um combinador e pode ser usado junto com outro filtro de texto:
@@ -820,7 +833,7 @@ try {
 
 | Classe               | Quando é lançada                                        |
 | -------------------- | ------------------------------------------------------- |
-| `VSRepoConfigError`  | Configuração inválida em `setupVSRepo` ou `build`       |
+| `VSRepoConfigError`  | Configuração inválida em `setupVSRepo`       |
 | `VSRepoBuildError`   | Nome de método inválido ou desconhecido no `build`      |
 | `VSRepoExtendError`  | Argumento inválido em `extend`                          |
 | `VSRepoRuntimeError` | Erro em tempo de execução durante uma operação          |
@@ -985,13 +998,24 @@ setupVSRepo<TPayload, TTableName>()({
 
 ```ts
 vsRepo.build(prisma, {
-  freeze?: boolean;        // Congela o objeto (padrão: true)
-  showWorking?: boolean;   // Exibe logs internos no console
+  freeze?: boolean;        // Congela o objeto (default = true)
+  showWorking?: boolean;   // Exibe logs internos no console (default = false)
 
+  // `active` serve para definir se o método vai existir depois do build (default = true)
+  // `defaultSelect` serve para definir qual `selectModel` esse método vai usar por default (default = `defaultSelectModel` definido no `setupVSRepo`)
+  // `ignoreRequiredWhere` serve para definir se o método vai ignorar o `requiredWhere` definido no `setupVSRepo` (default = false)
   baseMethods?: {
-    get?:    { active?: boolean; defaultSelect?: string };
-    remove?: { active?: boolean; defaultSelect?: string };
-    save?:   { active?: boolean; ignoreRequiredWhere?: boolean };
+    // Métodos que podem utilizar um `defaultSelect`
+    get?:       { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
+    getOrThrow?:{ active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
+    remove?:    { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
+    save?:      { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
+    getAll?:    { active?: boolean; defaultSelect?: string; ignoreRequiredWhere?: boolean };
+
+    // Métodos que NÃO aceitam `defaultSelect`
+    removeList?: { active?: boolean; ignoreRequiredWhere?: boolean };
+    total?:      { active?: boolean; ignoreRequiredWhere?: boolean };
+    has?:        { active?: boolean; ignoreRequiredWhere?: boolean };
   };
 });
 ```
@@ -1000,12 +1024,25 @@ vsRepo.build(prisma, {
 
 ```ts
 repo.extend((repo) => ({
-  meuMetodo() { ... }
+  meuMetodo: () => { ... }
 }));
 ```
 
 ---
 
+## Contribuindo
+
+Contribuições são bem-vindas! Se você encontrou um bug, tem uma ideia de melhoria ou quer ajudar com a documentação, sinta-se à vontade para participar (**[Repositório do GitHub](https://github.com/jaobrabo123/VSRepository)**):
+
+1. Faça um **Fork** do projeto.
+2. Crie uma nova branch com a sua alteração: `git checkout -b corrigindo-bug`.
+3. Faça o push para a sua branch: `git push origin corrigindo-bug`.
+4. Abra um **Pull Request**.
+
+Para reportar problemas ou sugerir novas funcionalidades, abra uma **Issue**.
+
+---
+
 ## Requisitos
 
 - Node.js 16+ (ESM)
@@ -1038,4 +1075,4 @@ repo.extend((repo) => ({
 
 **`proxyTo` obrigatório** — Nomes fora dos moldes (ex.: `buscarPorEmail`) não são parseados diretamente. Use `proxyTo: "findByEmail"` nesses casos.
 
-**Select model retorna campos inesperados** — Verifique se o select model define exatamente os campos que o seu tipo TypeScript espera. Campos com `false` não serão retornados pelo Prisma.
+**Select model retorna campos inesperados** — Verifique se o select model define exatamente os campos que o seu tipo TypeScript espera. Campos com `false` não serão retornados pelo Prisma.

package/VSRepository/VSRepoUtils.js

@@ -0,0 +1,84 @@
+import { VSRepoConfigError } from "./VSRepoError.js";
+
+export class FieldValidator {
+    constructor(throws) {
+        this.throws = throws;
+    }
+
+    validate(
+        field,
+        fieldName,
+        mustBe,
+        undefinedAble,
+        nullAble,
+        customReason
+    ) {
+        if (field === undefined) {
+            if (undefinedAble) return;
+            throw this.instanceError(fieldName, customReason ?? "cannot be undefined");
+        }
+
+        if (field === null) {
+            if (nullAble) return;
+            throw this.instanceError(fieldName, customReason ?? "cannot be null");
+        }
+
+        const condition = typeof mustBe === "function" ? !mustBe(field) : typeof field !== mustBe;
+
+        if(condition) {
+            throw this.instanceError(fieldName, customReason ?? `must be a valid ${mustBe}`);
+        };
+    }
+
+    instanceError(fieldName, reason) {
+        const error = new this.throws("");
+        error.message = `[VSRepository] (${error.type}) '${fieldName}' ${reason}.`;
+        return error;
+    }
+}
+
+export function validateConfig(config) {
+    const validator = new FieldValidator(VSRepoConfigError);
+
+    validator.validate(config, "config", "object");
+    validator.validate(config.tableName, "tableName", "string");
+    validator.validate(config.pkName, "pkName", "string");
+    validator.validate(config.selectModels, "selectModels", "object", true);
+
+    if(config.defaultSelectModel !== undefined) {
+        validator.validate(config.defaultSelectModel, "defaultSelectModel", "string");
+
+        validator.validate(config.defaultSelectModel, "defaultSelectModel", (field) => {
+            return !!(config.selectModels && Object.keys(config.selectModels).includes(config.defaultSelectModel))
+        }, false, false, "must be a valid key of 'selectModels'");
+    }
+
+    if(config.relations !== undefined) {
+        validator.validate(config.relations, "relations", "object");
+
+        for (const key of Object.keys(config.relations)) {
+            const relation = config.relations[key];
+
+            validator.validate(relation.pk, "pk", "string", false, false, `of relation '${key}' must be a string`);
+            validator.validate(relation.mode, "mode", (field) => ['otm', 'mtm', 'mto', 'oto'].includes(field), false, false, `of relation '${key}' must be 'otm', 'mtm', 'mto' or 'oto'`);
+            validator.validate(relation.restriction, "restriction", (field) => ['set', 'add'].includes(field), false, false, `of relation '${key}' must be 'set' or 'add'`);
+        }
+    }
+
+    validator.validate(config.requiredWhere, "requiredWhere", "object", true);
+
+    if(config.methods !== undefined) {
+        validator.validate(config.methods, "methods", "object");
+
+        for (const [key, value] of Object.entries(config.methods)) {
+            validator.validate(value.map, "map", "boolean", false, false, `on ${key} must be a valid boolean`);
+            validator.validate(value.whereType, "whereType", (field) => ['extending', 'overwrite'].includes(field), true, false, `on ${key} must be 'extending' or 'overwrite'`);
+            validator.validate(value.selectModel, "selectModel", (field) => !!(field === false || (config.selectModels && Object.keys(config.selectModels).includes(field))), true, false, `on ${key} must be a valid key of 'selectModels'`);
+            validator.validate(value.proxyTo, "proxyTo", "string", true, false, `on ${key} must be a valid string`);
+            validator.validate(value.fbMode, "fbMode", (field) => ['one', 'list'].includes(field), true, false, `on ${key} must be 'one' or 'list'`);
+            validator.validate(value.pushWhere, "pushWhere", "object", true, false, `on ${key} must be a valid object`);
+            validator.validate(value.injectOrdenation, "injectOrdenation", "object", true, false, `on ${key} must be a valid object or array`);
+            validator.validate(value.injectPagination, "injectPagination", "object", true, false, `on ${key} must be a valid object`);
+        }
+    }
+}

package/VSRepository/VSRepository.d.ts

@@ -43,9 +43,12 @@ export type PaginationOptions<TCursor = unknown> = {
 export type OrderOptions = OrderPattern | OrderPattern[];
 
 type ValidMethodPatterns =
-    | `existsBy${string}` | `findBy${string}` | `findUniqueBy${string}`
-    | `findFirstBy${string}` | `findFirst${string}` | `findManyBy${string}`
-    | `findMany${string}` | `createManyAndReturn${string}` | `createMany${string}`
+    | `existsBy${string}` | `findBy${string}` 
+    | `findUniqueBy${string}` | `findUniqueOrThrowBy${string}`
+    | `findFirstBy${string}` | `findFirst${string}` 
+    | `findFirstOrThrowBy${string}` | `findFirstOrThrow${string}`
+    | `findManyBy${string}` | `findMany${string}` 
+    | `createManyAndReturn${string}` | `createMany${string}`
     | `create${string}` | `updateManyAndReturnBy${string}` | `updateManyBy${string}`
     | `updateBy${string}` | `upsertBy${string}` | `deleteManyBy${string}`
     | `deleteBy${string}` | `countBy${string}` | `count${string}`
@@ -55,9 +58,6 @@ type StringModifiers =
     | 'NotStartsWith' | 'StartsWith' | 'NotEndsWith' | 'EndsWith' 
     | 'NotContains' | 'Contains' | 'NotIn' | 'In' | 'Not';
 
-type NumberModifiers = 
-    | 'LessThanEqual' | 'LessThan' | 'GreaterThanEqual' | 'GreaterThan';
-
 type StripModifier<S extends string> =
   S extends `${infer Base}${StringModifiers}Insensitive` ? Base :
   S extends `${infer Base}NotStartsWith` ? Base :
@@ -149,7 +149,7 @@ type ResolveReturnType<M extends string, TSelected> =
     M extends 'createMany' | 'updateManyBy' | 'deleteManyBy' ? { count: number } :
     M extends 'findMany' | 'createManyAndReturn' | 'updateManyAndReturnBy' | 'findListWhere' | 'findByList' ? TSelected[] :
     M extends 'findUnique' | 'findFirst' | 'findWhere' | 'findByOne' ? TSelected | null :
-    M extends 'create' | 'updateBy' | 'upsertBy' | 'deleteBy' ? TSelected :
+    M extends 'findUniqueOrThrow' | 'findFirstOrThrow' | 'create' | 'updateBy' | 'upsertBy' | 'deleteBy' ? TSelected :
     M extends 'count' ? number : never;
 
 type ExtraArgs<M extends string, R extends string, I> = [
@@ -218,7 +218,9 @@ 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 `findFirstOrThrowBy${string}` | `findFirstOrThrow${string}` ? 'findFirstOrThrow' :
     K extends `findManyBy${string}` | `findMany${string}` ? 'findMany' :
     K extends `createManyAndReturn${string}` ? 'createManyAndReturn' :
     K extends `createMany${string}` ? 'createMany' :
@@ -236,7 +238,7 @@ type GetMappedMethod<K extends string, MethodConf> =
 
 type ExtractPatternBase<K extends string> = 
     K extends `${string}By${infer R}` ? R :
-    K extends `findFirst${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 `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 : '';
 
 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>;
@@ -346,7 +348,7 @@ type BaseMethodConfig<TSelectKeys extends PropertyKey = string> = {
     active?: boolean;
     /** Select model padrão usado pelo método base. */
     defaultSelect?: TSelectKeys;
-    /** Ignora o `requiredWhere` no `save`. */
+    /** Ignora o `requiredWhere`. */
     ignoreRequiredWhere?: boolean;
 };
 
@@ -364,14 +366,24 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
     baseMethods?: {
         /** Configuração do método `get`. */
         get?: BaseMethodConfig<TSelectKeys>;
+        /** Configuração do método `getOrThrow`. */
+        getOrThrow?: BaseMethodConfig<TSelectKeys>;
         /** Configuração do método `remove`. */
         remove?: BaseMethodConfig<TSelectKeys>;
         /** Configuração do método `save`. */
         save?: 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). */
+        getAll?: BaseMethodConfig<TSelectKeys>;
+        /** Configuração do método `total` (contagem). Não aceita select. */
+        total?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
+        /** Configuração do método `has` (verificação de existência). Não aceita select. */
+        has?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
     };
 };
 
-type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'remove' | 'save', TSelects = ExtractSelectModels<Config>> =
+type ResolveMethodDefaultSelect<Config, C, Method extends 'get' | 'getOrThrow' | 'remove' | 'save' | 'getAll', TSelects = ExtractSelectModels<Config>> =
     C extends { baseMethods?: { [_ in Method]?: { defaultSelect?: infer D } } }
         ? D extends keyof TSelects 
             ? D 
@@ -406,6 +418,17 @@ type InjectedGet<
     ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault> | null>;
 };
 
+type InjectedGetOrThrow<
+    T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
+    TSelects = ExtractSelectModels<Config>,
+    TDefault = ExtractDefaultSelect<Config>,
+    TPk = ExtractPkName<T, Config>
+> = C extends { baseMethods: { getOrThrow: { active: false } } } ? {} : {
+    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>>;
+};
+
 type InjectedRemove<
     T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
     TSelects = ExtractSelectModels<Config>,
@@ -460,10 +483,59 @@ type InjectedSave<
     ): 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. */
+    removeList(
+        pks: T[TPk extends keyof T ? TPk : never][], 
+        options?: { db?: ClientOrTransaction }
+    ): Promise<{ count: number }>;
+};
+
+type InjectedGetAll<
+    T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined,
+    TSelects = ExtractSelectModels<Config>,
+    TDefault = ExtractDefaultSelect<Config>,
+    I = PrismaModelInputs<M>
+> = C extends { baseMethods: { getAll: { active: false } } } ? {} : {
+    /** Busca todos os registros, respeitando o `requiredWhere` se houver. */
+    getAll<S extends keyof TSelects | false = ResolveMethodDefaultSelect<Config, C, 'getAll', TSelects>>(
+        options?: MethodOptions<S> & { 
+            pagination?: PaginationOptions<I extends { cursorInput: infer Curs } ? Curs : unknown>;
+            order?: I extends { orderByInput: infer OB } ? OB : OrderOptions;
+        }
+    ): Promise<ResolveCurrentReturn<M, TSelects, S, TDefault>[]>;
+};
+
+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. */
+    total(options?: { db?: ClientOrTransaction }): Promise<number>;
+};
+
+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. */
+    has(
+        pk: T[TPk extends keyof T ? TPk : never], 
+        options?: { db?: ClientOrTransaction }
+    ): Promise<boolean>;
+};
+
 type InjectedBaseMethods<T, M extends Prisma.ModelName, Config, C extends BuildConfig<any> | undefined> = 
     InjectedGet<T, M, Config, C> & 
+    InjectedGetOrThrow<T, M, Config, C> & 
     InjectedRemove<T, M, Config, C> & 
-    InjectedSave<T, M, Config, C>;
+    InjectedSave<T, M, Config, C> &
+    InjectedRemoveList<T, M, Config, C> &
+    InjectedGetAll<T, M, Config, C> &
+    InjectedTotal<T, M, Config, C> &
+    InjectedHas<T, M, Config, C>;
 
 /**
  * Infere automaticamente a configuração de relação possível a partir de um campo.

package/VSRepository/VSRepository.js

@@ -8,7 +8,8 @@
 export * from "./VSRepoError.js";
 
 // * Importando classes de erro
-import { VSRepoConfigError, VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
+import { VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
+import { validateConfig } from "./VSRepoUtils.js";
 
 // * Essa é a classe pincipal, é a partir dela que serão criados os objetos dos repositories
 export class VSRepository {
@@ -28,92 +29,7 @@ export class VSRepository {
     methods;
 
     constructor(config) {
-        if(typeof config !== 'object' || config === null){
-            throw new VSRepoConfigError(`[VSRepository] (config) 'config' must be a valid object.`);
-        }
-        if(typeof config.tableName !== 'string') {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'tableName' must be a valid string.`);
-        }
-        if(typeof config.pkName !== 'string') {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'pkName' must be a valid string.`);
-        }
-        if(config.selectModels !== undefined && typeof config.selectModels !== 'object' || config.selectModels === null) {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'selectModels' must be a valid object.`);
-        }
-        if(config.defaultSelectModel !== undefined) {
-            if(!config.selectModels) {
-                throw new VSRepoConfigError(`[VSRepository] (config) 'defaultSelectModel' can only be passed with 'selectModels'.`);
-            }
-            if(typeof config.defaultSelectModel !== 'string') {
-                throw new VSRepoConfigError(`[VSRepository] (config) 'defaultSelectModel' must be a valid string.`);
-            }
-            if(!Object.keys(config.selectModels).includes(config.defaultSelectModel)){
-                throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'defaultSelectModel': ${config.defaultSelectModel}`);
-            }
-        }
-        if(config.relations !== undefined) {
-            const relations = config.relations;
-            if(typeof relations !== 'object' || relations === null){
-                throw new VSRepoConfigError(`[VSRepository] (config) 'relations' must be a valid object.`);
-            }
-
-            for (const key of Object.keys(relations)) {
-                const relation = relations[key];
-                if(typeof relation.pk !== 'string'){
-                    throw new VSRepoConfigError(`[VSRepository] (config) The property 'pk' of relation '${key}' must be a string.`);
-                }
-                if(typeof relation.mode !== 'string'){
-                    throw new VSRepoConfigError(`[VSRepository] (config) The property 'mode' of relation '${key}' must be 'otm', 'mtm', 'mto' or 'oto'.`);
-                }
-                if(typeof relation.restriction !== 'string'){
-                    throw new VSRepoConfigError(`[VSRepository] (config) The property 'restriction' of relation '${key}' must be 'set' or 'add'.`);
-                }
-            }
-        }
-        if(config.requiredWhere !== undefined && typeof config.requiredWhere !== 'object' || config.requiredWhere === null) {
-            throw new VSRepoConfigError(`[VSRepository] (config) 'requiredWhere' must be a valid object.`);
-        }
-        if(config.methods !== undefined) {
-            if(typeof config.methods !== 'object' || config.methods === null){
-                throw new VSRepoConfigError(`[VSRepository] (config) 'methods' must be a valid object.`);
-            } else {
-                for (const [key, value] of Object.entries(config.methods)) {
-
-                    if(typeof value.map !== "boolean") {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'map' on ${key} must be a valid boolean.`);
-                    }
-
-                    if(value.whereType !== undefined && !['extending', 'overwrite'].includes(value.whereType)){
-                        throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'whereType' on ${key}: ${value.whereType}`);
-                    }
-
-                    if(value.selectModel !== undefined && value.selectModel !== false && (!config.selectModels || !Object.keys(config.selectModels).includes(value.selectModel))){
-                        throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'selectModel' on ${key}: ${value.selectModel}`);
-                    }
-
-                    if(value.proxyTo !== undefined && typeof value.proxyTo !== 'string') {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'proxyTo' on ${key} must be a valid string.`);
-                    }
-
-                    if(value.fbMode !== undefined && !['one', 'list'].includes(value.fbMode)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) Invalid 'fbMode' on ${key}: ${value.whereType}`);
-                    }
-
-                    if(value.pushWhere !== undefined && (typeof value.pushWhere !== 'object' || value.pushWhere === null)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'pushWhere' on ${key} must be a valid object.`);
-                    }
-
-                    if(value.injectOrdenation !== undefined && (typeof value.injectOrdenation !== 'object' || value.injectOrdenation === null)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'injectOrdenation' on ${key} must be a valid object or array.`);
-                    }
-
-                    if(value.injectPagination !== undefined && (typeof value.injectPagination !== 'object' || value.injectPagination === null)) {
-                        throw new VSRepoConfigError(`[VSRepository] (config) 'injectPagination' on ${key} must be a valid object.`);
-                    }
-
-                }
-            }
-        }
+        validateConfig(config);
 
         this.vsrepocache = new Map();
         this.tableName = config.tableName;
@@ -185,9 +101,22 @@ export class VSRepository {
             const whereParams = [];
             const otherParams = [];
 
-            if(keyToMap.startsWith('findUniqueBy')) {
+            if(keyToMap.startsWith('findUniqueOrThrowBy')) {
+                keyToMapReplaced = keyToMap.replace('findUniqueOrThrowBy', '');
+                method = 'findUniqueOrThrow';
+            } else if(keyToMap.startsWith('findUniqueBy')) {
                 keyToMapReplaced = keyToMap.replace('findUniqueBy', '');
                 method = 'findUnique';
+            } else if(keyToMap.startsWith('findFirstOrThrowBy')) {
+                keyToMapReplaced = keyToMap.replace('findFirstOrThrowBy', '')
+                ignoreOrderByAndPagination = false;
+                method = 'findFirstOrThrow';
+            } else if(keyToMap.startsWith('findFirstOrThrow')) {
+                keyToMapReplaced = keyToMap.replace('findFirstOrThrow', '');
+                ignoreOrderByAndPagination = false;
+                ignoreWhere = true;
+                onlyBaseWheres = true;
+                method = 'findFirstOrThrow';
             } else if(keyToMap.startsWith('findFirstBy')) {
                 keyToMapReplaced = keyToMap.replace('findFirstBy', '')
                 ignoreOrderByAndPagination = false;
@@ -811,10 +740,7 @@ export class VSRepository {
 
         if(config.baseMethods?.get?.active !== false) {
             buildInstance.get = async(pk, options = {}) => {
-                let db;
-                if(options?.db) db = options.db;
-                else db = prisma;
-
+                let db = options?.db ?? prisma;
                 const prismaArgs = {};
 
                 const where = { [buildInstance.pkName]: pk };
@@ -851,12 +777,48 @@ export class VSRepository {
                 }
             }
         }
+        if(config.baseMethods?.getOrThrow?.active !== false) {
+            buildInstance.getOrThrow = async(pk, options = {}) => {
+                let db = options?.db ?? prisma;
+                const prismaArgs = {};
+
+                const where = { [buildInstance.pkName]: pk };
+                if(buildInstance.requiredWhere && !config.baseMethods?.getOrThrow?.ignoreRequiredWhere) {
+                    Object.assign(where, buildInstance.requiredWhere);
+                }
+                prismaArgs.where = where;
+
+                let selectModelKey = options?.selectModel ?? config.baseMethods?.getOrThrow?.defaultSelect ?? buildInstance.defaultSelectModel;
+                if(selectModelKey){
+                    prismaArgs.select = buildInstance.selectModels[selectModelKey];
+                }
+
+                let start;
+                if(showWorking){
+                    console.log(`[VSRepository] (runtime) Executing getOrThrow on ${buildInstance.tableName}.`);
+                    console.log(`[VSRepository] (runtime) Built arguments to getOrThrow on ${buildInstance.tableName}:\n`, JSON.stringify(prismaArgs, null, 2));
+                    start = performance.now();
+                }
+
+                try {
+                    const result = await db[buildInstance.tableName].findUniqueOrThrow(prismaArgs);
+
+                    if(showWorking) {
+                        const end = performance.now();
+                        const duration = (end - start).toFixed(2);
+                        console.log(`[VSRepository] (runtime) Executed getOrThrow on ${buildInstance.tableName} (took: ${duration}ms).`);
+                    }
+
+                    return result;
+                } catch (err) {
+                    console.log(`[VSRepository] (runtime) Fatal error when trying to getOrThrow on ${buildInstance.tableName}:\n`, JSON.stringify({ prismaArgs }, null, 2));
+                    throw err;
+                }
+            }
+        }
         if(config.baseMethods?.remove?.active !== false) {
             buildInstance.remove = async (pk, options = {}) => {
-                let db;
-                if(options?.db) db = options.db;
-                else db = prisma;
-
+                let db = options?.db ?? prisma;
                 const prismaArgs = {};
 
                 const where = { [buildInstance.pkName]: pk };
@@ -894,10 +856,7 @@ export class VSRepository {
         }
         if(config.baseMethods?.save?.active !== false) {
             buildInstance.save = async (obj, options = {}) => {
-                let db;
-                if(options?.db) db = options.db;
-                else db = prisma;
-
+                let db = options?.db ?? prisma;
                 const prismaArgs = {};
 
                 let selectModelKey = options?.selectModel ?? config.baseMethods?.save?.defaultSelect ?? buildInstance.defaultSelectModel;
@@ -1106,6 +1065,137 @@ export class VSRepository {
                     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;
+
+                    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(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];
+                    }
+
+                    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;
+                    }
+                }
+            }
+            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 };
+                    }
+
+                    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).`);
+                        }
+                        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.freeze) Object.freeze(buildInstance)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {
@@ -61,6 +61,7 @@
     "@types/node": "^25.6.0",
     "dotenv": "^17.4.2",
     "prisma": "^7.8.0",
+    "tsx": "^4.22.3",
     "typescript": "^6.0.3"
   }
 }

package/scripts/configure-prisma-import.mjs

@@ -10,6 +10,15 @@ const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 
 const DEFAULT_OUTPUT = 'src/generated/vsrepo';
 const DEFAULT_PRISMA = 'src/generated/prisma';
+const GENERATED_HEADER = `/**
+ * ! THIS FILE IS AUTO-GENERATED.
+ * ! DO NOT EDIT MANUALLY.
+ */
+/* eslint-disable */
+/* biome-ignore-all lint: generated file */
+// @ts-nocheck
+
+`;
 
 const command = args[0]?.startsWith('-') ? 'generate' : args[0] ?? 'generate';
 const commandArgs = command === 'generate' && args[0] !== command ? args : args.slice(1);
@@ -91,7 +100,7 @@ for (const fileName of typeFiles) {
     `from '${relativeImportPath(path.dirname(targetFile), prismaTargetPath)}'`
   );
 
-  fs.writeFileSync(targetFile, contents, 'utf8');
+  fs.writeFileSync(targetFile, GENERATED_HEADER + contents, 'utf8');
 
   console.log(`Gerado: ${path.relative(workspaceRoot, targetFile)}`);
 }
@@ -166,7 +175,7 @@ export type * from './VSRepository.types';
 for (const file of tsFiles) {
   const targetFile = path.join(outputDir, file.fileName);
 
-  fs.writeFileSync(targetFile, file.content, 'utf8');
+  fs.writeFileSync(targetFile, GENERATED_HEADER + file.content, 'utf8');
 
   console.log(`Gerado: ${path.relative(workspaceRoot, targetFile)}`);
 }