vsrepo 1.3.4 → 1.3.6

package/dist/DynamicRepository.d.ts

@@ -8,13 +8,14 @@ import {
     ExtractNestedUpdateInput,
     IncludeModel,
     ModelUpsertInput,
-    OrdenationModel,
+    OrderingModel,
     PaginationModel,
     PaginationOptions,
     PrismaModelInputs,
     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>;
 };
 
 /**
@@ -220,12 +224,23 @@ export interface DynamicRepositoryConstructorConfig<T, U extends PrismaModelName
 
     /**
      * Default ordering automatically injected into all queries that accept `orderBy`,
-     * unless the method already has `injectOrdenation` configured or uses the `Ordered` suffix.
+     * unless the method already has `injectOrdering` configured or uses the `Ordered` suffix.
+     *
+     * Useful for ensuring a consistent sort order across the repository without repeating
+     * the `order` argument on every call.
+     */
+    defaultOrdering?: OrderingModel<U>;
+
+    /**
+     * Default ordering automatically injected into all queries that accept `orderBy`,
+     * unless the method already has `injectOrdering` configured or uses the `Ordered` suffix.
      *
      * Useful for ensuring a consistent sort order across the repository without repeating
      * the `order` argument on every call.
+     *
+     * @deprecated Use `defaultOrdering` instead.
      */
-    defaultOrdenation?: OrdenationModel<U>;
+    defaultOrdenation?: OrderingModel<U>;
 
     /**
      * Configures automatic relation management.
@@ -290,7 +305,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 +321,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 +337,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). */
@@ -332,18 +347,18 @@ export declare abstract class DynamicRepository<
             pagination?: PaginationOptions;
             /**
              * Ordering to apply to the query.
-             * When omitted and `defaultOrdenation` is configured on the repository,
+             * When omitted and `defaultOrdering` is configured on the repository,
              * the default ordering is applied automatically.
              */
-            order?: OrdenationModel<UName>;
+            order?: OrderingModel<UName>;
         },
     ): 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 +366,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 +375,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 }>;
 }
 
@@ -381,7 +396,13 @@ export type DynamicMethodConfig<M extends PrismaModelName = PrismaModelName> = {
     fbMode?: "one" | "list";
 
     /** Injects a fixed ordering automatically into the query. */
-    injectOrdenation?: OrdenationModel<M>;
+    injectOrdering?: OrderingModel<M>;
+
+    /**
+     * Injects a fixed ordering automatically into the query.
+     * @deprecated Use `injectOrdering` instead.
+     */
+    injectOrdenation?: OrderingModel<M>;
 
     /** Injects a fixed pagination automatically into the query. */
     injectPagination?: PaginationModel<M>;
@@ -402,7 +423,7 @@ export type DynamicMethodConfig<M extends PrismaModelName = PrismaModelName> = {
  *     `@DynamicMethod()`
  *     declare findOneByEmail: (email: string) => Promise<User | null>;
  *
- *     @DynamicMethod<"User">({ injectOrdenation: { createdAt: "desc" } })
+ *     @DynamicMethod<"User">({ injectOrdering: { createdAt: "desc" } })
  *     declare findByAge: (email: number) => Promise<User[]>;
  * }
  * ```

package/dist/VSRepoError.d.ts

@@ -8,6 +8,24 @@ export type VSRepoErrorType =
     | 'VSREPO_RUNTIME'
     | 'VSREPO_DECORATOR';
 
+/**
+ * Catalog of the internal codes used by `VSRepoRuntimeError`. Each code identifies
+ * a category of runtime failure, so consuming code can discriminate on
+ * `error.code` without parsing the (human-readable) message. See the
+ * "Error handling" section of the README for the full description of each code.
+ */
+export type VSRepoRuntimeErrorCode =
+    /** A required argument is missing or has an invalid shape (e.g. missing `pk`, `pks`/`objs`/`tuples` that aren't an array, or `options`/`obj` that isn't a valid object). */
+    | '65706'
+    /** No record was found for the provided primary key (`getOrThrow` when fetching the base record). */
+    | '20727'
+    /** Validation (zod) of a method's `options`, or of a `@QueryMethod` argument, failed. */
+    | '67542'
+    /** A relation passed to `save`/`patch`/`merge` has an invalid shape for the configured `mode`/`restriction`. */
+    | '91868'
+    /** A dynamic method (`config.methods`) was called with fewer positional arguments than its `where` fields require. */
+    | '48670';
+
 /**
  * Base class for all errors thrown by the VSRepository.
  */
@@ -59,5 +77,7 @@ export declare class VSRepoDecoratorError extends VSRepoError {
  */
 export declare class VSRepoRuntimeError extends VSRepoError {
     readonly type: 'VSREPO_RUNTIME';
-    constructor(message: string, code: string);
+    /** Internal code identifying the category of runtime failure. See {@link VSRepoRuntimeErrorCode}. */
+    readonly code: VSRepoRuntimeErrorCode;
+    constructor(message: string, code: VSRepoRuntimeErrorCode);
 }

package/dist/VSRepository.d.ts

@@ -30,7 +30,7 @@ export type DbTransaction = Prisma.TransactionClient;
  */
 export type ClientOrTransaction = DbClient | DbTransaction;
 
-export * from './VSRepoError';
+export type * from './VSRepoError';
 
 type OrderPattern = {
     [key: string]: 'asc' | 'desc' | { _count: 'asc' | 'desc' } | OrderPattern;
@@ -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>;
 
@@ -396,7 +409,7 @@ type ExtractIncludeModels<Config> = Config extends { includeModels: infer 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;
-type ExtractDefaultOrdenation<Config> = Config extends { defaultOrdenation: infer O } ? O : never;
+type ExtractDefaultOrdering<Config> = Config extends { defaultOrdering: infer O } ? O : Config extends { defaultOrdenation: infer O } ? O : never;
 
 type AggregateMethod<M extends PrismaModelName> = <A extends Prisma.TypeMap['model'][M]['operations']['aggregate']['args']>(
     prismaArgs: A, 
@@ -516,7 +529,13 @@ export type CursorModel<M extends PrismaModelName> = PrismaModelInputs<M>['curso
 /**
  * Type of the `orderBy` object of a Prisma model.
  */
-export type OrdenationModel<M extends PrismaModelName> = PrismaModelInputs<M>['orderByInput'];
+export type OrderingModel<M extends PrismaModelName> = PrismaModelInputs<M>['orderByInput'];
+
+/**
+ * Type of the `orderBy` object of a Prisma model.
+ * @deprecated Use `OrderingModel` instead.
+ */
+export type OrdenationModel<M extends PrismaModelName> = OrderingModel<M>;
 
 /**
  * Pagination options with typed cursor for a Prisma model.
@@ -550,7 +569,12 @@ export type MethodConfig<M extends PrismaModelName, SelectModels = any> = {
      */
     readonly fbMode?: 'one' | 'list';
     /** Injects a fixed ordering automatically into the query. */
-    readonly injectOrdenation?: OrdenationModel<M>;
+    readonly injectOrdering?: OrderingModel<M>;
+    /**
+     * Injects a fixed ordering automatically into the query.
+     * @deprecated Use `injectOrdering` instead.
+     */
+    readonly injectOrdenation?: OrderingModel<M>;
     /** Injects a fixed pagination automatically into the query. */
     readonly injectPagination?: PaginationModel<M>;
     /**
@@ -674,18 +698,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 +817,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>;
@@ -799,7 +825,7 @@ type _Inc<Config> = ExtractIncludeModels<Config>;
 type _Def<Config> = ExtractDefaultSelect<Config>;
 type _Rel<Config> = ExtractRelations<Config>;
 type _Soft<Config> = ExtractSoftRemovekName<Config>;
-type _DOrd<Config> = ExtractDefaultOrdenation<Config>;
+type _DOrd<Config> = ExtractDefaultOrdering<Config>;
 
 // ─── refactored mapped type — optimized for the TS compiler ──────────────────
 
@@ -814,69 +840,69 @@ type AllBaseMethods<
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
     I         = PrismaModelInputs<M>,
-    TDefaultOrdenation = _DOrd<Config>,
+    TDefaultOrdering = _DOrd<Config>,
     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.
-             * When omitted and `defaultOrdenation` is configured on the repository,
+             * When omitted and `defaultOrdering` is configured on the repository,
              * the default ordering is applied automatically.
              */
             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 +911,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 }>;
@@ -912,10 +938,10 @@ type InjectedBaseMethods<
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
     I         = PrismaModelInputs<M>,
-    TDefaultOrdenation = _DOrd<Config>,
+    TDefaultOrdering = _DOrd<Config>,
     TIncludes = _Inc<Config>
 > = Pick<
-    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdenation, TIncludes>,
+    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdering, 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')
@@ -1019,7 +1045,9 @@ export type RepoConfig<T, M extends PrismaModelName, SM extends Record<string, A
     defaultSelectModel?: Extract<keyof SM, string>;
     includeModels?: IncludeModels<M>;
     requiredWhere?: WhereModel<M>;
-    defaultOrdenation?: OrdenationModel<M>;
+    defaultOrdering?: OrderingModel<M>;
+    /** @deprecated Use `defaultOrdering` instead. */
+    defaultOrdenation?: OrderingModel<M>;
     relations?: RepositoryRelations<T>;
     methods?: Record<string, MethodConfig<M, SM>>;
 };
@@ -1117,12 +1145,23 @@ export type ValidateRepoConfig<T extends object, M extends PrismaModelName, Conf
 
     /**
      * Default ordering automatically injected into all queries that accept `orderBy`,
-     * unless the method already has `injectOrdenation` configured or uses the `Ordered` suffix.
+     * unless the method already has `injectOrdering` configured or uses the `Ordered` suffix.
+     *
+     * Useful for ensuring a consistent sort order across the repository without repeating
+     * the `order` argument on every call.
+     */
+    defaultOrdering?: OrderingModel<M>;
+
+    /**
+     * Default ordering automatically injected into all queries that accept `orderBy`,
+     * unless the method already has `injectOrdering` configured or uses the `Ordered` suffix.
      *
      * Useful for ensuring a consistent sort order across the repository without repeating
      * the `order` argument on every call.
+     *
+     * @deprecated Use `defaultOrdering` instead.
      */
-    defaultOrdenation?: OrdenationModel<M>;
+    defaultOrdenation?: OrderingModel<M>;
 
     /**
      * Configures automatic relation management.