vsrepo 1.1.1 → 1.1.3

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`, `getOrThrow`, `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();
 
-await usuarioRepository.updateById(usuario.id, { nome: "Joao Pedro" });
+usuario.nome = "Joao Pedro";
+
+await usuarioRepository.save(usuario);
 await usuarioRepository.remove(usuario.id);
 ```
 
@@ -332,23 +326,27 @@ export class UserController {
 
 ## Métodos base
 
-Ao chamar `.build(prisma)`, quatro 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         |
 | `getOrThrow(pk)` | Busca um registro pela primary key e lança erro se não encontrar |
-| `save(obj)`  | Cria ou atualiza (upsert pela primary key) |
+| `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: {
@@ -360,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)
+    }
   },
 });
 ```
@@ -398,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.
 
@@ -487,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:
@@ -833,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          |
@@ -998,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 };
   };
 });
 ```
@@ -1013,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)
@@ -1051,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

@@ -1,84 +1,127 @@
-import { VSRepoConfigError } from "./VSRepoError.js";
+import z from "zod";
+import { VSRepoConfigError, VSRepoBuildError } from "./VSRepoError.js";
 
-export class FieldValidator {
-    constructor(throws) {
-        this.throws = throws;
-    }
+const stringSchema = z.string().trim().nonempty();
+const objectSchema = z.looseObject({});
+const booleanSchema = z.boolean();
 
-    validate(
-        field,
-        fieldName,
-        mustBe,
-        undefinedAble,
-        nullAble,
-        customReason
-    ) {
-        if (field === undefined) {
-            if (undefinedAble) return;
-            throw this.instanceError(fieldName, customReason ?? "cannot be undefined");
+export function validateConfig(config) {
+    const configSchema = z.strictObject({
+        tableName: stringSchema,
+        pkName: stringSchema,
+        selectModels: z.record(stringSchema, objectSchema).optional(),
+        defaultSelectModel: stringSchema.optional(),
+        requiredWhere: objectSchema.optional(),
+        relations: z.record(
+            stringSchema,
+            z.strictObject({
+                mode: z.enum(['otm', 'mtm', 'mto', 'oto']),
+                restriction: z.enum(['set', 'add']),
+                pk: stringSchema,
+                nullAble: booleanSchema.optional(),
+            })
+        ).optional(),
+        methods: z.record(stringSchema, z.strictObject({
+            map: booleanSchema,
+            selectModel: stringSchema.or(z.literal(false)).optional(),
+            whereType: z.enum(["overwrite", "extending"]).optional(),
+            proxyTo: stringSchema.optional(),
+            pushWhere: objectSchema.optional(),
+            fbMode: z.enum(["one", "list"]).optional(),
+            injectOrdenation: objectSchema.or(z.array(objectSchema)).optional(),
+            injectPagination: objectSchema.optional()
+        })).optional()
+    }).superRefine((config, ctx)=>{
+        if (config.defaultSelectModel && !config.selectModels?.[config.defaultSelectModel]) {
+            ctx.addIssue({
+                code: "vs_custom",
+                path: ["defaultSelectModel"],
+                message: "must be a valid key of 'selectModels'",
+            });
         }
 
-        if (field === null) {
-            if (nullAble) return;
-            throw this.instanceError(fieldName, customReason ?? "cannot be null");
+        if (config.methods) {
+            for (const [key, method] of Object.entries(config.methods)) {
+                if (method.selectModel && !config.selectModels?.[method.selectModel]) {
+                    ctx.addIssue({
+                        code: "vs_custom",
+                        path: ["methods", key, "selectModel"],
+                        message: "must be a valid key of 'selectModels'",
+                    });
+                }
+            }
         }
+    });
 
-        const condition = typeof mustBe === "function" ? !mustBe(field) : typeof field !== mustBe;
+    const configParsed = configSchema.safeParse(config);
 
-        if(condition) {
-            throw this.instanceError(fieldName, customReason ?? `must be a valid ${mustBe}`);
-        };
+    if(!configParsed.success) {
+        const firstIssue = configParsed.error.issues[0];
+        const path = firstIssue.path.length ? firstIssue.path.join(".") : "config";
+        throw new VSRepoConfigError(`[VSRepository] (config) ${path}: ${firstIssue.message}`)
     }
 
-    instanceError(fieldName, reason) {
-        const error = new this.throws("");
-        error.message = `[VSRepository] (${error.type}) '${fieldName}' ${reason}.`;
-        return error;
-    }
+    return configParsed.data;
 }
 
-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'");
+export function validateBuildConfig(buildConfig, buildInstance) {
+    const activeSchema = booleanSchema.default(true);
+    const defaultSelectSchema = buildInstance.selectModels ?
+        z.enum(Object.keys(buildInstance.selectModels)).optional()
+        : z.never("can only be passed if you have configured 'selectModels'.");
+    const ignoreRequiredWhereSchema = booleanSchema.default(false);
+
+    const buildConfigSchema = z.strictObject({
+        freeze: booleanSchema.default(true),
+        showWorking: booleanSchema.default(false),
+        baseMethods: z.strictObject({
+            get: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            getOrThrow: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            getAll: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            remove: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            save: z.strictObject({
+                active: activeSchema,
+                defaultSelect: defaultSelectSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            removeList: z.strictObject({
+                active: activeSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            total: z.strictObject({
+                active: activeSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+            has: z.strictObject({
+                active: activeSchema,
+                ignoreRequiredWhere: ignoreRequiredWhereSchema
+            }).optional(),
+        }).optional()
+    });
+
+    const buildConfigParsed = buildConfigSchema.safeParse(buildConfig);
+
+    if(!buildConfigParsed.success) {
+        const firstIssue = buildConfigParsed.error.issues[0];
+        const path = firstIssue.path.length ? firstIssue.path.join(".") : "config";
+        throw new VSRepoBuildError(`[VSRepository] (build) ${path}: ${firstIssue.message}`)
     }
 
-    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`);
-        }
-    }
-}
+    return buildConfigParsed.data;
+}

package/VSRepository/VSRepository.d.ts

@@ -348,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;
 };
 
@@ -372,10 +372,18 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
         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' | 'getOrThrow' | '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 
@@ -475,11 +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.
@@ -534,6 +590,11 @@ export type BuiltRepository<T extends object, M extends Prisma.ModelName, Config
      * Estende o repository com métodos personalizados sem perder a tipagem.
      */
     extend<E>(extensionFunc: (repo: BuiltRepository<T, M, Config, C>) => E): BuiltRepository<T, M, Config, C> & E;
+
+    /**
+     * Instância do Prisma Client passada no `build`.
+     */
+    readonly prisma: DbClient;
 } & DynamicMethods<T, M, Config, PrismaModelInputs<M>> & InjectedBaseMethods<T, M, Config, C>;
 
 /**
@@ -549,7 +610,7 @@ export declare class VSRepository<T extends object, M extends Prisma.ModelName,
     /**
      * Constrói o repository final com os métodos base e dinâmicos.
      */
-    build<C extends BuildConfig<any>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
+    build<C extends BuildConfig<keyof ExtractSelectModels<Config>>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
     vsrepocache: never;
 }
 

package/VSRepository/VSRepository.js

@@ -8,8 +8,8 @@
 export * from "./VSRepoError.js";
 
 // * Importando classes de erro
-import { VSRepoConfigError, VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
-import { validateConfig } from "./VSRepoUtils.js";
+import { VSRepoBuildError, VSRepoExtendError, VSRepoRuntimeError } from "./VSRepoError.js";
+import { validateBuildConfig, validateConfig } from "./VSRepoUtils.js";
 
 // * Essa é a classe pincipal, é a partir dela que serão criados os objetos dos repositories
 export class VSRepository {
@@ -29,7 +29,7 @@ export class VSRepository {
     methods;
 
     constructor(config) {
-        validateConfig(config);
+        config = validateConfig(config);
 
         this.vsrepocache = new Map();
         this.tableName = config.tableName;
@@ -59,18 +59,17 @@ export class VSRepository {
         return extended;
     }
 
-    build(prisma, config = {}) {
-        const showWorking = config.showWorking;
-
-        if(typeof config !== 'object' || config === null) {
-            throw new VSRepoBuildError(`[VSRepository] (build) 'config' must be a valid object.`);
-        }
-        if(config.freeze === undefined) {
-            config.freeze = true;
+    build(prisma, config = { freeze: true, showWorking: false }) {
+        if(typeof prisma !== 'object' || prisma === null) {
+            throw new VSRepoBuildError(`[VSRepository] (build) 'prisma' must be a valid Prisma Client.`);
         }
 
         const buildInstance = Object.create(this);
 
+        config = validateBuildConfig(config, buildInstance);
+
+        const showWorking = config.showWorking;
+
         const relationsKeys = buildInstance.relations ? Object.keys(buildInstance.relations) : [];
 
         const methods = buildInstance.methods;
@@ -487,10 +486,6 @@ export class VSRepository {
                                 whereArgs.push(buildedWhere);
                             }
 
-                            if(showWorking) {
-                                console.log(`[VSRepository] (build) Where object builded to ${keyToMap}:\n`, JSON.stringify(buildedWhere, null, 2));
-                            }
-
                             if(buildedWhere.autoInjectVal === undefined) argsCount++;
                         }
 
@@ -700,9 +695,9 @@ export class VSRepository {
                     const missingParams = whereParams.concat(otherParams).slice(args.length);
                     throw new VSRepoRuntimeError(`[VSRepository] (runtime) Missing parameters: ${missingParams.join(', ')}`);
                 } else if(args.length > argsCount) {
-                    const optionsArg = args[args.length - 1]
+                    const optionsArg = args[args.length - 1];
                     db = optionsArg.db ?? db;
-                    optionsSelectModel = optionsArg.selectModel
+                    optionsSelectModel = optionsArg.selectModel;
                 } else {
                     args.push('1')
                 }
@@ -740,10 +735,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 };
@@ -782,10 +774,7 @@ export class VSRepository {
         }
         if(config.baseMethods?.getOrThrow?.active !== false) {
             buildInstance.getOrThrow = 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 };
@@ -824,10 +813,7 @@ export class VSRepository {
         }
         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 };
@@ -865,10 +851,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;
@@ -1077,9 +1060,142 @@ 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)
+        buildInstance.prisma = prisma;
+
+        if(config.freeze) Object.freeze(buildInstance);
         return buildInstance;
     }
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "vsrepo",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jaobrabo123/VSRepository"
+    "url": "git+https://github.com/jaobrabo123/VSRepository.git"
   },
   "main": "./VSRepository/index.js",
   "types": "./VSRepository/index.d.ts",
@@ -32,7 +32,7 @@
     "scripts"
   ],
   "bin": {
-    "vsrepo": "./scripts/configure-prisma-import.mjs"
+    "vsrepo": "scripts/configure-prisma-import.mjs"
   },
   "engines": {
     "node": ">=18"
@@ -63,5 +63,8 @@
     "prisma": "^7.8.0",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "zod": "^4.4.3"
   }
-}
+}