vsrepo 1.3.3 → 1.3.5

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?: never;
+              includeModel?: never;
+              include?: never;
+              select: RS;
             }
-        : | { selectModel?: S | false; includeModel?: never; include?: never }
-          | { selectModel?: never; includeModel: IM; include?: never }
-          | { selectModel?: never; includeModel?: never; include: RI }
+        : | { 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>;
 
@@ -408,18 +421,47 @@ type GroupByMethod<M extends PrismaModelName> = <A extends Prisma.TypeMap['model
     options?: { db?: ClientOrTransaction }
 ) => Promise<Prisma.Result<PrismaDelegate<M>, A, 'groupBy'>>;
 
+/**
+ * Function type generated for a dynamic method configured with `query` (non-modifying).
+ *
+ * The result of a raw SQL `SELECT` isn't statically known, so the method itself
+ * resolves to `any` by default, but exposes a generic parameter so the caller can
+ * infer/assert the shape of the result: `repo.myRawQuery<User[]>({ args: [...] })`.
+ *
+ * @template TReturn Return type asserted at the call site. Defaults to `any`.
+ */
+type QueryMethodFn = <TReturn = any>(
+    arg: { args: any[]; db?: ClientOrTransaction },
+) => Promise<TReturn>;
+
+/**
+ * Function type generated for a dynamic method configured with `query` and
+ * `modifying: true`.
+ *
+ * Modifying raw queries run through `$executeRawUnsafe` and always resolve to the
+ * number of affected rows, so — unlike `QueryMethodFn` — no generic return type is
+ * exposed here.
+ */
+type QueryMethodModifyingFn = (
+    arg: { args: any[]; db?: ClientOrTransaction },
+) => Promise<number>;
+
 type DynamicMethods<T, M extends PrismaModelName, Config, I> = Config extends { methods: infer Methods }
     ? {
           [K in keyof Methods as Methods[K] extends { map: true } ? K : never]: K extends string
-              ? (Methods[K] extends { proxyTo: infer P extends string } ? P : K) extends infer ResolvedKey
-                  ? ResolvedKey extends 'aggregate'
-                      ? AggregateMethod<M>
-                      : ResolvedKey extends 'groupBy'
-                      ? GroupByMethod<M>
-                      : ResolvedKey extends string
-                      ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K], ExtractIncludeModels<Config>>
+              ? Methods[K] extends { query: { modifying: true } }
+                  ? QueryMethodModifyingFn
+                  : Methods[K] extends { query: infer Q }
+                  ? QueryMethodFn
+                  : (Methods[K] extends { proxyTo: infer P extends string } ? P : K) extends infer ResolvedKey
+                      ? ResolvedKey extends 'aggregate'
+                          ? AggregateMethod<M>
+                          : ResolvedKey extends 'groupBy'
+                          ? GroupByMethod<M>
+                          : ResolvedKey extends string
+                          ? MethodFactory<T, M, ResolvedKey, ExtractSelectModels<Config>, ResolveSelectModel<Methods[K], Config, ExtractSelectModels<Config>>, I, Methods[K], ExtractIncludeModels<Config>>
+                          : never
                       : never
-                  : never
               : never;
       }
     : {};
@@ -524,6 +566,53 @@ export type MethodConfig<M extends PrismaModelName, SelectModels = any> = {
     readonly injectOrdenation?: OrdenationModel<M>;
     /** Injects a fixed pagination automatically into the query. */
     readonly injectPagination?: PaginationModel<M>;
+    /**
+     * Turns this method into a **raw SQL query method**, bypassing name-based parsing
+     * entirely. The method executes the given SQL directly through Prisma, with
+     * parameters injected positionally via the `args` array passed at the call site
+     * (`$1`, `$2`, ... placeholders), so no other option in `MethodConfig` applies
+     * (`selectModels`, `requiredWhere`, `pushWhere`, etc. are all ignored).
+     *
+     * - `modifying: false` (default) runs through `$queryRawUnsafe` and the method
+     *   resolves to `TReturn` (`any` by default), inferable/assertable via a generic
+     *   at the call site.
+     * - `modifying: true` runs through `$executeRawUnsafe` and the method **always**
+     *   resolves to `number` (the count of affected rows).
+     *
+     * @example
+     * ```typescript
+     * methods: {
+     *   findActiveUsersRaw: {
+     *     map: true,
+     *     query: { value: 'SELECT * FROM "user" WHERE active = $1' },
+     *   },
+     *   deactivateUsersOlderThanRaw: {
+     *     map: true,
+     *     query: { value: 'UPDATE "user" SET active = false WHERE "createdAt" < $1', modifying: true },
+     *   },
+     * }
+     *
+     * // Uso:
+     * const users = await repo.findActiveUsersRaw<User[]>({ args: [true] });
+     * const affected = await repo.deactivateUsersOlderThanRaw({ args: [cutoffDate] });
+     * ```
+     */
+    readonly query?: {
+        /**
+         * Raw SQL statement to execute. Use positional placeholders (`$1`, `$2`, ...)
+         * for the values passed in `args`, never string-interpolate the values
+         * directly, or you'll re-introduce the SQL injection risk this API exists to avoid.
+         */
+        readonly value: string;
+        /**
+         * When `true`, executes via `$executeRawUnsafe` and the method always resolves
+         * to `number` (rows affected). When `false`/omitted, executes via
+         * `$queryRawUnsafe` and the method resolves to `TReturn` (`any` by default).
+         *
+         * @default false
+         */
+        readonly modifying?: boolean;
+    };
 };
 
 type BaseMethodConfig<TSelectKeys extends PropertyKey = string> = {
@@ -598,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 ──────────────────────────────────────────────────
@@ -715,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>;
@@ -742,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.
@@ -800,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>;
@@ -809,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 }>;
@@ -1062,7 +1153,14 @@ export type ValidateRepoConfig<T extends object, M extends PrismaModelName, Conf
      */
     methods?: {
         [K in keyof (Config extends { methods: infer Meth } ? Meth : {})]: K extends string
-            ? MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> & (K extends ValidMethodPatterns ? {} : { proxyTo: ValidMethodPatterns })
+            ? MethodConfig<M, Config extends { selectModels: infer SM } ? SM : any> &
+              (K extends ValidMethodPatterns
+                  ? {}
+                  : (Config extends { methods: infer Meth }
+                        ? (K extends keyof Meth ? Meth[K] : never)
+                        : never) extends { query: any }
+                    ? {}
+                    : { proxyTo: ValidMethodPatterns })
             : never;
     };
 };

package/dist/VSRepository.js

@@ -29,6 +29,7 @@ const pretty_wheres_resolve_1 = require("./internal/resolvers/pretty-wheres.reso
 const specific_where_resolve_1 = require("./internal/resolvers/specific-where.resolve");
 const dbAndPrismaArgs_resolve_1 = require("./internal/resolvers/dbAndPrismaArgs.resolve");
 const method_options_validate_1 = require("./internal/validation/method-options.validate");
+const query_method_arg_validate_1 = require("./internal/validation/query-method-arg.validate");
 class VSRepository {
     vsrepocache;
     tableName;
@@ -82,6 +83,27 @@ class VSRepository {
                 (0, logger_util_1.logger)("Keys to map:", "build", buildInstance.tableName, methodsToMap);
             for (let methodToMap of methodsToMap) {
                 const originalKey = methodToMap;
+                if (methods[originalKey]?.query) {
+                    const modifyingQueryMethod = methods[originalKey].query.modifying;
+                    const valueQueryMethod = methods[originalKey].query.value;
+                    buildInstance[originalKey] = async (arg) => {
+                        const queryArgValidated = (0, query_method_arg_validate_1.validateQueryMethodArg)(arg, buildInstance);
+                        const db = queryArgValidated.db ?? buildInstance.prisma;
+                        const start = showWorking
+                            ? (0, logger_util_1.performanceLoggerStart)(buildInstance.tableName, `Query method: ${originalKey} (Modifying: ${modifyingQueryMethod})`, queryArgValidated.args)
+                            : undefined;
+                        try {
+                            const result = await db[modifyingQueryMethod ? "$executeRawUnsafe" : "$queryRawUnsafe"](valueQueryMethod, ...queryArgValidated.args);
+                            if (showWorking)
+                                (0, logger_util_1.performanceLoggerEnd)(buildInstance.tableName, `Query method: ${originalKey} (Modifying: ${modifyingQueryMethod})`, start);
+                            return result;
+                        }
+                        catch (err) {
+                            throw err;
+                        }
+                    };
+                    continue;
+                }
                 methodToMap = methods[originalKey]?.proxyTo ?? methodToMap;
                 const dinamicMethodInfo = (0, dinamic_method_info_resolve_1.resolveDinamicMethodInfo)(buildInstance, methodToMap, originalKey);
                 const dinamicMethodCustomization = (0, dinamic_method_customization_resolve_1.resolveDinamicMethodCustomization)(buildInstance, dinamicMethodInfo, originalKey);

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

@@ -8,7 +8,7 @@ function DynamicMethod(config) {
     const validatedConfig = config ? (0, dynamic_method_config_validate_1.validateDynamicMethodConfig)(config) : undefined;
     return (target, propertyKey) => {
         const methods = Reflect.getMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, target) ?? [];
-        methods.push(new dynamic_method_metadata_entity_1.DynamicMethodMetadata(propertyKey, validatedConfig?.map ?? true, validatedConfig?.proxyTo, validatedConfig?.whereType, validatedConfig?.pushWhere, validatedConfig?.fbMode, validatedConfig?.injectOrdenation, validatedConfig?.injectPagination));
+        methods.push(new dynamic_method_metadata_entity_1.DynamicMethodMetadata(propertyKey, true, validatedConfig?.proxyTo, validatedConfig?.whereType, validatedConfig?.pushWhere, validatedConfig?.fbMode, validatedConfig?.injectOrdenation, validatedConfig?.injectPagination));
         Reflect.defineMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, methods, target);
     };
 }

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

@@ -0,0 +1,20 @@
+"use strict";
+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 };
+    return (target, propertyKey) => {
+        const methods = Reflect.getMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, target) ?? [];
+        methods.push(new dynamic_method_metadata_entity_1.DynamicMethodMetadata(propertyKey, true, undefined, undefined, undefined, undefined, undefined, undefined, { value, ...validatedConfig }));
+        Reflect.defineMetadata(dinamic_methods_key_constant_1.DINAMIC_METHODS_KEY, methods, target);
+    };
+}

package/dist/internal/entities/dynamic-method-metadata.entity.js

@@ -10,7 +10,8 @@ class DynamicMethodMetadata {
     fbMode;
     injectOrdenation;
     injectPagination;
-    constructor(propertyKey, map, proxyTo, whereType, pushWhere, fbMode, injectOrdenation, injectPagination) {
+    query;
+    constructor(propertyKey, map, proxyTo, whereType, pushWhere, fbMode, injectOrdenation, injectPagination, query) {
         this.propertyKey = propertyKey;
         this.map = map;
         this.proxyTo = proxyTo;
@@ -19,6 +20,7 @@ class DynamicMethodMetadata {
         this.fbMode = fbMode;
         this.injectOrdenation = injectOrdenation;
         this.injectPagination = injectPagination;
+        this.query = query;
     }
 }
 exports.DynamicMethodMetadata = DynamicMethodMetadata;

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/utils/schemas.util.js

@@ -3,11 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.methodSchema = exports.booleanSchema = exports.objectSchema = exports.stringSchema = void 0;
+exports.methodSchema = exports.queryOptionsSchema = exports.booleanSchema = exports.objectSchema = exports.stringSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
 exports.stringSchema = zod_1.default.string().trim().nonempty();
 exports.objectSchema = zod_1.default.looseObject({});
 exports.booleanSchema = zod_1.default.boolean();
+exports.queryOptionsSchema = zod_1.default.strictObject({
+    value: exports.stringSchema,
+    modifying: exports.booleanSchema.default(false),
+});
 exports.methodSchema = zod_1.default.strictObject({
     map: exports.booleanSchema,
     selectModel: exports.stringSchema.or(zod_1.default.literal(false)).optional(),
@@ -17,4 +21,5 @@ exports.methodSchema = zod_1.default.strictObject({
     fbMode: zod_1.default.enum(["one", "list"]).optional(),
     injectOrdenation: exports.objectSchema.or(zod_1.default.array(exports.objectSchema)).optional(),
     injectPagination: exports.objectSchema.optional(),
+    query: exports.queryOptionsSchema.optional(),
 });

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/dist/internal/validation/query-method-arg.validate.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQueryMethodArg = validateQueryMethodArg;
+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 validateQueryMethodArg(arg, instance) {
+    const queryArgSchema = zod_1.default.strictObject({
+        args: zod_1.default.array(zod_1.default.any()),
+        db: schemas_util_1.objectSchema.optional(),
+    });
+    const argParsed = queryArgSchema.safeParse(arg);
+    if (!argParsed.success) {
+        const firstIssue = argParsed.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}`, "67542");
+    }
+    return argParsed.data;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateQueryMethodOptions = validateQueryMethodOptions;
+const zod_1 = __importDefault(require("zod"));
+const vs_repo_error_1 = require("../errors/vs-repo.error");
+const is_object_validate_1 = require("./is-object.validate");
+const schemas_util_1 = require("../utils/schemas.util");
+function validateQueryMethodOptions(options) {
+    if (!(0, is_object_validate_1.isObject)(options)) {
+        throw new vs_repo_error_1.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) 'options' must be a valid object`);
+    }
+    const optionsParsed = zod_1.default
+        .strictObject({ modifying: schemas_util_1.booleanSchema.default(false) })
+        .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.VSRepoDecoratorError(`[VSRepository] (unknown: decorator) ${path}: ${firstIssue?.message}`);
+    }
+    return optionsParsed.data;
+}

package/dist/internal/validation/types/query-method-arg.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/internal/validation/types/query-method-options.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });