vsrepo 1.3.4 → 1.3.5

package/README.md

@@ -35,6 +35,7 @@ VSRepository lets you create strongly-typed repositories with:
   - [Merge](#merge)
   - [Configuring the base methods](#configuring-the-base-methods)
 - [Select Models](#select-models)
+  - [Raw select (options.select)](#raw-select-optionsselect)
 - [Include Models](#include-models)
   - [Raw include (options.include)](#raw-include-optionsinclude)
 - [Required Where](#required-where)
@@ -104,6 +105,8 @@ npx vsrepo generate \
 
 ```
 generated/vsrepo/
+├── DynamicRepository.ts
+├── DynamicRepository.types.d.ts
 ├── VSRepoError.ts
 ├── VSRepoError.types.d.ts
 ├── VSRepository.ts
@@ -531,6 +534,35 @@ const user = await userRepository.get(id, { selectModel: "minimal" });
 const fullUser = await userRepository.get(id, { selectModel: false });
 ```
 
+### Raw `select` (`options.select`)
+
+Besides `selectModel` (named, pre-configured in `selectModels`), you can pass a raw Prisma `select` directly in the call, without registering it beforehand on the repository.
+
+```ts
+const user = await userRepository.get(id, {
+  select: { id: true, name: true },
+});
+```
+
+`options.select` accepts any valid Prisma `select` for the repository's model — it's fully typed and offers the same autocomplete/validation as calling `prisma.user.findMany({ select: ... })` directly, and the method's return type is narrowed to exactly the fields selected.
+
+**Rules and behavior:**
+
+- **Mutually exclusive with `selectModel`, `includeModel` and `include`.** Only one of the four can be provided per call; the types enforce this — passing more than one is a compile-time error.
+- **Ad hoc, not reusable.** Unlike `selectModel`, it doesn't need to be declared in `selectModels`. Use it for one-off projections that don't justify a named select model.
+- **No `defaultSelectModel` is applied.** When `select` is provided, the default select (`defaultSelectModel`) is ignored and only the raw `select` is sent to Prisma.
+
+```ts
+// CORRECT ✅ — raw select only
+await userRepository.get(id, { select: { id: true, name: true } });
+
+// WRONG ❌ — combining select with selectModel/includeModel/include is not allowed
+await userRepository.get(id, { selectModel: "public", select: { id: true } });
+await userRepository.get(id, { include: { posts: true }, select: { id: true } });
+```
+
+> **When to use `selectModel` vs. `select`:** prefer `selectModel` for projections reused across multiple calls (defined once in `selectModels`); use `select` for specific, occasional projections that don't need a name.
+
 ---
 
 ## Include Models
@@ -1367,6 +1399,8 @@ type OptsModel = MethodOptionsModel<typeof userVSRepo>;
 ```
 
 > The second parameter of `MethodOptions` (`IM`) represents the valid keys of `includeModels`. When provided, `selectModel` and `includeModel` become mutually exclusive in the type — it's not possible to pass both in the same call.
+>
+> `MethodOptions` also accepts two further generic parameters, `RI` and `RS`, for typing raw `include` and raw `select` respectively (both default to `never`, meaning they're not accepted unless explicitly typed): `MethodOptions<"public", "withPosts", "user", IncludeModel<"user">, SelectModel<"user">>`. `MethodOptionsModel`, derived directly from a configured repository, does not expose `RI`/`RS` — use `MethodOptions` directly if you need to type raw `include`/`select` options.
 
 ### Configuration types
 

package/README.pt-BR.md

@@ -35,6 +35,7 @@ O VSRepository permite criar repositórios fortemente tipados com:
   - [Merge](#merge)
   - [Configurando os métodos base](#configurando-os-métodos-base)
 - [Select Models](#select-models)
+  - [Select bruto (options.select)](#select-bruto-optionsselect)
 - [Include Models](#include-models)
   - [Include bruto (options.include)](#include-bruto-optionsinclude)
 - [Required Where](#required-where)
@@ -104,6 +105,8 @@ npx vsrepo generate \
 
 ```
 generated/vsrepo/
+├── DynamicRepository.ts
+├── DynamicRepository.types.d.ts
 ├── VSRepoError.ts
 ├── VSRepoError.types.d.ts
 ├── VSRepository.ts
@@ -531,6 +534,35 @@ const user = await userRepository.get(id, { selectModel: "minimal" });
 const fullUser = await userRepository.get(id, { selectModel: false });
 ```
 
+### Select bruto (`options.select`)
+
+Além do `selectModel` (nomeado, pré-configurado em `selectModels`), você pode passar um `select` bruto do Prisma diretamente na chamada, sem precisar registrá-lo antecipadamente no repositório.
+
+```ts
+const usuario = await usuarioRepository.get(id, {
+  select: { id: true, nome: true },
+});
+```
+
+`options.select` aceita qualquer `select` válido para o modelo Prisma do repositório — é totalmente tipado e oferece o mesmo autocomplete/validação de chamar `prisma.usuario.findMany({ select: ... })` diretamente, e o tipo de retorno do método é restrito exatamente aos campos selecionados.
+
+**Regras e comportamento:**
+
+- **Mutuamente exclusivo com `selectModel`, `includeModel` e `include`.** Apenas um dos quatro pode ser fornecido por chamada; os tipos garantem isso — passar mais de um é um erro em tempo de compilação.
+- **Ad hoc, não reutilizável.** Diferente do `selectModel`, não precisa ser declarado em `selectModels`. Use-o para projeções pontuais que não justificam um select model nomeado.
+- **Nenhum `defaultSelectModel` é aplicado.** Quando `select` é fornecido, o select padrão (`defaultSelectModel`) é ignorado e apenas o `select` bruto é enviado ao Prisma.
+
+```ts
+// CORRETO ✅ — apenas select bruto
+await usuarioRepository.get(id, { select: { id: true, nome: true } });
+
+// ERRADO ❌ — combinar select com selectModel/includeModel/include não é permitido
+await usuarioRepository.get(id, { selectModel: "public", select: { id: true } });
+await usuarioRepository.get(id, { include: { posts: true }, select: { id: true } });
+```
+
+> **Quando usar `selectModel` vs. `select`:** prefira `selectModel` para projeções reutilizadas em várias chamadas (definidas uma vez em `selectModels`); use `select` para projeções específicas e ocasionais que não precisam de um nome.
+
 ---
 
 ## Include Models
@@ -1367,6 +1399,8 @@ type OptsModel = MethodOptionsModel<typeof userVSRepo>;
 ```
 
 > O segundo parâmetro de `MethodOptions` (`IM`) representa as chaves válidas de `includeModels`. Quando informado, `selectModel` e `includeModel` se tornam mutuamente exclusivos no tipo — não é possível passar os dois na mesma chamada.
+>
+> `MethodOptions` também aceita mais dois parâmetros genéricos, `RI` e `RS`, para tipar `include` e `select` brutos respectivamente (ambos com padrão `never`, ou seja, não são aceitos a menos que tipados explicitamente): `MethodOptions<"public", "withPosts", "usuario", IncludeModel<"usuario">, SelectModel<"usuario">>`. O `MethodOptionsModel`, derivado diretamente de um repositório configurado, não expõe `RI`/`RS` — use `MethodOptions` diretamente se precisar tipar as opções de `include`/`select` brutos.
 
 ### Tipos de configuração
 

package/dist/DynamicRepository.d.ts

@@ -15,6 +15,7 @@ import {
     PrismaModelName,
     RepositoryRelations,
     SeeMode,
+    SelectModel,
     WhereModel,
 } from "./VSRepository.d";
 
@@ -157,8 +158,11 @@ export type DynamicMethodOptions<TName extends PrismaModelName = PrismaModelName
      */
     see?: SeeMode;
 
-    /** Raw Prisma `include`. */
+    /** Raw Prisma `include`. Cannot be used together with `select`. */
     include?: IncludeModel<TName>;
+
+    /** Raw Prisma `select`. Cannot be used together with `include`. */
+    select?: SelectModel<TName>;
 };
 
 /**
@@ -290,7 +294,7 @@ export declare abstract class DynamicRepository<
     /** Saves an array of objects in a single automatic transaction. */
     saveList(
         objs: DynamicSaveInput<TEntity, UName, WRelations>[],
-        options?: Omit<DynamicMethodOptions<UName>, "include"> & {
+        options?: Omit<DynamicMethodOptions<UName>, "include" | "select"> & {
             /** Transaction client to use for this operation. */
             db?: DbTransaction;
         },
@@ -306,7 +310,7 @@ export declare abstract class DynamicRepository<
     /** Partially updates multiple records via `[pk, obj]` tuples in an automatic transaction. */
     patchList(
         tuples: [pk: VPKType, obj: DynamicPatchInput<TEntity, UName, WRelations>][],
-        options?: Omit<DynamicMethodOptions<UName>, "include"> & {
+        options?: Omit<DynamicMethodOptions<UName>, "include" | "select"> & {
             /** Transaction client to use for this operation. */
             db?: DbTransaction;
         },
@@ -322,7 +326,7 @@ export declare abstract class DynamicRepository<
     /** Deletes multiple records by their primary keys. */
     removeList(
         pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "include">,
+        options?: Omit<DynamicMethodOptions<UName>, "include" | "select">,
     ): Promise<{ count: number }>;
 
     /** Fetches all records (respects `requiredWhere` when set). */
@@ -340,10 +344,10 @@ export declare abstract class DynamicRepository<
     ): Promise<TEntity[]>;
 
     /** Returns the total number of records. */
-    total(options?: Omit<DynamicMethodOptions<UName>, "include">): Promise<number>;
+    total(options?: Omit<DynamicMethodOptions<UName>, "include" | "select">): Promise<number>;
 
     /** Checks whether a record exists by its primary key (PK). */
-    has(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "include">): Promise<boolean>;
+    has(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "include" | "select">): Promise<boolean>;
 
     /** Marks a record as deleted (soft-delete). */
     softRemove(pk: VPKType, options?: Omit<DynamicMethodOptions<UName>, "see">): Promise<TEntity>;
@@ -351,7 +355,7 @@ export declare abstract class DynamicRepository<
     /** Marks multiple records as deleted (soft-delete) in batch. */
     softRemoveList(
         pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "see" | "include">,
+        options?: Omit<DynamicMethodOptions<UName>, "see" | "include" | "select">,
     ): Promise<{ count: number }>;
 
     /** Restores a record previously marked as deleted (soft-delete). */
@@ -360,7 +364,7 @@ export declare abstract class DynamicRepository<
     /** Restores multiple records previously marked as deleted (soft-delete) in batch. */
     restoreList(
         pks: VPKType[],
-        options?: Omit<DynamicMethodOptions<UName>, "see" | "include">,
+        options?: Omit<DynamicMethodOptions<UName>, "see" | "include" | "select">,
     ): Promise<{ count: number }>;
 }
 

package/dist/VSRepository.d.ts

@@ -228,20 +228,22 @@ type PrecomputedIncludes<M extends PrismaModelName, IncludeModels> = {
     [I in keyof IncludeModels]: Prisma.Result<PrismaDelegate<M>, { include: IncludeModels[I] }, 'findMany'> extends Array<infer U> ? U : never
 };
 
-type SelectedModel<M extends PrismaModelName, S, SelectModels, IM = never, IncludeModels = {}, RI = never> = 
-    [RI] extends [never]
-        ? [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>
-        : Prisma.Result<PrismaDelegate<M>, { include: RI }, 'findMany'> extends Array<infer U> ? U : never;
+type SelectedModel<M extends PrismaModelName, S, SelectModels, IM = never, IncludeModels = {}, RI = never, RS = never> = 
+    [RS] extends [never]
+        ? [RI] extends [never]
+            ? [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>
+            : Prisma.Result<PrismaDelegate<M>, { include: RI }, 'findMany'> extends Array<infer U> ? U : never
+        : Prisma.Result<PrismaDelegate<M>, { select: RS }, 'findMany'> extends Array<infer U> ? U : never;
 
 /**
  * Strips the `Distinct{Fields}` suffix used by read methods (e.g. `findManyDistinctIdadeAndCargo`).
@@ -265,7 +267,7 @@ type CleanFields<R extends string> =
  * @template S Available keys in `selectModels`.
  * @template IM Available keys in `includeModels`.
  */
-export type MethodOptions<S, IM extends PropertyKey = never, M extends PrismaModelName = never, RI = never> = {
+export type MethodOptions<S, IM extends PropertyKey = never, M extends PrismaModelName = never, RI = never, RS = never> = {
     /** Prisma client or transaction to use for the operation. */
     db?: ClientOrTransaction;
     /**
@@ -287,15 +289,25 @@ export type MethodOptions<S, IM extends PropertyKey = never, M extends PrismaMod
               includeModel?: never;
               /** Raw Prisma `include`. Cannot be used together with `selectModel` or `includeModel`. */
               include?: never;
+              /** Raw Prisma `select`. Cannot be used together with `selectModel`, `includeModel` or `include`. */
+              select?: never;
             }
           | {
               selectModel?: never;
               includeModel?: never;
               include: RI;
+              select?: never;
             }
-        : | { selectModel?: S | false; includeModel?: never; include?: never }
-          | { selectModel?: never; includeModel: IM; include?: never }
-          | { selectModel?: never; includeModel?: never; include: RI }
+          | {
+              selectModel?: never;
+              includeModel?: never;
+              include?: never;
+              select: RS;
+            }
+        : | { selectModel?: S | false; includeModel?: never; include?: never; select?: never }
+          | { selectModel?: never; includeModel: IM; include?: never; select?: never }
+          | { selectModel?: never; includeModel?: never; include: RI; select?: never }
+          | { selectModel?: never; includeModel?: never; include?: never; select: RS }
 );
 
 /**
@@ -318,14 +330,15 @@ type MethodOptionsWithInclude<
     TIncludes,
     M extends PrismaModelName,
     RI = never,
-    Excluded extends keyof MethodOptions<S, keyof TIncludes, M, RI> = never
-> = DistributiveOmit<MethodOptions<S, keyof TIncludes, M, RI>, Excluded>
+    RS = never,
+    Excluded extends keyof MethodOptions<S, keyof TIncludes, M, RI, RS> = never
+> = DistributiveOmit<MethodOptions<S, keyof TIncludes, M, RI, RS>, Excluded>
     & ({ includeModel: IM } | { includeModel?: never });
 
 type MethodFn<MethodName extends string, T, M extends PrismaModelName, R extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, IncludeModels> = 
-    <S extends keyof SelectModels | false = DefaultSelect, IM extends keyof IncludeModels = never, RI extends IncludeModel<M> = never>(
-        ...args: [...ExtractFields<T, CleanFields<R>, I>, ...ExtraArgs<MethodName, R, I>, options?: MethodOptionsWithInclude<S, IM, IncludeModels, M, RI>]
-    ) => Promise<ResolveReturnType<MethodName, SelectedModel<M, S, SelectModels, IM, IncludeModels, RI>>>;
+    <S extends keyof SelectModels | false = DefaultSelect, IM extends keyof IncludeModels = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        ...args: [...ExtractFields<T, CleanFields<R>, I>, ...ExtraArgs<MethodName, R, I>, options?: MethodOptionsWithInclude<S, IM, IncludeModels, M, RI, RS>]
+    ) => Promise<ResolveReturnType<MethodName, SelectedModel<M, S, SelectModels, IM, IncludeModels, RI, RS>>>;
 
 type GetMappedMethod<K extends string, MethodConf> = 
     K extends `findBy${string}` ? (MethodConf extends { fbMode: 'one' } ? 'findByOne' : 'findByList') :
@@ -380,9 +393,9 @@ type MethodFactory<T, M extends PrismaModelName, K extends string, SelectModels,
     K extends `findWhere${string}`
         ? {
             /** @deprecated Use findOneWhere instead. */
-            <S extends keyof SelectModels | false = DefaultSelect, IM extends keyof IncludeModels = never, RI extends IncludeModel<M> = never>(
-                ...args: [...ExtractFields<T, CleanFields<ExtractPatternBase<K>>, I>, ...ExtraArgs<GetMappedMethod<K, MethodConf>, ExtractPatternBase<K>, I>, options?: MethodOptionsWithInclude<S, IM, IncludeModels, M, RI>]
-            ): Promise<ResolveReturnType<GetMappedMethod<K, MethodConf>, SelectedModel<M, S, SelectModels, IM, IncludeModels, RI>>>;
+            <S extends keyof SelectModels | false = DefaultSelect, IM extends keyof IncludeModels = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+                ...args: [...ExtractFields<T, CleanFields<ExtractPatternBase<K>>, I>, ...ExtraArgs<GetMappedMethod<K, MethodConf>, ExtractPatternBase<K>, I>, options?: MethodOptionsWithInclude<S, IM, IncludeModels, M, RI, RS>]
+            ): Promise<ResolveReturnType<GetMappedMethod<K, MethodConf>, SelectedModel<M, S, SelectModels, IM, IncludeModels, RI, RS>>>;
           }
         : MethodFn<GetMappedMethod<K, MethodConf>, T, M, ExtractPatternBase<K>, SelectModels, DefaultSelect, I, IncludeModels>;
 
@@ -674,18 +687,20 @@ type ResolveMethodDefaultSelect<Config, C, Method extends keyof NonNullable<Buil
             ? ExtractDefaultSelect<Config> 
             : false;
 
-type ResolveCurrentReturn<M extends PrismaModelName, Models, S, D, IM = never, Includes = {}, RI = never> = 
-    [RI] extends [never]
-        ? [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>
-        : Prisma.Result<PrismaDelegate<M>, { include: RI }, 'findMany'> extends Array<infer U> ? U : never;
+type ResolveCurrentReturn<M extends PrismaModelName, Models, S, D, IM = never, Includes = {}, RI = never, RS = never> = 
+    [RS] extends [never]
+        ? [RI] extends [never]
+            ? [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>
+            : Prisma.Result<PrismaDelegate<M>, { include: RI }, 'findMany'> extends Array<infer U> ? U : never
+        : Prisma.Result<PrismaDelegate<M>, { select: RS }, 'findMany'> extends Array<infer U> ? U : never;
 
 // ─── helpers reused within the mapped type ───────────────────────────────────
 // ─── relation payload types ──────────────────────────────────────────────────
@@ -791,7 +806,7 @@ export type PatchObject<TInput, TRepo> =
 
 
 type _Pk<T, Config> = WidenField<T[ExtractPkName<T, Config> extends keyof T ? ExtractPkName<T, Config> : never]>;
-type _Ret<M extends PrismaModelName, TSelects, S, TDefault, IM = never, TIncludes = {}, RI = never> = ResolveCurrentReturn<M, TSelects, S, TDefault, IM, TIncludes, RI>;
+type _Ret<M extends PrismaModelName, TSelects, S, TDefault, IM = never, TIncludes = {}, RI = never, RS = never> = ResolveCurrentReturn<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>;
 type _DS<Config, C, Method extends keyof NonNullable<BuildConfig['baseMethods']>, TSelects = ExtractSelectModels<Config>> =
     ResolveMethodDefaultSelect<Config, C, Method, TSelects>;
 type _Sel<Config> = ExtractSelectModels<Config>;
@@ -818,56 +833,56 @@ type AllBaseMethods<
     TIncludes = _Inc<Config>
 > = {
     /** Fetches a record by its primary key (PK). */
-    get: <S extends keyof TSelects | false = _DS<Config, C, 'get', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI> | null>;
+    get: <S extends keyof TSelects | false = _DS<Config, C, 'get', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS> | null>;
 
     /** Fetches a record by PK and throws `VSRepoRuntimeError` if not found. */
-    getOrThrow: <S extends keyof TSelects | false = _DS<Config, C, 'getOrThrow', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>>;
+    getOrThrow: <S extends keyof TSelects | false = _DS<Config, C, 'getOrThrow', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>>;
 
     /** Fetches multiple records by a list of primary keys (PKs). */
-    getList: <S extends keyof TSelects | false = _DS<Config, C, 'getList', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pks: _Pk<T, Config>[], options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>[]>;
+    getList: <S extends keyof TSelects | false = _DS<Config, C, 'getList', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pks: _Pk<T, Config>[], options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>[]>;
 
     /** Deletes a record identified by its primary key (PK). */
-    remove: <S extends keyof TSelects | false = _DS<Config, C, 'remove', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>>;
+    remove: <S extends keyof TSelects | false = _DS<Config, C, 'remove', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>>;
 
     /** Inserts or updates (upsert) a record. */
-    save: <S extends keyof TSelects | false = _DS<Config, C, 'save', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        obj: UpsertWithRelations<T, M, TRelations>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>>;
+    save: <S extends keyof TSelects | false = _DS<Config, C, 'save', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        obj: UpsertWithRelations<T, M, TRelations>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>>;
 
     /** Saves an array of objects in a single automatic transaction. */
-    saveList: <S extends keyof TSelects | false = _DS<Config, C, 'saveList', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        objs: UpsertWithRelations<T, M, TRelations>[], options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, 'db'> & { db?: DbTransaction }
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>[]>;
+    saveList: <S extends keyof TSelects | false = _DS<Config, C, 'saveList', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        objs: UpsertWithRelations<T, M, TRelations>[], options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS, 'db'> & { db?: DbTransaction }
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>[]>;
 
     /** Partially updates (patch) an existing record by its primary key (PK). */
-    patch: <S extends keyof TSelects | false = _DS<Config, C, 'patch', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, obj: PatchWithRelations<T, M, TRelations>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>>;
+    patch: <S extends keyof TSelects | false = _DS<Config, C, 'patch', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, obj: PatchWithRelations<T, M, TRelations>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>>;
 
     /** Partially updates multiple records via `[pk, obj]` tuples in an automatic transaction. */
-    patchList: <S extends keyof TSelects | false = _DS<Config, C, 'patchList', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        tuples: [pk: _Pk<T, Config>, obj: PatchWithRelations<T, M, TRelations>][], options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, 'db'> & { db?: DbTransaction }
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>[]>;
+    patchList: <S extends keyof TSelects | false = _DS<Config, C, 'patchList', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        tuples: [pk: _Pk<T, Config>, obj: PatchWithRelations<T, M, TRelations>][], options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS, 'db'> & { db?: DbTransaction }
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>[]>;
 
     /** 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>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI> | null>;
+    merge: <S extends keyof TSelects | false = _DS<Config, C, 'merge', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS> | 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>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI> & {
+    getAll: <S extends keyof TSelects | false = _DS<Config, C, 'getAll', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS> & {
             pagination?: PaginationOptions<I extends { cursorInput: infer Curs } ? Curs : unknown>;
             /**
              * Ordering to apply to the query.
@@ -876,7 +891,7 @@ type AllBaseMethods<
              */
             order?: I extends { orderByInput: infer OB } ? OB : OrderOptions;
         }
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>[]>;
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>[]>;
 
     /** Returns the total number of records. */
     total: (options?: { db?: ClientOrTransaction; see?: SeeMode }) => Promise<number>;
@@ -885,17 +900,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>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, 'see'>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>>;
+    softRemove: <S extends keyof TSelects | false = _DS<Config, C, 'softRemove', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS, 'see'>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>>;
 
     /** 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>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never>(
-        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, 'see'>
-    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI>>;
+    restore: <S extends keyof TSelects | false = _DS<Config, C, 'restore', TSelects>, IM extends keyof TIncludes = never, RI extends IncludeModel<M> = never, RS extends SelectModel<M> = never>(
+        pk: _Pk<T, Config>, options?: MethodOptionsWithInclude<S, IM, TIncludes, M, RI, RS, 'see'>
+    ) => Promise<_Ret<M, TSelects, S, TDefault, IM, TIncludes, RI, RS>>;
 
     /** Restores multiple records previously marked as deleted (soft-delete) in batch. */
     restoreList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;

package/dist/internal/decorators/query-method.decorator.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryMethod = QueryMethod;
 const dinamic_methods_key_constant_1 = require("../constants/dinamic-methods-key.constant");
 const dynamic_method_metadata_entity_1 = require("../entities/dynamic-method-metadata.entity");
+const vs_repo_error_1 = require("../errors/vs-repo.error");
 const query_method_options_validate_1 = require("../validation/query-method-options.validate");
 function QueryMethod(value, options) {
+    if (typeof value !== "string") {
+        throw new vs_repo_error_1.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) 'value' must be a valid string`);
+    }
     const validatedConfig = options
         ? (0, query_method_options_validate_1.validateQueryMethodOptions)(options)
         : { modifying: false };

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

@@ -21,6 +21,9 @@ function resolveDbAndPrismaArgs(data) {
         if (specificSelect) {
             prismaArgs.select = specificSelect;
         }
+        else if (validatedOptions.select) {
+            prismaArgs.select = validatedOptions.select;
+        }
         else if (validatedOptions.includeModel) {
             prismaArgs.include = instance.includeModels?.[validatedOptions.includeModel];
         }

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

@@ -18,12 +18,19 @@ function validateMethodOptions(options, instance) {
         includeModel: zod_1.default.enum(Object.keys(instance.includeModels ?? {})).optional(),
         see: zod_1.default.enum(["active", "removed", "all"]).default("active"),
         include: schemas_util_1.objectSchema.optional(),
+        select: schemas_util_1.objectSchema.optional(),
     })
         .refine(data => {
-        return !(data.selectModel !== undefined && data.includeModel !== undefined);
+        const provided = [
+            data.select !== undefined,
+            data.selectModel !== undefined,
+            data.include !== undefined,
+            data.includeModel !== undefined,
+        ].filter(Boolean).length;
+        return provided <= 1;
     }, {
-        message: "cannot be provided with 'selectModel'.",
-        path: ["includeModel"],
+        message: "'select', 'selectModel', 'include' and 'includeModel' are mutually exclusive — only one can be provided.",
+        path: ["options"],
     });
     const optionsParsed = optionsSchema.safeParse(options ?? {});
     if (!optionsParsed.success) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsrepo",
-  "version": "1.3.4",
+  "version": "1.3.5",
   "description": "A repository pattern library for Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {
@@ -45,7 +45,11 @@
   "scripts": {
     "vsrepo": "node ./scripts/configure-prisma-import.mjs",
     "build": "tsc -p tsconfig.build.json && node ./scripts/copy-types.mjs",
-    "prepack": "pnpm build"
+    "prepack": "pnpm build",
+    "test": "npm run test:typing && npm run test:implementation",
+    "test:implementation": "cross-env NODE_OPTIONS=--experimental-vm-modules jest",
+    "test:implementation:watch": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --watch",
+    "test:typing": "tsc --noEmit -p test/typing/tsconfig.json"
   },
   "keywords": [
     "prisma",
@@ -62,11 +66,16 @@
     "@prisma/client": "^7.8.0"
   },
   "devDependencies": {
+    "@jest/globals": "^30.4.1",
     "@prisma/adapter-pg": "^7.8.0",
     "@prisma/client": "^7.8.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^25.6.0",
+    "cross-env": "^10.1.0",
     "dotenv": "^17.4.2",
+    "jest": "^30.4.2",
     "prisma": "^7.8.0",
+    "ts-jest": "^29.4.12",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3"
   },

package/scripts/configure-prisma-import.mjs

@@ -137,7 +137,8 @@ const tsFiles = [
   VSRepoConfigError as VSRepoConfigErrorRuntime,
   VSRepoBuildError as VSRepoBuildErrorRuntime,
   VSRepoExtendError as VSRepoExtendErrorRuntime,
-  VSRepoRuntimeError as VSRepoRuntimeErrorRuntime
+  VSRepoRuntimeError as VSRepoRuntimeErrorRuntime,
+  VSRepoDecoratorError as VSRepoDecoratorErrorRuntime,
 } from 'vsrepo/VSRepoError';
 
 import type {
@@ -145,14 +146,16 @@ import type {
   VSRepoConfigError as VSRepoConfigErrorType,
   VSRepoBuildError as VSRepoBuildErrorType,
   VSRepoExtendError as VSRepoExtendErrorType,
-  VSRepoRuntimeError as VSRepoRuntimeErrorType
+  VSRepoRuntimeError as VSRepoRuntimeErrorType,
+  VSRepoDecoratorError as VSRepoDecoratorErrorType,
 } from './VSRepoError.types';
 
-export const VSRepoError: typeof VSRepoErrorType = VSRepoErrorRuntime;
-export const VSRepoConfigError: typeof VSRepoConfigErrorType = VSRepoConfigErrorRuntime;
-export const VSRepoBuildError: typeof VSRepoBuildErrorType = VSRepoBuildErrorRuntime;
-export const VSRepoExtendError: typeof VSRepoExtendErrorType = VSRepoExtendErrorRuntime;
-export const VSRepoRuntimeError: typeof VSRepoRuntimeErrorType = VSRepoRuntimeErrorRuntime;
+export const VSRepoError = VSRepoErrorRuntime as typeof VSRepoErrorType;
+export const VSRepoConfigError = VSRepoConfigErrorRuntime as typeof VSRepoConfigErrorType;
+export const VSRepoBuildError = VSRepoBuildErrorRuntime as typeof VSRepoBuildErrorType;
+export const VSRepoExtendError = VSRepoExtendErrorRuntime as typeof VSRepoExtendErrorType;
+export const VSRepoRuntimeError = VSRepoRuntimeErrorRuntime as typeof VSRepoRuntimeErrorType;
+export const VSRepoDecoratorError = VSRepoDecoratorErrorRuntime as typeof VSRepoDecoratorErrorType;
 
 export type * from './VSRepoError.types';
 `,