vsrepo 1.2.9 → 1.3.0

package/README.md

@@ -30,6 +30,7 @@ O VSRepository permite criar repositories fortemente tipados com:
   - [Merge](#merge)
   - [Configurando os métodos base](#configurando-os-métodos-base)
 - [Select Models](#select-models)
+- [Include Models](#include-models)
 - [Required Where](#requiredwhere)
 - [Default Ordenation](#default-ordenation)
 - [Opção `see`](#opção-see)
@@ -464,6 +465,51 @@ const usuarioCompleto = await usuarioRepository.get(id, { selectModel: false });
 
 ---
 
+## Include Models
+
+`includeModels` funciona de forma parecida com o `selectModels`, mas em vez de receber um `select`, ele recebe um `include` válido do Prisma.
+
+```ts
+const usuarioRepository = setupVSRepo<Usuario, "usuario">()(({
+  tableName: "usuario",
+  pkName: "id",
+  selectModels: {
+    public: { id: true, nome: true, email: true },
+  },
+  defaultSelectModel: "public",
+  includeModels: {
+    comPosts: { posts: true },
+    comPostsEPerfil: { posts: true, perfil: true },
+  },
+}).build(prisma);
+```
+
+**Usando um `includeModel` na chamada:**
+
+```ts
+const usuario = await usuarioRepository.get(id, { includeModel: "comPosts" });
+```
+
+Nesse caso, o `select` padrão (`selectModels`/`defaultSelectModel`) é ignorado e apenas o `include` é enviado ao Prisma.
+
+### Diferenças em relação ao `selectModels`
+
+- **Só pode ser passado na chamada do método**, via `options.includeModel`. Não existe `defaultIncludeModel` nem `defaultInclude` — não há como configurar um `includeModel` padrão no repository, diferente do que ocorre com `defaultSelectModel`.
+- **`includeModel` e `selectModel` não podem ser passados juntos** na mesma chamada. Se um `includeModel` for informado, qualquer `selectModel` (incluindo o padrão) é ignorado.
+
+```ts
+// CORRETO ✅ — apenas includeModel
+await usuarioRepository.get(id, { includeModel: "comPosts" });
+
+// CORRETO ✅ — apenas selectModel
+await usuarioRepository.get(id, { selectModel: "public" });
+
+// ERRADO ❌ — não é permitido combinar os dois
+await usuarioRepository.get(id, { selectModel: "public", includeModel: "comPosts" });
+```
+
+---
+
 ## Required Where
 
 `requiredWhere` define filtros aplicados automaticamente em todas as queries do repository.
@@ -973,6 +1019,8 @@ type SeeMode = "active" | "removed" | "all";
 import type {
   SelectModel,
   SelectModels,
+  IncludeModel,
+  IncludeModels,
   WhereModel,
   OrdenationModel,
   PaginationModel,
@@ -986,14 +1034,16 @@ import type {
 ```ts
 import type { MethodOptions, MethodOptionsModel } from "../../generated/vsrepo";
 
-// MethodOptions<S> — opções passadas nos métodos do repository
-type Opts = MethodOptions<"public" | "minimal">;
+// MethodOptions<S, IM> — opções passadas nos métodos do repository
+type Opts = MethodOptions<"public" | "minimal", "comPosts">;
 
 // MethodOptionsModel<TRepo> — derivado de uma instância VSRepository configurada
 const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()(config);
 type OptsModel = MethodOptionsModel<typeof usuarioVSRepo>;
 ```
 
+> O segundo parâmetro de `MethodOptions` (`IM`) representa as chaves válidas de `includeModels`. Quando informado, `selectModel` e `includeModel` tornam-se mutuamente exclusivos no tipo — não é possível passar os dois na mesma chamada.
+
 ### Tipos de configuração
 
 ```ts
@@ -1049,8 +1099,9 @@ setupVSRepo<TPayload, TTableName>()({
   tableName: Uncapitalize<M>;                     // Nome da tabela no Prisma
   pkName: keyof T;                                // Nome da primary key
   softRemovekName?: keyof T & string;             // Campo DateTime para soft-delete (opcional)
-  selectModels?: SelectModels<M>;                 // Projeções de dados nomeadas
+  selectModels?: SelectModels<M>;                 // Projeções de dados nomeadas (select)
   defaultSelectModel?: keyof SM;                  // Select aplicado por padrão
+  includeModels?: IncludeModels<M>;               // Projeções de dados nomeadas (include) — sem default, só na chamada
   requiredWhere?: WhereModel<M>;                  // Filtros sempre aplicados
   defaultOrdenation?: OrdenationModel<M>;         // Ordenação padrão para queries sem Ordered/injectOrdenation
   relations?: RepositoryRelations<T>;             // Configuração de relações
@@ -1146,6 +1197,10 @@ Para reportar problemas ou sugerir novas funcionalidades, abra uma **Issue**.
 
 **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.
 
+**`selectModel` e `includeModel` juntos na mesma chamada** — Não é permitido. Escolha um ou outro: se `includeModel` for informado, o `select` (incluindo o `defaultSelectModel`) é ignorado e apenas o `include` é enviado ao Prisma.
+
+**`includeModel` não aparece como opção padrão do repository** — Isso é esperado. Diferente de `defaultSelectModel`, não existe `defaultIncludeModel`/`defaultInclude`. Um `includeModel` só pode ser definido na chamada do método, via `options.includeModel`.
+
 **`softRemovekName` lança erro no build** — O campo informado deve ser do tipo `DateTime` no schema do Prisma. Tipos como `Boolean` ou `String` não são aceitos.
 
 **`defaultOrdenation` não está sendo aplicada** — Verifique se o método não usa o sufixo `Ordered`, `OrderedAndPaginated` ou `PaginatedAndOrdered`, e se não possui `injectOrdenation` configurado. Ambos têm prioridade sobre a ordenação padrão.

package/dist/VSRepoError.d.ts

@@ -50,5 +50,5 @@ export declare class VSRepoExtendError extends VSRepoError {
  */
 export declare class VSRepoRuntimeError extends VSRepoError {
     readonly type: 'VSREPO_RUNTIME';
-    constructor(message: string, code?: string);
+    constructor(message: string, code: string);
 }

package/dist/VSRepository.d.ts

@@ -222,14 +222,22 @@ type PrecomputedSelects<M extends Prisma.ModelName, SelectModels> = {
     [S in keyof SelectModels]: Prisma.Result<PrismaDelegate<M>, { select: SelectModels[S] }, 'findMany'> extends Array<infer U> ? U : never
 };
 
-type SelectedModel<M extends Prisma.ModelName, S, SelectModels> = 
-    [S] extends [false] 
-        ? FullModelType<M>
-        : [S] extends [never] 
-            ? FullModelType<M> 
-            : [S] extends [keyof SelectModels] 
-                ? PrecomputedSelects<M, SelectModels>[S]
-                : FullModelType<M>;
+type PrecomputedIncludes<M extends Prisma.ModelName, IncludeModels> = {
+    [I in keyof IncludeModels]: Prisma.Result<PrismaDelegate<M>, { include: IncludeModels[I] }, 'findMany'> extends Array<infer U> ? U : never
+};
+
+type SelectedModel<M extends Prisma.ModelName, S, SelectModels, IM = never, IncludeModels = {}> = 
+    [IM] extends [never]
+        ? [S] extends [false] 
+            ? FullModelType<M>
+            : [S] extends [never] 
+                ? FullModelType<M> 
+                : [S] extends [keyof SelectModels] 
+                    ? PrecomputedSelects<M, SelectModels>[S]
+                    : FullModelType<M>
+        : IM extends keyof IncludeModels
+            ? PrecomputedIncludes<M, IncludeModels>[IM]
+            : FullModelType<M>;
 
 type CleanFields<R extends string> =
     R extends `${infer F}PaginatedAndOrdered` ? F :
@@ -242,17 +250,10 @@ type CleanFields<R extends string> =
  * Additional options accepted by repository methods.
  *
  * @template S Available keys in `selectModels`.
+ * @template IM Available keys in `includeModels`.
  */
-export type MethodOptions<S> = {
-    /**
-     * Select model to apply to the operation.
-     *
-     * @note Use `false` to return the full Prisma payload without a select.
-     */
-    selectModel?: S | false;
-    /**
-     * Prisma client or transaction to use for the operation.
-     */
+export type MethodOptions<S, IM extends PropertyKey = never> = {
+    /** Prisma client or transaction to use for the operation. */
     db?: ClientOrTransaction;
     /**
      * Visibility mode for records with soft-delete.
@@ -264,7 +265,17 @@ export type MethodOptions<S> = {
      * - `"all"` — returns all records, ignoring deletion status.
      */
     see?: SeeMode;
-};
+} & (
+    [IM] extends [never]
+        ? { 
+            /** Select model to apply to the operation. Use `false` to return the full payload. */
+            selectModel?: S | false; 
+            /** Include model to apply to the operation. Cannot be used together with `selectModel`. */
+            includeModel?: never;
+          }
+        : | { selectModel?: S | false; includeModel?: never }
+          | { selectModel?: never; includeModel: IM }
+);
 
 /**
  * Version of `MethodOptions` derived directly from a configured `VSRepository` instance.
@@ -277,11 +288,13 @@ export type MethodOptions<S> = {
  */
 export type MethodOptionsModel<TRepo> =
     TRepo extends VSRepository<any, any, infer Config>
-        ? MethodOptions<keyof ExtractSelectModels<Config> | false>
+        ? MethodOptions<keyof ExtractSelectModels<Config> | false, keyof ExtractIncludeModels<Config>>
         : never;
 
-type MethodFn<MethodName extends string, T, M extends Prisma.ModelName, R extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I> = 
-    <S extends keyof SelectModels | false = DefaultSelect>(...args: [...ExtractFields<T, CleanFields<R>, I>, ...ExtraArgs<MethodName, R, I>, options?: MethodOptions<S>]) => Promise<ResolveReturnType<MethodName, SelectedModel<M, S, SelectModels>>>;
+type MethodFn<MethodName extends string, T, M extends Prisma.ModelName, R extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, IncludeModels> = 
+    <S extends keyof SelectModels | false = DefaultSelect, IM extends keyof IncludeModels = never>(
+        ...args: [...ExtractFields<T, CleanFields<R>, I>, ...ExtraArgs<MethodName, R, I>, options?: MethodOptions<S, keyof IncludeModels> & ({ includeModel: IM } | { includeModel?: never })]
+    ) => Promise<ResolveReturnType<MethodName, SelectedModel<M, S, SelectModels, IM, IncludeModels>>>;
 
 type GetMappedMethod<K extends string, MethodConf> = 
     K extends `findBy${string}` ? (MethodConf extends { fbMode: 'one' } ? 'findByOne' : 'findByList') :
@@ -332,13 +345,13 @@ type ExtractPatternBase<K extends string> =
     K extends `updateManyAndReturnWhere${infer R}` ? R :
     K extends `deleteManyWhere${infer R}` ? R : '';
 
-type MethodFactory<T, M extends Prisma.ModelName, K extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, MethodConf> = 
+type MethodFactory<T, M extends Prisma.ModelName, K extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, MethodConf, IncludeModels> = 
     K extends `findWhere${string}`
         ? {
             /** @deprecated Use findOneWhere instead. */
-            <S extends keyof SelectModels | false = DefaultSelect>(...args: [...ExtractFields<T, CleanFields<ExtractPatternBase<K>>, I>, ...ExtraArgs<GetMappedMethod<K, MethodConf>, ExtractPatternBase<K>, I>, options?: MethodOptions<S>]): Promise<ResolveReturnType<GetMappedMethod<K, MethodConf>, SelectedModel<M, S, SelectModels>>>;
+            <S extends keyof SelectModels | false = DefaultSelect, IM extends keyof IncludeModels = never>(...args: [...ExtractFields<T, CleanFields<ExtractPatternBase<K>>, I>, ...ExtraArgs<GetMappedMethod<K, MethodConf>, ExtractPatternBase<K>, I>, options?: MethodOptions<S, keyof IncludeModels> & ({ includeModel: IM } | { includeModel?: never })]): Promise<ResolveReturnType<GetMappedMethod<K, MethodConf>, SelectedModel<M, S, SelectModels, IM, IncludeModels>>>;
           }
-        : MethodFn<GetMappedMethod<K, MethodConf>, T, M, ExtractPatternBase<K>, SelectModels, DefaultSelect, I>;
+        : MethodFn<GetMappedMethod<K, MethodConf>, T, M, ExtractPatternBase<K>, SelectModels, DefaultSelect, I, IncludeModels>;
 
 type ResolveSelectModel<MethodConf, GlobalConf, SelectModels> = 
     MethodConf extends { selectModel: infer S } ? (S extends false ? false : S extends keyof SelectModels ? S : never) : 
@@ -346,6 +359,7 @@ type ResolveSelectModel<MethodConf, GlobalConf, SelectModels> =
 
 type ExtractPkName<T, Config> = Config extends { pkName: infer PK } ? (PK extends keyof T ? PK : never) : never;
 type ExtractSelectModels<Config> = Config extends { selectModels: infer SM } ? SM : {};
+type ExtractIncludeModels<Config> = Config extends { includeModels: infer IM } ? IM : {};
 type ExtractDefaultSelect<Config> = Config extends { defaultSelectModel: infer D } ? D : never;
 type ExtractRelations<Config> = Config extends { relations: infer R } ? (R extends object ? R : {}) : {};
 type ExtractSoftRemovekName<Config> = Config extends { softRemovekName: infer S } ? S : never;
@@ -370,7 +384,7 @@ type DynamicMethods<T, M extends Prisma.ModelName, Config, I> = Config extends {
                       : ResolvedKey extends 'groupBy'
                       ? GroupByMethod<M>
                       : ResolvedKey extends string
-                      ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K]>
+                      ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K], ExtractIncludeModels<Config>>
                       : never
                   : never
               : never;
@@ -385,6 +399,8 @@ type DynamicMethods<T, M extends Prisma.ModelName, Config, I> = Config extends {
 export type PrismaModelInputs<M extends Prisma.ModelName> = {
     /** Type of the `select` argument used in model queries. */
     select: Prisma.TypeMap['model'][M]['operations']['findMany']['args']['select'];
+    /** Type of the `include` argument used in model queries. */
+    include: Prisma.TypeMap['model'][M]['operations']['findMany']['args']['include'];
     /** Type of the `data` used in `create`. */
     createInput: Prisma.TypeMap['model'][M]['operations']['create']['args']['data'];
     /** Type of the `data` used in `createMany`. */
@@ -415,6 +431,16 @@ export type SelectModel<M extends Prisma.ModelName> = PrismaModelInputs<M>['sele
  */
 export type SelectModels<M extends Prisma.ModelName> = Record<string, SelectModel<M>>;
 
+/**
+ * Type of the `include` object of a Prisma model.
+ */
+export type IncludeModel<M extends Prisma.ModelName> = PrismaModelInputs<M>['include'];
+
+/**
+ * Map of named, reusable includes for a Prisma model.
+ */
+export type IncludeModels<M extends Prisma.ModelName> = Record<string, IncludeModel<M>>;
+
 /**
  * Type of the `where` object of a Prisma model.
  */
@@ -452,8 +478,7 @@ export type MethodConfig<M extends Prisma.ModelName, SelectModels = any> = {
     readonly proxyTo?: ValidMethodPatterns;
     /** Adds an extra `where` on top of `requiredWhere`. */
     readonly pushWhere?: WhereModel<M>;
-    /** 
-     * Defines whether `findBy` returns a single item (`one`) or a list (`list`).
+    /** * Defines whether `findBy` returns a single item (`one`) or a list (`list`).
      * @deprecated Use `findOneBy` if you want to return a single result.
      */
     readonly fbMode?: 'one' | 'list';
@@ -497,8 +522,12 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
         remove?: BaseMethodConfig<TSelectKeys>;
         /** Configuration for the `save` method. */
         save?: BaseMethodConfig<TSelectKeys>;
+        /** Configuration for the `saveList` method (batch save via transaction). */
+        saveList?: BaseMethodConfig<TSelectKeys>;
         /** Configuration for the `patch` method. */
         patch?: BaseMethodConfig<TSelectKeys>;
+        /** Configuration for the `patchList` method (batch update via transaction). */
+        patchList?: BaseMethodConfig<TSelectKeys>;
         /** Configuration for the `merge` method. */
         merge?: BaseMethodConfig<TSelectKeys>;
         /** Configuration for the `removeList` method (batch deletion). Does not accept select. */
@@ -509,10 +538,6 @@ export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
         total?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
         /** Configuration for the `has` method (existence check). Does not accept select. */
         has?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
-        /** Configuration for the `saveList` method (batch save via transaction). */
-        saveList?: BaseMethodConfig<TSelectKeys>;
-        /** Configuration for the `patchList` method (batch update via transaction). */
-        patchList?: BaseMethodConfig<TSelectKeys>;
         /** Configuration for the `softRemove` method. Only available if `softRemovekName` is configured. */
         softRemove?: BaseMethodConfig<TSelectKeys>;
         /** Configuration for the `softRemoveList` method. Does not accept select. Only available if `softRemovekName` is configured. */
@@ -535,12 +560,16 @@ type ResolveMethodDefaultSelect<Config, C, Method extends keyof NonNullable<Buil
             ? ExtractDefaultSelect<Config> 
             : false;
 
-type ResolveCurrentReturn<M extends Prisma.ModelName, Models, S, D> = 
-    [S] extends [false] 
-        ? FullModelType<M> 
-        : [S] extends [never] 
-            ? ([D] extends [never] ? FullModelType<M> : SelectedModel<M, D, Models>)
-            : SelectedModel<M, S, Models>;
+type ResolveCurrentReturn<M extends Prisma.ModelName, Models, S, D, IM = never, Includes = {}> = 
+    [IM] extends [never]
+        ? [S] extends [false] 
+            ? FullModelType<M> 
+            : [S] extends [never] 
+                ? ([D] extends [never] ? FullModelType<M> : SelectedModel<M, D, Models>)
+                : SelectedModel<M, S, Models>
+        : IM extends keyof Includes
+            ? PrecomputedIncludes<M, Includes>[IM]
+            : FullModelType<M>;
 
 // ─── helpers reused within the mapped type ───────────────────────────────────
 // ─── relation payload types ──────────────────────────────────────────────────
@@ -603,13 +632,21 @@ type RelationUpdatePayload<TField, TRelationConfig, M extends Prisma.ModelName,
       : never;
 
 /**
- * Payload accepted by `patch` when the repository has configured relations.
+ * Payload accepted by `merge` when the repository has configured relations (uses update input).
  */
 type UpdateWithRelations<T, M extends Prisma.ModelName, TRelations> =
     DistributiveOmit<PrismaModelInputs<M>['updateInput'], keyof TRelations> & {
         [K in Extract<keyof TRelations, keyof T>]?: RelationUpdatePayload<T[K], TRelations[K], M, K>;
     };
 
+/**
+ * Payload accepted by `patch` and `patchList` when the repository has configured relations (uses create input).
+ */
+type PatchWithRelations<T, M extends Prisma.ModelName, TRelations> =
+    DistributiveOmit<PrismaModelInputs<M>['updateInput'], keyof TRelations> & {
+        [K in Extract<keyof TRelations, keyof T>]?: RelationPayload<T[K], TRelations[K], M, K>;
+    };
+
 /**
  * Extracts the payload type of the `save` method from a configured VSRepository instance.
  */
@@ -631,17 +668,18 @@ export type PatchObject<TInput, TRepo> =
     TRepo extends VSRepository<infer T, infer M, infer Config>
         ? (Config extends { relations: infer R } ? (R extends object ? R : {}) : {}) extends infer TRelations
             ? DistributiveOmit<TInput, keyof TRelations> & {
-                  [K in Extract<keyof TRelations, keyof T>]?: RelationUpdatePayload<T[K], TRelations[K], M, K>;
+                  [K in Extract<keyof TRelations, keyof T>]?: RelationPayload<T[K], TRelations[K], M, K>;
               }
             : never
         : never;
 
 
 type _Pk<T, Config> = WidenField<T[ExtractPkName<T, Config> extends keyof T ? ExtractPkName<T, Config> : never]>;
-type _Ret<M extends Prisma.ModelName, TSelects, S, TDefault> = ResolveCurrentReturn<M, TSelects, S, TDefault>;
+type _Ret<M extends Prisma.ModelName, TSelects, S, TDefault, IM = never, TIncludes = {}> = ResolveCurrentReturn<M, TSelects, S, TDefault, IM, TIncludes>;
 type _DS<Config, C, Method extends keyof NonNullable<BuildConfig['baseMethods']>, TSelects = ExtractSelectModels<Config>> =
     ResolveMethodDefaultSelect<Config, C, Method, TSelects>;
 type _Sel<Config> = ExtractSelectModels<Config>;
+type _Inc<Config> = ExtractIncludeModels<Config>;
 type _Def<Config> = ExtractDefaultSelect<Config>;
 type _Rel<Config> = ExtractRelations<Config>;
 type _Soft<Config> = ExtractSoftRemovekName<Config>;
@@ -660,59 +698,60 @@ type AllBaseMethods<
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
     I         = PrismaModelInputs<M>,
-    TDefaultOrdenation = _DOrd<Config>
+    TDefaultOrdenation = _DOrd<Config>,
+    TIncludes = _Inc<Config>
 > = {
     /** Fetches a record by its primary key (PK). */
-    get: <S extends keyof TSelects | false = _DS<Config, C, 'get', TSelects>>(
-        pk: _Pk<T, Config>, options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault> | null>;
+    get: <S extends keyof TSelects | false = _DS<Config, C, 'get', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes> | null>;
 
     /** Fetches a record by PK and throws `VSRepoRuntimeError` if not found. */
-    getOrThrow: <S extends keyof TSelects | false = _DS<Config, C, 'getOrThrow', TSelects>>(
-        pk: _Pk<T, Config>, options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>>;
+    getOrThrow: <S extends keyof TSelects | false = _DS<Config, C, 'getOrThrow', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>>;
 
     /** Fetches multiple records by a list of primary keys (PKs). */
-    getList: <S extends keyof TSelects | false = _DS<Config, C, 'getList', TSelects>>(
-        pks: _Pk<T, Config>[], options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
+    getList: <S extends keyof TSelects | false = _DS<Config, C, 'getList', TSelects>, IM extends keyof TIncludes = never>(
+        pks: _Pk<T, Config>[], options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>[]>;
 
     /** Deletes a record identified by its primary key (PK). */
-    remove: <S extends keyof TSelects | false = _DS<Config, C, 'remove', TSelects>>(
-        pk: _Pk<T, Config>, options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>>;
+    remove: <S extends keyof TSelects | false = _DS<Config, C, 'remove', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>>;
 
     /** Inserts or updates (upsert) a record. */
-    save: <S extends keyof TSelects | false = _DS<Config, C, 'save', TSelects>>(
-        obj: UpsertWithRelations<T, M, TRelations>, options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>>;
+    save: <S extends keyof TSelects | false = _DS<Config, C, 'save', TSelects>, IM extends keyof TIncludes = never>(
+        obj: UpsertWithRelations<T, M, TRelations>, options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>>;
 
     /** Saves an array of objects in a single automatic transaction. */
-    saveList: <S extends keyof TSelects | false = _DS<Config, C, 'saveList', TSelects>>(
-        objs: UpsertWithRelations<T, M, TRelations>[], options?: Omit<MethodOptions<S>, 'db'> & { db?: DbTransaction }
-    ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
+    saveList: <S extends keyof TSelects | false = _DS<Config, C, 'saveList', TSelects>, IM extends keyof TIncludes = never>(
+        objs: UpsertWithRelations<T, M, TRelations>[], options?: Omit<MethodOptions<S, keyof TIncludes>, 'db'> & ({ includeModel: IM } | { includeModel?: never }) & { db?: DbTransaction }
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>[]>;
 
     /** Partially updates (patch) an existing record by its primary key (PK). */
-    patch: <S extends keyof TSelects | false = _DS<Config, C, 'patch', TSelects>>(
-        pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>>;
+    patch: <S extends keyof TSelects | false = _DS<Config, C, 'patch', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, obj: PatchWithRelations<T, M, TRelations>, options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>>;
 
     /** Partially updates multiple records via `[pk, obj]` tuples in an automatic transaction. */
-    patchList: <S extends keyof TSelects | false = _DS<Config, C, 'patchList', TSelects>>(
-        tuples: [pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>][], options?: Omit<MethodOptions<S>, 'db'> & { db?: DbTransaction }
-    ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
+    patchList: <S extends keyof TSelects | false = _DS<Config, C, 'patchList', TSelects>, IM extends keyof TIncludes = never>(
+        tuples: [pk: _Pk<T, Config>, obj: PatchWithRelations<T, M, TRelations>][], options?: Omit<MethodOptions<S, keyof TIncludes>, 'db'> & ({ includeModel: IM } | { includeModel?: never }) & { db?: DbTransaction }
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>[]>;
 
     /** Fetches a record by PK and deep-merges it with the provided object **in memory**. */
-    merge: <S extends keyof TSelects | false = _DS<Config, C, 'merge', TSelects>>(
-        pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptions<S>
-    ) => Promise<_Ret<M, TSelects, S, TDefault> | null>;
+    merge: <S extends keyof TSelects | false = _DS<Config, C, 'merge', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes> | null>;
 
     /** Deletes multiple records by their primary keys. */
     removeList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;
 
     /** Fetches all records (respects `requiredWhere` when set). */
-    getAll: <S extends keyof TSelects | false = _DS<Config, C, 'getAll', TSelects>>(
-        options?: MethodOptions<S> & {
+    getAll: <S extends keyof TSelects | false = _DS<Config, C, 'getAll', TSelects>, IM extends keyof TIncludes = never>(
+        options?: MethodOptions<S, keyof TIncludes> & ({ includeModel: IM } | { includeModel?: never }) & {
             pagination?: PaginationOptions<I extends { cursorInput: infer Curs } ? Curs : unknown>;
             /**
              * Ordering to apply to the query.
@@ -721,7 +760,7 @@ type AllBaseMethods<
              */
             order?: I extends { orderByInput: infer OB } ? OB : OrderOptions;
         }
-    ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>[]>;
 
     /** Returns the total number of records. */
     total: (options?: { db?: ClientOrTransaction; see?: SeeMode }) => Promise<number>;
@@ -730,17 +769,17 @@ type AllBaseMethods<
     has: (pk: _Pk<T, Config>, options?: { db?: ClientOrTransaction; see?: SeeMode }) => Promise<boolean>;
 
     /** Marks a record as deleted (soft-delete). */
-    softRemove: <S extends keyof TSelects | false = _DS<Config, C, 'softRemove', TSelects>>(
-        pk: _Pk<T, Config>, options?: Omit<MethodOptions<S>, 'see'>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>>;
+    softRemove: <S extends keyof TSelects | false = _DS<Config, C, 'softRemove', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, options?: Omit<MethodOptions<S, keyof TIncludes>, 'see'> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>>;
 
     /** Marks multiple records as deleted (soft-delete) in batch. */
     softRemoveList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;
 
     /** Restores a record previously marked as deleted (soft-delete). */
-    restore: <S extends keyof TSelects | false = _DS<Config, C, 'restore', TSelects>>(
-        pk: _Pk<T, Config>, options?: Omit<MethodOptions<S>, 'see'>
-    ) => Promise<_Ret<M, TSelects, S, TDefault>>;
+    restore: <S extends keyof TSelects | false = _DS<Config, C, 'restore', TSelects>, IM extends keyof TIncludes = never>(
+        pk: _Pk<T, Config>, options?: Omit<MethodOptions<S, keyof TIncludes>, 'see'> & ({ includeModel: IM } | { includeModel?: never })
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes>>;
 
     /** Restores multiple records previously marked as deleted (soft-delete) in batch. */
     restoreList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;
@@ -757,9 +796,10 @@ type InjectedBaseMethods<
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
     I         = PrismaModelInputs<M>,
-    TDefaultOrdenation = _DOrd<Config>
+    TDefaultOrdenation = _DOrd<Config>,
+    TIncludes = _Inc<Config>
 > = Pick<
-    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdenation>,
+    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdenation, TIncludes>,
     | (C extends { baseMethods: { get:          { active: false } } } ? never : 'get')
     | (C extends { baseMethods: { getOrThrow:   { active: false } } } ? never : 'getOrThrow')
     | (C extends { baseMethods: { getList:      { active: false } } } ? never : 'getList')
@@ -861,6 +901,7 @@ export type RepoConfig<T, M extends Prisma.ModelName, SM extends Record<string,
     softRemovekName?: keyof T & string;
     selectModels?: SM;
     defaultSelectModel?: Extract<keyof SM, string>;
+    includeModels?: IncludeModels<M>;
     requiredWhere?: WhereModel<M>;
     defaultOrdenation?: OrdenationModel<M>;
     relations?: RepositoryRelations<T>;
@@ -946,6 +987,12 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
      */
     defaultSelectModel?: string;
 
+    /**
+     * Defines named and reusable include projections.
+     * Similar to selectModels, but resolves Prisma `include` clauses.
+     */
+    includeModels?: IncludeModels<M>;
+
     /**
      * Defines global filters that will be automatically applied to all repository queries.
      * Useful for tenant isolation (multi-tenancy) or base restrictions (e.g., `isActive: true`).

package/dist/VSRepository.js

@@ -35,6 +35,7 @@ class VSRepository {
     pkName;
     softRemovekName;
     selectModels;
+    includeModels;
     defaultSelectModel;
     requiredWhere;
     relations;
@@ -47,6 +48,7 @@ class VSRepository {
         this.pkName = validatedConfig.pkName;
         this.softRemovekName = validatedConfig.softRemovekName;
         this.selectModels = validatedConfig.selectModels;
+        this.includeModels = validatedConfig.includeModels;
         this.defaultSelectModel = validatedConfig.defaultSelectModel;
         this.relations = validatedConfig.relations;
         this.requiredWhere = validatedConfig.requiredWhere;
@@ -162,7 +164,7 @@ class VSRepository {
                         const missingParams = dinamicMethodInfo.whereParams
                             .concat(dinamicMethodInfo.otherParams)
                             .slice(args.length);
-                        throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${buildInstance.tableName}: runtime) Missing parameters: ${missingParams.join(", ")}`);
+                        throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${buildInstance.tableName}: runtime) Missing parameters: ${missingParams.join(", ")}`, "48670");
                     }
                     else if (args.length > dinamicMethodInfo.argsCount) {
                         const optionsArg = args[args.length - 1];

package/dist/internal/resolvers/base-methods.resolve.js

@@ -21,7 +21,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.get.active) {
         instance.get = async (pk, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.get,
@@ -41,7 +41,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.getOrThrow.active) {
         instance.getOrThrow = async (pk, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.getOrThrow,
@@ -64,7 +64,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.getList.active) {
         instance.getList = async (pks, options) => {
             if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.getList,
@@ -84,7 +84,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.getAll.active) {
         instance.getAll = async (options) => {
             if (options !== undefined && !(0, is_object_validate_1.isObject)(options))
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'options' must be a valid object.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'options' must be a valid object.`, "65706");
             const { pagination, order, ...restOptions } = options ?? {};
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
@@ -107,7 +107,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.remove.active) {
         instance.remove = async (pk, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.remove,
@@ -127,7 +127,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.removeList.active) {
         instance.removeList = async (pks, options) => {
             if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.removeList,
@@ -166,7 +166,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.has.active) {
         instance.has = async (pk, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.has,
@@ -187,9 +187,9 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.merge.active) {
         instance.merge = async (pk, obj, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             if (!(0, is_object_validate_1.isObject)(obj)) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`, "65706");
             }
             (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
@@ -273,7 +273,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.softRemove.active && softRemovekName) {
         instance.softRemove = async (pk, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.softRemove,
@@ -295,7 +295,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.softRemoveList.active && softRemovekName) {
         instance.softRemoveList = async (pks, options) => {
             if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.softRemoveList,
@@ -318,7 +318,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.restore.active && softRemovekName) {
         instance.restore = async (pk, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.restore,
@@ -340,7 +340,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.restoreList.active && softRemovekName) {
         instance.restoreList = async (pks, options) => {
             if (!Array.isArray(pks) || pks.some(pk => pk == undefined))
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pks' must an array of primary keys.`, "65706");
             const { db, prismaArgs } = (0, dbAndPrismaArgs_resolve_1.resolveDbAndPrismaArgs)({
                 instance,
                 baseConfig: baseMethods.restoreList,
@@ -363,7 +363,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.save.active) {
         instance.save = async (obj, options) => {
             if (!(0, is_object_validate_1.isObject)(obj)) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`, "65706");
             }
             (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
             const objAny = obj;
@@ -407,7 +407,7 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.saveList.active) {
         instance.saveList = async (objs, options) => {
             if (!Array.isArray(objs) || objs.some(ob => !(0, is_object_validate_1.isObject)(ob))) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'objs' must be an array of valid objects.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'objs' must be an array of valid objects.`, "65706");
             }
             const validatedOptions = (0, method_options_validate_1.validateMethodOptions)(options, instance);
             const argsList = [];
@@ -466,9 +466,9 @@ function resolveBaseMethods(instance, config) {
     if (baseMethods.patch.active) {
         instance.patch = async (pk, obj, options) => {
             if (pk == undefined)
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'pk' must be provided.`, "65706");
             if (!(0, is_object_validate_1.isObject)(obj)) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'obj' must be a valid object.`, "65706");
             }
             (0, obj_with_relations_validate_1.validateObjWithRelations)(instance, obj, relationsKeys);
             const { updatePayload } = (0, create_update_payloads_with_relations_resolve_1.resolveCreateUpdatePayloadsWithRelations)(instance, obj, relationsKeys);
@@ -493,7 +493,7 @@ function resolveBaseMethods(instance, config) {
         instance.patchList = async (tuples, options) => {
             if (!Array.isArray(tuples) ||
                 tuples.some(tuple => tuple[0] == undefined || !(0, is_object_validate_1.isObject)(tuple[1]))) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'tuples' must be a valid array of tuples [pk, obj].`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${tableName}: runtime) 'tuples' must be a valid array of tuples [pk, obj].`, "65706");
             }
             const validatedOptions = (0, method_options_validate_1.validateMethodOptions)(options, instance);
             const argsList = [];

package/dist/internal/resolvers/dbAndPrismaArgs.resolve.js

@@ -6,7 +6,7 @@ const merge_wheres_resolve_1 = require("./merge-wheres.resolve");
 const select_resolve_1 = require("./select.resolve");
 function resolveDbAndPrismaArgs(data) {
     const { baseConfig, instance, options, wherePkValue, withoutSelect, withoutWhere, specificSelect, dataPayload, createPayload, updatePayload, alreadyValidatedOptions, specificWhere, pushWhere, ordenation, pagination, skipDuplicates, forceSeeMode, withOrdenationAndPagination, } = data;
-    const validatedOptions = (alreadyValidatedOptions && options)
+    const validatedOptions = alreadyValidatedOptions && options
         ? options
         : (0, method_options_validate_1.validateMethodOptions)(options, instance);
     const db = validatedOptions.db ?? instance.prisma;
@@ -18,9 +18,15 @@ function resolveDbAndPrismaArgs(data) {
         }, wherePkValue != undefined ? { [instance.pkName]: wherePkValue } : specificWhere, pushWhere, instance.requiredWhere, instance.softRemovekName);
     }
     if (!withoutSelect) {
-        prismaArgs.select =
-            specificSelect ??
-                (0, select_resolve_1.resolveSelect)(instance, validatedOptions.selectModel, baseConfig.defaultSelect);
+        if (specificSelect) {
+            prismaArgs.select = specificSelect;
+        }
+        else if (validatedOptions.includeModel) {
+            prismaArgs.include = instance.includeModels?.[validatedOptions.includeModel];
+        }
+        else {
+            prismaArgs.select = (0, select_resolve_1.resolveSelect)(instance, validatedOptions.selectModel, baseConfig.defaultSelect);
+        }
     }
     if (dataPayload) {
         prismaArgs.data = dataPayload;

package/dist/internal/validation/constructor-config.validate.js

@@ -14,6 +14,7 @@ function validateConstructorConfig(config) {
         pkName: schemas_util_1.stringSchema,
         softRemovekName: schemas_util_1.stringSchema.optional(),
         selectModels: zod_1.default.record(schemas_util_1.stringSchema, schemas_util_1.objectSchema).optional(),
+        includeModels: zod_1.default.record(schemas_util_1.stringSchema, schemas_util_1.objectSchema).optional(),
         defaultSelectModel: schemas_util_1.stringSchema.optional(),
         requiredWhere: schemas_util_1.objectSchema.optional(),
         relations: zod_1.default

package/dist/internal/validation/method-options.validate.js

@@ -8,19 +8,27 @@ const zod_1 = __importDefault(require("zod"));
 const schemas_util_1 = require("../utils/schemas.util");
 const vs_repo_error_1 = require("../errors/vs-repo.error");
 function validateMethodOptions(options, instance) {
-    const optionsSchema = zod_1.default.strictObject({
+    const optionsSchema = zod_1.default
+        .strictObject({
         db: schemas_util_1.objectSchema.optional(),
         selectModel: zod_1.default
             .literal(false)
             .or(zod_1.default.enum(Object.keys(instance.selectModels ?? {})))
             .optional(),
+        includeModel: zod_1.default.enum(Object.keys(instance.includeModels ?? {})).optional(),
         see: zod_1.default.enum(["active", "removed", "all"]).default("active"),
+    })
+        .refine(data => {
+        return !(data.selectModel !== undefined && data.includeModel !== undefined);
+    }, {
+        message: "cannot be provided with 'selectModel'.",
+        path: ["includeModel"],
     });
     const optionsParsed = optionsSchema.safeParse(options ?? {});
     if (!optionsParsed.success) {
         const firstIssue = optionsParsed.error.issues[0];
         const path = firstIssue?.path.length ? firstIssue.path.join(".") : "options";
-        throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) ${path}: ${firstIssue?.message}`);
+        throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) ${path}: ${firstIssue?.message}`, "67542");
     }
     return optionsParsed.data;
 }

package/dist/internal/validation/obj-with-relations.validate.js

@@ -14,23 +14,23 @@ function validateObjWithRelations(instance, obj, relationsKeys) {
         const relation = relations[key];
         if (relation.mode === "mtm" || relation.mode === "otm") {
             if (obj[key] === null) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' cannot be 'null' when relation mode is "mtm" or "otm", use an empty array instead.`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' cannot be 'null' when relation mode is "mtm" or "otm", use an empty array instead.`, "91868");
             }
             else if (!Array.isArray(obj[key]) || obj[key].some(val => !(0, is_object_validate_1.isObject)(val))) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' must be a valid array of objects when relation mode is "mtm" or "otm".`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' must be a valid array of objects when relation mode is "mtm" or "otm".`, "91868");
             }
         }
         else {
             if (obj[key] === null) {
                 if (relation.mode === "oto" && relation.restriction !== "set") {
-                    throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' can be 'null' only if the relation restriction is "set" and mode is "oto".`);
+                    throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' can be 'null' only if the relation restriction is "set" and mode is "oto".`, "91868");
                 }
                 else if (relation.mode === "mto" && !relation.nullable && !relation.nullAble) {
-                    throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' can be 'null' only if the relation 'nullable' is 'true' and mode is "mto".`);
+                    throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' can be 'null' only if the relation 'nullable' is 'true' and mode is "mto".`, "91868");
                 }
             }
             else if (!(0, is_object_validate_1.isObject)(obj[key])) {
-                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' must be a valid object when relation mode is "oto" or "mto".`);
+                throw new vs_repo_error_1.VSRepoRuntimeError(`[VSRepository] (${instance.tableName}: runtime) '${key}' must be a valid object when relation mode is "oto" or "mto".`, "91868");
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.2.9",
+  "version": "1.3.0",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {