vsrepo 1.2.7 → 1.2.9

package/README.md

@@ -31,6 +31,7 @@ O VSRepository permite criar repositories fortemente tipados com:
   - [Configurando os métodos base](#configurando-os-métodos-base)
 - [Select Models](#select-models)
 - [Required Where](#requiredwhere)
+- [Default Ordenation](#default-ordenation)
 - [Opção `see`](#opção-see)
 - [Métodos dinâmicos](#métodos-dinâmicos)
   - [Prefixos disponíveis](#prefixos-disponíveis)
@@ -485,7 +486,47 @@ const usuario = await usuarioRepository.findByEmail("joao@email.com");
 
 ---
 
-## Opção `see`
+## Default Ordenation
+
+`defaultOrdenation` define uma ordenação padrão aplicada automaticamente em todas as queries que aceitam `orderBy`, sem precisar repetir o argumento `order` em cada chamada.
+
+```ts
+const usuarioRepository = setupVSRepo<Usuario, "usuario">()(({
+  tableName: "usuario",
+  pkName: "id",
+  defaultOrdenation: { criadoEm: "desc" },
+}).build(prisma);
+```
+
+Com isso, toda query de listagem já virá ordenada por `criadoEm` decrescente:
+
+```ts
+// Internamente: ORDER BY criadoEm DESC
+const usuarios = await usuarioRepository.getAll();
+
+// Também aplica ao getAll com pagination
+const paginados = await usuarioRepository.getAll({ pagination: { take: 10 } });
+```
+
+**A `defaultOrdenation` é ignorada quando:**
+
+- O método usa o sufixo `Ordered`, `OrderedAndPaginated` ou `PaginatedAndOrdered` — nesses casos o argumento `order` passado na chamada tem prioridade.
+- O método dinâmico tem `injectOrdenation` configurado — a ordenação fixa do método prevalece.
+
+```ts
+methods: {
+  findManyPaginatedAndOrdered: { map: true },         // ordem vem do argumento → defaultOrdenation ignorada
+  findManyByAtivo:             { map: true },         // sem Ordered → defaultOrdenation aplicada
+  findManyByStatus: {
+    map: true,
+    injectOrdenation: { nome: "asc" },                // injectOrdenation → defaultOrdenation ignorada
+  },
+}
+```
+
+> `defaultOrdenation` aceita o mesmo tipo que o `orderBy` nativo do Prisma para o modelo — incluindo arrays de ordenações encadeadas.
+
+---
 
 Quando `softRemovekName` está configurado, todos os métodos base aceitam a opção `see` para controlar a visibilidade de registros soft-deletados:
 
@@ -1005,14 +1046,15 @@ type UsuarioPatchPayload = PatchObject<Prisma.UsuarioUpdateInput, typeof usuario
 
 ```ts
 setupVSRepo<TPayload, TTableName>()({
-  tableName: Uncapitalize<M>;          // Nome da tabela no Prisma
-  pkName: keyof T;                     // Nome da primary key
-  softRemovekName?: keyof T & string;  // Campo DateTime para soft-delete (opcional)
-  selectModels?: SelectModels<M>;      // Projeções de dados nomeadas
-  defaultSelectModel?: keyof SM;       // Select aplicado por padrão
-  requiredWhere?: WhereModel<M>;       // Filtros sempre aplicados
-  relations?: RepositoryRelations<T>;  // Configuração de relações
-  methods?: Record<string, MethodConfig<M, SM>>; // Métodos dinâmicos
+  tableName: Uncapitalize<M>;                     // Nome da tabela no Prisma
+  pkName: keyof T;                                // Nome da primary key
+  softRemovekName?: keyof T & string;             // Campo DateTime para soft-delete (opcional)
+  selectModels?: SelectModels<M>;                 // Projeções de dados nomeadas
+  defaultSelectModel?: keyof SM;                  // Select aplicado por padrão
+  requiredWhere?: WhereModel<M>;                  // Filtros sempre aplicados
+  defaultOrdenation?: OrdenationModel<M>;         // Ordenação padrão para queries sem Ordered/injectOrdenation
+  relations?: RepositoryRelations<T>;             // Configuração de relações
+  methods?: Record<string, MethodConfig<M, SM>>;  // Métodos dinâmicos
 });
 ```
 
@@ -1106,4 +1148,6 @@ Para reportar problemas ou sugerir novas funcionalidades, abra uma **Issue**.
 
 **`softRemovekName` lança erro no build** — O campo informado deve ser do tipo `DateTime` no schema do Prisma. Tipos como `Boolean` ou `String` não são aceitos.
 
-**`saveList`/`patchList` com `db` inválido** — O campo `db` nestes métodos aceita apenas `DbTransaction` (retorno de `prisma.$transaction`), não o cliente principal. Passar o `PrismaClient` diretamente causará comportamento inesperado.
+**`defaultOrdenation` não está sendo aplicada** — Verifique se o método não usa o sufixo `Ordered`, `OrderedAndPaginated` ou `PaginatedAndOrdered`, e se não possui `injectOrdenation` configurado. Ambos têm prioridade sobre a ordenação padrão.
+
+**`saveList`/`patchList` com `db` inválido** — O campo `db` nestes métodos aceita apenas `DbTransaction` (retorno de `prisma.$transaction`), não o cliente principal. Passar o `PrismaClient` diretamente causará comportamento inesperado.

package/dist/VSRepoError.d.ts

@@ -1,5 +1,5 @@
 /**
- * Tipos literais que representam os códigos de erro internos da biblioteca.
+ * Literal types representing the internal error codes of the library.
  */
 export type VSRepoErrorType = 
     | 'VSREPO_CONFIG'
@@ -8,18 +8,18 @@ export type VSRepoErrorType =
     | 'VSREPO_RUNTIME';
 
 /**
- * Classe base para todos os erros lançados pelo Virtual Schema Repository.
+ * Base class for all errors thrown by the VSRepository.
  */
 export declare abstract class VSRepoError extends Error {
-    /** Código interno usado para identificar a categoria do erro. */
+    /** Internal code used to identify the error category. */
     abstract readonly type: VSRepoErrorType;
     
     constructor(message: string, type: VSRepoErrorType);
 }
 
 /**
- * Lançado quando uma configuração inválida ou uma inconsistência de
- * configuração é detectada antes ou durante a inicialização do repositório.
+ * Thrown when an invalid configuration or a configuration inconsistency
+ * is detected before or during repository initialization.
  */
 export declare class VSRepoConfigError extends VSRepoError {
     readonly type: 'VSREPO_CONFIG';
@@ -27,8 +27,8 @@ export declare class VSRepoConfigError extends VSRepoError {
 }
 
 /**
- * Lançado quando a injeção da instância do Prisma falha ou quando o
- * repositório não pode ser finalizado por meio de `.build()`.
+ * Thrown when the Prisma instance injection fails or when the
+ * build configuration is incorrect in the `.build()`.
  */
 export declare class VSRepoBuildError extends VSRepoError {
     readonly type: 'VSREPO_BUILD';
@@ -36,8 +36,8 @@ export declare class VSRepoBuildError extends VSRepoError {
 }
 
 /**
- * Lançado quando ocorre um erro ao injetar novos métodos no repositório
- * por meio de `.extend()`.
+ * Thrown when an error occurs while injecting new methods into the repository
+ * via `.extend()`.
  */
 export declare class VSRepoExtendError extends VSRepoError {
     readonly type: 'VSREPO_EXTEND';
@@ -45,8 +45,8 @@ export declare class VSRepoExtendError extends VSRepoError {
 }
 
 /**
- * Lançado quando operações dinâmicas falham em tempo de execução, como
- * quando argumentos inválidos são passados para métodos.
+ * Thrown when dynamic operations fail at runtime, such as
+ * when invalid arguments are passed to methods.
  */
 export declare class VSRepoRuntimeError extends VSRepoError {
     readonly type: 'VSREPO_RUNTIME';

package/dist/VSRepository.d.ts

@@ -2,8 +2,8 @@ import { Prisma, PrismaClient } from '../generated/prisma/client';
 import { Decimal, JsonValue } from '@prisma/client/runtime/client';
 
 /**
- * Achata uma interseção de tipos em um único objeto,
- * evitando o erro "union type too complex to represent" do TypeScript.
+ * Flattens a type intersection into a single object,
+ * avoiding the TypeScript "union type too complex to represent" error.
  */
 type Simplify<T> = { [K in keyof T]: T[K] } & {};
 
@@ -16,17 +16,17 @@ type WidenField<T> =
     T;
 
 /**
- * Instância completa do Prisma Client usada para construir repositories.
+ * Full Prisma Client instance used to build repositories.
  */
 export type DbClient = PrismaClient;
 
 /**
- * Cliente transacional do Prisma retornado por `prisma.$transaction`.
+ * Prisma transactional client returned by `prisma.$transaction`.
  */
 export type DbTransaction = Prisma.TransactionClient;
 
 /**
- * Aceita tanto o cliente principal do Prisma quanto um cliente de transação.
+ * Accepts either the main Prisma client or a transaction client.
  */
 export type ClientOrTransaction = DbClient | DbTransaction;
 
@@ -37,32 +37,32 @@ type OrderPattern = {
 };
 
 /**
- * Opções de paginação aceitas pelos métodos com sufixo `Paginated`.
+ * Pagination options accepted by methods with the `Paginated` suffix.
  *
- * @template TCursor Tipo do cursor usado pelo modelo Prisma.
+ * @template TCursor Type of the cursor used by the Prisma model.
  */
 export type PaginationOptions<TCursor = unknown> = {
-    /** Quantidade de registros a ignorar. */
+    /** Number of records to skip. */
     skip?: number;
-    /** Quantidade máxima de registros retornados. */
+    /** Maximum number of records to return. */
     take?: number;
-    /** Cursor tipado para paginação baseada em posição. */
+    /** Typed cursor for position-based pagination. */
     cursor?: TCursor;
 };
 
 /**
- * Ordenação aceita pelos métodos do repository.
+ * Ordering accepted by repository methods.
  *
- * Pode ser uma única ordenação ou uma lista de ordenações encadeadas.
+ * Can be a single ordering or a list of chained orderings.
  */
 export type OrderOptions = OrderPattern | OrderPattern[];
 
 /**
- * Modo de visibilidade para registros com soft-delete.
+ * Visibility mode for records with soft-delete.
  *
- * - `"active"` — retorna apenas registros não removidos (padrão).
- * - `"removed"` — retorna apenas registros removidos.
- * - `"all"` — retorna todos os registros, independentemente do status.
+ * - `"active"` — returns only non-deleted records (default).
+ * - `"removed"` — returns only deleted records.
+ * - `"all"` — returns all records regardless of their status.
  */
 export type SeeMode = 'active' | 'removed' | 'all';
 
@@ -195,7 +195,7 @@ type GetCreateManyInput<I> = I extends { createManyInput: infer CM } ? CM : unkn
 type GetUpdateManyInput<I> = I extends { updateManyInput: infer UM } ? UM : unknown;
 type GetWhereInput<I> = I extends { whereInput: infer W } ? NonNullable<W> : unknown;
 type GetCursorInput<I> = I extends { cursorInput: infer C } ? C : unknown;
-type GetOrderByInput<I> = I extends { orderByInput: infer OB } ? OB : OrderOptions;
+type GetOrderByInput<I> = I extends { orderByInput: infer OB } ? NonNullable<OB> : OrderOptions;
 
 type ExtraArgs<M extends string, R extends string, I> = [
     ...(M extends 'upsertBy' ? [update: GetUpdateInput<I>, create: GetCreateInput<I>]
@@ -239,41 +239,41 @@ type CleanFields<R extends string> =
     R extends `${infer F}SkipDuplicates` ? F : R;
 
 /**
- * Opções adicionais aceitas pelos métodos do repository.
+ * Additional options accepted by repository methods.
  *
- * @template S Chaves disponíveis em `selectModels`.
+ * @template S Available keys in `selectModels`.
  */
 export type MethodOptions<S> = {
     /**
-     * Select model a ser aplicado na operação.
+     * Select model to apply to the operation.
      *
-     * @note Use `false` para retornar o payload completo do Prisma, sem select.
+     * @note Use `false` to return the full Prisma payload without a select.
      */
     selectModel?: S | false;
     /**
-     * Cliente Prisma ou transação que deve executar a operação.
+     * Prisma client or transaction to use for the operation.
      */
     db?: ClientOrTransaction;
     /**
-     * Modo de visibilidade para registros com soft-delete.
+     * Visibility mode for records with soft-delete.
      *
-     * Só tem efeito se `softRemovekName` estiver configurado no repository.
+     * Only takes effect if `softRemovekName` is configured on the repository.
      *
-     * - `"active"` — retorna apenas registros não removidos (padrão).
-     * - `"removed"` — retorna apenas registros removidos.
-     * - `"all"` — retorna todos os registros, ignorando o status de remoção.
+     * - `"active"` — returns only non-deleted records (default).
+     * - `"removed"` — returns only deleted records.
+     * - `"all"` — returns all records, ignoring deletion status.
      */
     see?: SeeMode;
 };
 
 /**
- * Versão de `MethodOptions` derivada diretamente de uma instância configurada de `VSRepository`.
+ * Version of `MethodOptions` derived directly from a configured `VSRepository` instance.
  *
- * @template TRepo Instância de `VSRepository` configurada (use `typeof meuVSRepo`).
+ * @template TRepo Configured `VSRepository` instance (use `typeof myVSRepo`).
  *
  * @example
- * const usuarioVSRepo = setupVSRepo<Usuario, "usuario">()(config);
- * type Opts = MethodOptionsModel<typeof usuarioVSRepo>;
+ * const userVSRepo = setupVSRepo<User, "user">()(config);
+ * type Opts = MethodOptionsModel<typeof userVSRepo>;
  */
 export type MethodOptionsModel<TRepo> =
     TRepo extends VSRepository<any, any, infer Config>
@@ -335,7 +335,7 @@ type ExtractPatternBase<K extends string> =
 type MethodFactory<T, M extends Prisma.ModelName, K extends string, SelectModels, DefaultSelect extends keyof SelectModels | false, I, MethodConf> = 
     K extends `findWhere${string}`
         ? {
-            /** @deprecated Use findOneWhere em seu lugar. */
+            /** @deprecated Use findOneWhere instead. */
             <S extends keyof SelectModels | false = DefaultSelect>(...args: [...ExtractFields<T, CleanFields<ExtractPatternBase<K>>, I>, ...ExtraArgs<GetMappedMethod<K, MethodConf>, ExtractPatternBase<K>, I>, options?: MethodOptions<S>]): Promise<ResolveReturnType<GetMappedMethod<K, MethodConf>, SelectedModel<M, S, SelectModels>>>;
           }
         : MethodFn<GetMappedMethod<K, MethodConf>, T, M, ExtractPatternBase<K>, SelectModels, DefaultSelect, I>;
@@ -349,6 +349,7 @@ type ExtractSelectModels<Config> = Config extends { selectModels: infer SM } ? S
 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 AggregateMethod<M extends Prisma.ModelName> = <A extends Prisma.TypeMap['model'][M]['operations']['aggregate']['args']>(
     prismaArgs: A, 
@@ -377,148 +378,148 @@ type DynamicMethods<T, M extends Prisma.ModelName, Config, I> = Config extends {
     : {};
 
 /**
- * Agrupa os principais tipos de input do Prisma derivados de um modelo.
+ * Groups the main Prisma input types derived from a model.
  *
- * @template M Nome do modelo Prisma.
+ * @template M Prisma model name.
  */
 export type PrismaModelInputs<M extends Prisma.ModelName> = {
-    /** Tipo do argumento `select` usado em consultas do modelo. */
+    /** Type of the `select` argument used in model queries. */
     select: Prisma.TypeMap['model'][M]['operations']['findMany']['args']['select'];
-    /** Tipo do `data` usado em `create`. */
+    /** Type of the `data` used in `create`. */
     createInput: Prisma.TypeMap['model'][M]['operations']['create']['args']['data'];
-    /** Tipo do `data` usado em `createMany`. */
+    /** Type of the `data` used in `createMany`. */
     createManyInput: Prisma.TypeMap['model'][M]['operations']['createMany']['args']['data'];
-    /** Tipo do `data` usado em `update`. */
+    /** Type of the `data` used in `update`. */
     updateInput: Prisma.TypeMap['model'][M]['operations']['update']['args']['data'];
-    /** Tipo do `data` usado em `updateMany`. */
+    /** Type of the `data` used in `updateMany`. */
     updateManyInput: Prisma.TypeMap['model'][M]['operations']['updateMany']['args']['data'];
-    /** Tipo do `where` usado nas buscas do modelo. */
+    /** Type of the `where` used in model queries. */
     whereInput: Prisma.TypeMap['model'][M]['operations']['findMany']['args']['where'];
-    /** Tipo do `orderBy` usado nas buscas do modelo. */
+    /** Type of the `orderBy` used in model queries. */
     orderByInput: Prisma.TypeMap['model'][M]['operations']['findMany']['args']['orderBy'];
-    /** Tipo do cursor usado nas buscas do modelo. */
+    /** Type of the cursor used in model queries. */
     cursorInput: Prisma.TypeMap['model'][M]['operations']['findMany']['args']['cursor'];
-    /** Tipo do payload `create` usado em `upsert`. */
+    /** Type of the `create` payload used in `upsert`. */
     upsertCreateInput: Prisma.TypeMap['model'][M]['operations']['upsert']['args']['create'];
-    /** Tipo do payload `update` usado em `upsert`. */
+    /** Type of the `update` payload used in `upsert`. */
     upsertUpdateInput: Prisma.TypeMap['model'][M]['operations']['upsert']['args']['update'];
 };
 
 /**
- * Tipo do objeto `select` de um modelo Prisma.
+ * Type of the `select` object of a Prisma model.
  */
 export type SelectModel<M extends Prisma.ModelName> = PrismaModelInputs<M>['select'];
 
 /**
- * Mapa de selects nomeados e reutilizáveis para um modelo Prisma.
+ * Map of named, reusable selects for a Prisma model.
  */
 export type SelectModels<M extends Prisma.ModelName> = Record<string, SelectModel<M>>;
 
 /**
- * Tipo do objeto `where` de um modelo Prisma.
+ * Type of the `where` object of a Prisma model.
  */
 export type WhereModel<M extends Prisma.ModelName> = PrismaModelInputs<M>['whereInput'];
 
 /**
- * Tipo do objeto `orderBy` de um modelo Prisma.
+ * Type of the `orderBy` object of a Prisma model.
  */
 export type OrdenationModel<M extends Prisma.ModelName> = PrismaModelInputs<M>['orderByInput'];
 
 /**
- * Opções de paginação com cursor tipado para um modelo Prisma.
+ * Pagination options with typed cursor for a Prisma model.
  */
 export type PaginationModel<M extends Prisma.ModelName> = PaginationOptions<PrismaModelInputs<M>['cursorInput']>;
 
 /**
- * Payload base usado para criar um registro no `save`/`upsert` do modelo.
+ * Base payload used to create a record in the model's `save`/`upsert`.
  */
 export type ModelUpsertInput<M extends Prisma.ModelName> = PrismaModelInputs<M>['upsertCreateInput'];
 
 /**
- * Configuração de um método dinâmico definido em `methods`.
+ * Configuration for a dynamic method defined in `methods`.
  *
- * @template M Nome do modelo Prisma.
- * @template SelectModels Mapa de select models disponíveis no repository.
+ * @template M Prisma model name.
+ * @template SelectModels Map of select models available in the repository.
  */
 export type MethodConfig<M extends Prisma.ModelName, SelectModels = any> = {
-    /** Define se o método será exposto no repository. */
+    /** Defines whether the method will be exposed on the repository. */
     readonly map: boolean;
-    /** Sobrescreve o `defaultSelectModel` apenas para este método. */
+    /** Overrides `defaultSelectModel` for this method only. */
     readonly selectModel?: string | false;
-    /** Controla se o método combina (`extending`) ou sobrescreve (`overwrite`) o `requiredWhere`. */
+    /** Controls whether the method combines (`extending`) or overwrites (`overwrite`) the `requiredWhere`. */
     readonly whereType?: 'overwrite' | 'extending';
-    /** Redireciona a lógica para outro padrão de método válido. */
+    /** Redirects the logic to another valid method pattern. */
     readonly proxyTo?: ValidMethodPatterns;
-    /** Adiciona um `where` extra além do `requiredWhere`. */
+    /** Adds an extra `where` on top of `requiredWhere`. */
     readonly pushWhere?: WhereModel<M>;
     /** 
-     * Define se `findBy` retorna um item (`one`) ou uma lista (`list`).
-     * @deprecated Use `findOneBy` se quiser retornar um único resultado.
+     * Defines whether `findBy` returns a single item (`one`) or a list (`list`).
+     * @deprecated Use `findOneBy` if you want to return a single result.
      */
     readonly fbMode?: 'one' | 'list';
-    /** Injeta uma ordenação fixa automaticamente na query. */
+    /** Injects a fixed ordering automatically into the query. */
     readonly injectOrdenation?: OrdenationModel<M>;
-    /** Injeta uma paginação fixa automaticamente na query. */
+    /** Injects a fixed pagination automatically into the query. */
     readonly injectPagination?: PaginationModel<M>;
 };
 
 type BaseMethodConfig<TSelectKeys extends PropertyKey = string> = {
-    /** Ativa ou desativa o método base no `build`. */
+    /** Enables or disables the base method in the `build`. */
     active?: boolean;
-    /** Select model padrão usado pelo método base. */
+    /** Default select model used by the base method. */
     defaultSelect?: TSelectKeys;
-    /** Ignora o `requiredWhere`. */
+    /** Ignores the `requiredWhere`. */
     ignoreRequiredWhere?: boolean;
 };
 
 /**
- * Configuração aplicada durante o `.build(prisma, config?)`.
+ * Configuration applied during `.build(prisma, config?)`.
  *
- * @template TSelectKeys Chaves válidas de `selectModels`.
+ * @template TSelectKeys Valid keys of `selectModels`.
  */
 export type BuildConfig<TSelectKeys extends PropertyKey = string> = {
     /**
-     * Congela o objeto final do repository com `Object.freeze`.
-     * @deprecated Não tem mais efeito prático na nova versão — o freeze é sempre aplicado.
+     * Freezes the final repository object with `Object.freeze`.
+     * @deprecated No longer has any practical effect in the next version — freeze will be always applied.
      */
     freeze?: boolean;
-    /** Exibe logs internos de funcionamento no console. */
+    /** Prints internal working logs to the console. */
     showWorking?: boolean;
-    /** Personaliza o comportamento dos métodos base automáticos. */
+    /** Customizes the behavior of the automatic base methods. */
     baseMethods?: {
-        /** Configuração do método `get`. */
+        /** Configuration for the `get` method. */
         get?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `getOrThrow`. */
+        /** Configuration for the `getOrThrow` method. */
         getOrThrow?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `getList` (busca por lista de PKs). */
+        /** Configuration for the `getList` method (fetch by list of PKs). */
         getList?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `remove`. */
+        /** Configuration for the `remove` method. */
         remove?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `save`. */
+        /** Configuration for the `save` method. */
         save?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `patch`. */
+        /** Configuration for the `patch` method. */
         patch?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `merge`. */
+        /** Configuration for the `merge` method. */
         merge?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `removeList` (exclusão em lote). Não aceita select. */
+        /** Configuration for the `removeList` method (batch deletion). Does not accept select. */
         removeList?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
-        /** Configuração do método `getAll` (listagem total). */
+        /** Configuration for the `getAll` method (full listing). */
         getAll?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `total` (contagem). Não aceita select. */
+        /** Configuration for the `total` method (count). Does not accept select. */
         total?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
-        /** Configuração do método `has` (verificação de existência). Não aceita select. */
+        /** Configuration for the `has` method (existence check). Does not accept select. */
         has?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
-        /** Configuração do método `saveList` (salvar em lote via transação). */
+        /** Configuration for the `saveList` method (batch save via transaction). */
         saveList?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `patchList` (atualizar em lote via transação). */
+        /** Configuration for the `patchList` method (batch update via transaction). */
         patchList?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `softRemove`. Só existe se `softRemovekName` estiver configurado. */
+        /** Configuration for the `softRemove` method. Only available if `softRemovekName` is configured. */
         softRemove?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `softRemoveList`. Não aceita select. Só existe se `softRemovekName` estiver configurado. */
+        /** Configuration for the `softRemoveList` method. Does not accept select. Only available if `softRemovekName` is configured. */
         softRemoveList?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
-        /** Configuração do método `restore`. Só existe se `softRemovekName` estiver configurado. */
+        /** Configuration for the `restore` method. Only available if `softRemovekName` is configured. */
         restore?: BaseMethodConfig<TSelectKeys>;
-        /** Configuração do método `restoreList`. Não aceita select. Só existe se `softRemovekName` estiver configurado. */
+        /** Configuration for the `restoreList` method. Does not accept select. Only available if `softRemovekName` is configured. */
         restoreList?: Omit<BaseMethodConfig<TSelectKeys>, 'defaultSelect'>;
     };
 };
@@ -541,11 +542,11 @@ type ResolveCurrentReturn<M extends Prisma.ModelName, Models, S, D> =
             ? ([D] extends [never] ? FullModelType<M> : SelectedModel<M, D, Models>)
             : SelectedModel<M, S, Models>;
 
-// ─── helpers reutilizados dentro do tipo mapeado ────────────────────────────
-// ─── tipos de payload para relações ─────────────────────────────────────────
+// ─── helpers reused within the mapped type ───────────────────────────────────
+// ─── relation payload types ──────────────────────────────────────────────────
 
 /**
- * Versão distributiva de `Omit`, preservando unions ao remover propriedades.
+ * Distributive version of `Omit`, preserving unions when removing properties.
  */
 type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 type ExtractUnionProp<T, K extends PropertyKey> = T extends any ? (K extends keyof T ? T[K] : never) : never;
@@ -564,18 +565,18 @@ type RelationPayload<TField, TRelationConfig, M extends Prisma.ModelName, K exte
 type TransformCreatePayload<U, T, M extends Prisma.ModelName, TRelations> =
     Omit<U, keyof TRelations> &
     {
-        // Campos que são OBRIGATÓRIOS nesta ramificação específica da união do Prisma
+        // Fields that are REQUIRED in this specific branch of the Prisma union
         [K in Extract<keyof TRelations, keyof U> as {} extends Pick<U, K> ? never : K]: 
             K extends keyof T ? RelationPayload<T[K], TRelations[K], M, K> : never;
     } &
     {
-        // Campos que são OPCIONAIS nesta ramificação ou que não pertencem originalmente a ela
+        // Fields that are OPTIONAL in this branch or do not originally belong to it
         [K in keyof TRelations as K extends keyof U ? ({} extends Pick<U, K> ? K : never) : K]?: 
             K extends keyof T ? RelationPayload<T[K], TRelations[K], M, K> : never;
     };
 
 /**
- * Payload aceito pelo `save` quando o repository possui relações configuradas.
+ * Payload accepted by `save` when the repository has configured relations.
  */
 type UpsertWithRelations<T, M extends Prisma.ModelName, TRelations> =
     ModelUpsertInput<M> extends infer U
@@ -602,7 +603,7 @@ type RelationUpdatePayload<TField, TRelationConfig, M extends Prisma.ModelName,
       : never;
 
 /**
- * Payload aceito pelo `patch` quando o repository possui relações configuradas.
+ * Payload accepted by `patch` when the repository has configured relations.
  */
 type UpdateWithRelations<T, M extends Prisma.ModelName, TRelations> =
     DistributiveOmit<PrismaModelInputs<M>['updateInput'], keyof TRelations> & {
@@ -610,7 +611,7 @@ type UpdateWithRelations<T, M extends Prisma.ModelName, TRelations> =
     };
 
 /**
- * Extrai o tipo de payload do método `save` a partir de uma instância de VSRepository configurada.
+ * Extracts the payload type of the `save` method from a configured VSRepository instance.
  */
 export type SaveObject<TInput, TRepo> = 
     TRepo extends VSRepository<infer T, infer M, infer Config>
@@ -624,7 +625,7 @@ export type SaveObject<TInput, TRepo> =
         : never;
 
 /**
- * Extrai o tipo de payload do método `patch` a partir de uma instância de VSRepository configurada.
+ * Extracts the payload type of the `patch` method from a configured VSRepository instance.
  */
 export type PatchObject<TInput, TRepo> = 
     TRepo extends VSRepository<infer T, infer M, infer Config>
@@ -644,8 +645,9 @@ type _Sel<Config> = ExtractSelectModels<Config>;
 type _Def<Config> = ExtractDefaultSelect<Config>;
 type _Rel<Config> = ExtractRelations<Config>;
 type _Soft<Config> = ExtractSoftRemovekName<Config>;
+type _DOrd<Config> = ExtractDefaultOrdenation<Config>;
 
-// ─── tipo mapeado refatorado — otimizado para o compilador TS ────────────────
+// ─── refactored mapped type — optimized for the TS compiler ──────────────────
 
 type AllBaseMethods<
     T,
@@ -657,84 +659,90 @@ type AllBaseMethods<
     TPk       = ExtractPkName<T, Config>,
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
-    I         = PrismaModelInputs<M>
+    I         = PrismaModelInputs<M>,
+    TDefaultOrdenation = _DOrd<Config>
 > = {
-    /** Busca um registro pela chave primária (PK). */
+    /** Fetches a record by its primary key (PK). */
     get: <S extends keyof TSelects | false = _DS<Config, C, 'get', TSelects>>(
         pk: _Pk<T, Config>, options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault> | null>;
 
-    /** Busca um registro pela PK e lança `VSRepoRuntimeError` se não encontrado. */
+    /** Fetches a record by PK and throws `VSRepoRuntimeError` if not found. */
     getOrThrow: <S extends keyof TSelects | false = _DS<Config, C, 'getOrThrow', TSelects>>(
         pk: _Pk<T, Config>, options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault>>;
 
-    /** Busca múltiplos registros por uma lista de chaves primárias (PKs). */
+    /** Fetches multiple records by a list of primary keys (PKs). */
     getList: <S extends keyof TSelects | false = _DS<Config, C, 'getList', TSelects>>(
         pks: _Pk<T, Config>[], options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
 
-    /** Remove um registro identificado pela chave primária (PK). */
+    /** Deletes a record identified by its primary key (PK). */
     remove: <S extends keyof TSelects | false = _DS<Config, C, 'remove', TSelects>>(
         pk: _Pk<T, Config>, options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault>>;
 
-    /** Insere ou atualiza (upsert) um registro. */
+    /** Inserts or updates (upsert) a record. */
     save: <S extends keyof TSelects | false = _DS<Config, C, 'save', TSelects>>(
         obj: UpsertWithRelations<T, M, TRelations>, options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault>>;
 
-    /** Salva um array de objetos em uma única transação automática. */
+    /** Saves an array of objects in a single automatic transaction. */
     saveList: <S extends keyof TSelects | false = _DS<Config, C, 'saveList', TSelects>>(
         objs: UpsertWithRelations<T, M, TRelations>[], options?: Omit<MethodOptions<S>, 'db'> & { db?: DbTransaction }
     ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
 
-    /** Atualiza parcialmente (patch) um registro existente pela chave primária (PK). */
+    /** Partially updates (patch) an existing record by its primary key (PK). */
     patch: <S extends keyof TSelects | false = _DS<Config, C, 'patch', TSelects>>(
         pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault>>;
 
-    /** Atualiza parcialmente múltiplos registros via tuplas `[pk, obj]` em transação automática. */
+    /** Partially updates multiple records via `[pk, obj]` tuples in an automatic transaction. */
     patchList: <S extends keyof TSelects | false = _DS<Config, C, 'patchList', TSelects>>(
         tuples: [pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>][], options?: Omit<MethodOptions<S>, 'db'> & { db?: DbTransaction }
     ) => Promise<_Ret<M, TSelects, S, TDefault>[]>;
 
-    /** Busca um registro pela PK e faz deep merge com o objeto fornecido **em memória**. */
+    /** Fetches a record by PK and deep-merges it with the provided object **in memory**. */
     merge: <S extends keyof TSelects | false = _DS<Config, C, 'merge', TSelects>>(
         pk: _Pk<T, Config>, obj: UpdateWithRelations<T, M, TRelations>, options?: MethodOptions<S>
     ) => Promise<_Ret<M, TSelects, S, TDefault> | null>;
 
-    /** Remove múltiplos registros pelas suas chaves primárias. */
+    /** Deletes multiple records by their primary keys. */
     removeList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;
 
-    /** Busca todos os registros (respeita `requiredWhere` quando aplicado). */
+    /** Fetches all records (respects `requiredWhere` when set). */
     getAll: <S extends keyof TSelects | false = _DS<Config, C, 'getAll', TSelects>>(
         options?: MethodOptions<S> & {
             pagination?: PaginationOptions<I extends { cursorInput: infer Curs } ? Curs : unknown>;
+            /**
+             * Ordering to apply to the query.
+             * When omitted and `defaultOrdenation` 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>[]>;
 
-    /** Retorna a quantidade total de registros. */
+    /** Returns the total number of records. */
     total: (options?: { db?: ClientOrTransaction; see?: SeeMode }) => Promise<number>;
 
-    /** Verifica se um registro existe pela chave primária (PK). */
+    /** Checks whether a record exists by its primary key (PK). */
     has: (pk: _Pk<T, Config>, options?: { db?: ClientOrTransaction; see?: SeeMode }) => Promise<boolean>;
 
-    /** Marca um registro como removido (soft-delete). */
+    /** Marks a record as deleted (soft-delete). */
     softRemove: <S extends keyof TSelects | false = _DS<Config, C, 'softRemove', TSelects>>(
         pk: _Pk<T, Config>, options?: Omit<MethodOptions<S>, 'see'>
     ) => Promise<_Ret<M, TSelects, S, TDefault>>;
 
-    /** Marca múltiplos registros como removidos (soft-delete) em lote. */
+    /** Marks multiple records as deleted (soft-delete) in batch. */
     softRemoveList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;
 
-    /** Restaura um registro marcado como removido (soft-delete). */
+    /** Restores a record previously marked as deleted (soft-delete). */
     restore: <S extends keyof TSelects | false = _DS<Config, C, 'restore', TSelects>>(
         pk: _Pk<T, Config>, options?: Omit<MethodOptions<S>, 'see'>
     ) => Promise<_Ret<M, TSelects, S, TDefault>>;
 
-    /** Restaura múltiplos registros marcados como removidos (soft-delete) em lote. */
+    /** Restores multiple records previously marked as deleted (soft-delete) in batch. */
     restoreList: (pks: _Pk<T, Config>[], options?: { db?: ClientOrTransaction }) => Promise<{ count: number }>;
 };
 
@@ -748,9 +756,10 @@ type InjectedBaseMethods<
     TPk       = ExtractPkName<T, Config>,
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
-    I         = PrismaModelInputs<M>
+    I         = PrismaModelInputs<M>,
+    TDefaultOrdenation = _DOrd<Config>
 > = Pick<
-    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I>,
+    AllBaseMethods<T, M, Config, C, TSelects, TDefault, TPk, TRelations, TSoftKey, I, TDefaultOrdenation>,
     | (C extends { baseMethods: { get:          { active: false } } } ? never : 'get')
     | (C extends { baseMethods: { getOrThrow:   { active: false } } } ? never : 'getOrThrow')
     | (C extends { baseMethods: { getList:      { active: false } } } ? never : 'getList')
@@ -772,56 +781,56 @@ type InjectedBaseMethods<
 
 
 /**
- * Configuração de relação para One-to-Many ou Many-to-Many.
+ * Relation configuration for One-to-Many or Many-to-Many.
  *
- * @template TItem O tipo da entidade relacionada.
+ * @template TItem Type of the related entity.
  */
 export type ManyRelationConfig<TItem> = {
-    /** A chave primária (Primary Key) da entidade relacionada. */
+    /** Primary key of the related entity. */
     pk: keyof TItem;
-    /** Tipo de relação: `otm` (One-to-Many) ou `mtm` (Many-to-Many). */
+    /** Relation type: `otm` (One-to-Many) or `mtm` (Many-to-Many). */
     mode: 'otm' | 'mtm';
-    /** Comportamento de mutação: `set` (substitui tudo) ou `add` (adiciona aos existentes). */
+    /** Mutation behavior: `set` (replaces all) or `add` (appends to existing). */
     restriction: 'set' | 'add';
 };
 
 /**
- * Configuração de relação One-to-One.
+ * One-to-One relation configuration.
  *
- * @template TItem O tipo da entidade relacionada.
+ * @template TItem Type of the related entity.
  */
 export type OneToOneRelationConfig<TItem> = {
-    /** A chave primária (Primary Key) da entidade relacionada. */
+    /** Primary key of the related entity. */
     pk: keyof TItem;
-    /** Tipo de relação: `oto` (One-to-One). */
+    /** Relation type: `oto` (One-to-One). */
     mode: 'oto';
-    /** Comportamento de mutação permitido para salvar. */
+    /** Allowed mutation behavior for saving. */
     restriction: 'set' | 'add';
 };
 
 /**
- * Configuração de relação Many-to-One.
+ * Many-to-One relation configuration.
  *
- * @template TItem O tipo da entidade relacionada.
+ * @template TItem Type of the related entity.
  */
 export type ManyToOneRelationConfig<TItem> = {
-    /** A chave primária (Primary Key) da entidade relacionada. */
+    /** Primary key of the related entity. */
     pk: keyof TItem;
-    /** Tipo de relação: `mto` (Many-to-One). */
+    /** Relation type: `mto` (Many-to-One). */
     mode: 'mto';
-    /** Comportamento de mutação permitido para salvar. */
+    /** Allowed mutation behavior for saving. */
     restriction: 'set' | 'add';
     /**
-     * Habilita a possibilidade de desvincular a relação, tornando a chave estrangeira nula.
-     * @deprecated Use `nullable` (com letras minúsculas) em vez de `nullAble`.
+     * Enables the ability to unlink the relation, setting the foreign key to null.
+     * @deprecated Use `nullable` (lowercase) instead of `nullAble`.
      */
     nullAble?: boolean;
-    /** Habilita a possibilidade de desvincular a relação, tornando a chave estrangeira nula. */
+    /** Enables the ability to unlink the relation, setting the foreign key to null. */
     nullable?: boolean;
 };
 
 /**
- * Infere automaticamente a configuração de relação possível a partir de um campo.
+ * Automatically infers the possible relation configuration from a field.
  */
 export type ExtractRelationConfig<TField> = NonNullable<TField> extends infer NonNull
     ? NonNull extends Date | Buffer | Uint8Array | Decimal | JsonValue ? never
@@ -831,7 +840,7 @@ export type ExtractRelationConfig<TField> = NonNullable<TField> extends infer No
     : never;
 
 /**
- * Mapa das relações configuráveis de um tipo de entidade.
+ * Map of configurable relations for an entity type.
  */
 export type RepositoryRelations<T> = {
     [K in keyof T as ExtractRelationConfig<T[K]> extends never ? never : K]?: ExtractRelationConfig<T[K]>;
@@ -840,67 +849,62 @@ export type RepositoryRelations<T> = {
 type AnySelect<M extends Prisma.ModelName> = Prisma.TypeMap['model'][M]['operations']['findMany']['args']['select'];
 
 /**
- * Configuração principal usada em `setupVSRepo<T, M>()(config)`.
+ * Main configuration used in `setupVSRepo<T, M>()(config)`.
  *
- * @template T Tipo da entidade manipulada pelo repository.
- * @template M Nome do modelo Prisma.
- * @template SM Mapa de select models nomeados.
+ * @template T Type of the entity managed by the repository.
+ * @template M Prisma model name.
+ * @template SM Map of named select models.
  */
 export type RepoConfig<T, M extends Prisma.ModelName, SM extends Record<string, AnySelect<M>> = Record<string, AnySelect<M>>> = {
     tableName: Uncapitalize<M>;
     pkName: keyof T;
-    /**
-     * Nome do campo `DateTime` usado para soft-delete.
-     *
-     * Quando configurado, habilita os métodos `softRemove`, `softRemoveList`, `restore` e `restoreList`.
-     * O campo **deve** ser do tipo `DateTime` no schema do Prisma — o VSRepository valida isso no `build`.
-     */
     softRemovekName?: keyof T & string;
     selectModels?: SM;
     defaultSelectModel?: Extract<keyof SM, string>;
     requiredWhere?: WhereModel<M>;
+    defaultOrdenation?: OrdenationModel<M>;
     relations?: RepositoryRelations<T>;
     methods?: Record<string, MethodConfig<M, SM>>;
 };
 
 /**
- * Tipo final retornado por `.build(prisma)`.
+ * Final type returned by `.build(prisma)`.
  *
- * Combina métodos dinâmicos, métodos base e extensões personalizadas.
+ * Combines dynamic methods, base methods, and custom extensions.
  */
 type BuiltRepository<T extends object, M extends Prisma.ModelName, Config extends RepoConfig<T, M, any>, C extends BuildConfig<any> | undefined> = {
     /**
-     * Estende o repository com métodos personalizados sem perder a tipagem.
+     * Extends the repository with custom methods without losing type inference.
      */
     extend<E>(extensionFunc: (repo: BuiltRepository<T, M, Config, C>) => E): BuiltRepository<T, M, Config, C> & E;
 
     /**
-     * Instância do Prisma Client passada no `build`.
+     * The Prisma Client instance passed to `build`.
      */
     readonly prisma: DbClient;
 } & DynamicMethods<T, M, Config, PrismaModelInputs<M>> & InjectedBaseMethods<T, M, Config, C>;
 
 /**
- * Fábrica tipada de repositories baseada na configuração do modelo Prisma.
+ * Typed repository factory based on the Prisma model configuration.
  */
 export declare class VSRepository<T extends object, M extends Prisma.ModelName, const Config extends RepoConfig<T, M, any> = RepoConfig<T, M, any>> {
-    /** Configuração original informada no `setupVSRepo`. */
+    /** Original configuration provided to `setupVSRepo`. */
     readonly config: Config;
     /**
-     * Cria uma instância configurável de `VSRepository`.
+     * Creates a configurable instance of `VSRepository`.
      */
     constructor(config: Config);
     /**
-     * Constrói o repository final com os métodos base e dinâmicos.
+     * Builds the final repository with base and dynamic methods.
      */
     build<C extends BuildConfig<keyof ExtractSelectModels<Config>>>(prisma: DbClient, config?: C): BuiltRepository<T, M, Config, C>;
     vsrepocache: never;
 }
 
 /**
- * Infere o tipo de um repository já configurado a partir de uma instância de `VSRepository`.
+ * Infers the type of an already-configured repository from a `VSRepository` instance.
  *
- * Também permite informar manualmente o `BuildConfig` e o tipo de extensões.
+ * Also allows manually providing the `BuildConfig` and extensions type.
  */
 export type RepositoryOf<TRepo, C extends BuildConfig<any> | undefined = undefined, E = unknown> =
     TRepo extends VSRepository<infer T, infer M, infer Config>
@@ -908,16 +912,67 @@ export type RepositoryOf<TRepo, C extends BuildConfig<any> | undefined = undefin
         : never;
 
 /**
- * Tipo utilitário usado para validar a configuração de um repository em tempo de compilação.
+ * Utility type used to validate a repository configuration at compile time.
  */
 export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Config> = {
+    /**
+     * Name of the table mapped by Prisma (usually uncapitalized).
+     */
     tableName: Uncapitalize<M>;
+
+    /**
+     * Name of the field that represents the entity's primary key (Primary Key).
+     */
     pkName: keyof T;
+
+    /**
+     * Name of the `DateTime` field used for soft-delete.
+     *
+     * When configured, enables the `softRemove`, `softRemoveList`, `restore`, and `restoreList` methods.
+     * The field **must** be of type `DateTime` in the Prisma schema — VSRepository validates this during `build`.
+     */
     softRemovekName?: keyof T & string;
+
+    /**
+     * Defines named and reusable data projections (selects).
+     * Allows creating different views of the same entity (e.g., `public`, `minimal`, `internal`).
+     */
     selectModels?: SelectModels<M>;
+
+    /**
+     * Defines which select (a key from `selectModels`) will be used automatically
+     * when none is specified in the method call.
+     * It is highly recommended to define it whenever `selectModels` are used.
+     */
     defaultSelectModel?: string;
+
+    /**
+     * Defines global filters that will be automatically applied to all repository queries.
+     * Useful for tenant isolation (multi-tenancy) or base restrictions (e.g., `isActive: true`).
+     */
     requiredWhere?: WhereModel<M>;
+
+    /**
+     * Default ordering automatically injected into all queries that accept `orderBy`,
+     * unless the method already has `injectOrdenation` configured or uses the `Ordered` suffix.
+     *
+     * Useful for ensuring a consistent sort order across the repository without repeating
+     * the `order` argument on every call.
+     */
+    defaultOrdenation?: OrdenationModel<M>;
+
+    /**
+     * Configures automatic relation management.
+     * When configured, allows the `save`, `saveList`, `patch`, and `patchList` methods 
+     * to automatically handle linking, creation, or cascading deletion of related records.
+     */
     relations?: RepositoryRelations<T>;
+
+    /**
+     * Definition of dynamic repository methods.
+     * Behaviors and return types are automatically inferred from the method's name 
+     * (e.g., `findOneByEmail`, `findManyPaginated`) or proxied via the `proxyTo` property.
+     */
     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 })
@@ -926,8 +981,8 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
 };
 
 /**
- * Função para inicializar e configurar o `repository`.
- * As configurações passadas nele são as que serão lidas ao executar o `.build()`.
+ * Function to initialize and configure the `repository`.
+ * The configuration passed here is what will be read when `.build()` is called.
  */
 export declare function setupVSRepo<T extends object, M extends Prisma.ModelName>(): <
     const SM extends Record<string, SelectModel<M>>,

package/dist/VSRepository.js

@@ -39,6 +39,7 @@ class VSRepository {
     requiredWhere;
     relations;
     methods;
+    defaultOrdenation;
     constructor(config) {
         const validatedConfig = (0, constructor_config_validate_1.validateConstructorConfig)(config);
         this.vsrepocache = new Map();
@@ -50,6 +51,7 @@ class VSRepository {
         this.relations = validatedConfig.relations;
         this.requiredWhere = validatedConfig.requiredWhere;
         this.methods = validatedConfig.methods;
+        this.defaultOrdenation = validatedConfig.defaultOrdenation;
     }
     extend(extensionFunc) {
         const extension = (0, extension_validate_1.validateExtension)(extensionFunc, this);
@@ -139,6 +141,7 @@ class VSRepository {
                         updatePayload: dinamicMethodInfo.updateIndex !== undefined
                             ? args.at(dinamicMethodInfo.updateIndex)
                             : undefined,
+                        withOrdenationAndPagination: !dinamicMethodInfo.ignoreOrderByAndPagination,
                     };
                     if (!dinamicMethodInfo.ignoreWhere) {
                         resolveDbAndPrismaArgsData.specificWhere = (0, specific_where_resolve_1.resolveSpecificWhere)(args, dinamicMethodWhereOps.prettyWheres);

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

@@ -92,6 +92,7 @@ function resolveBaseMethods(instance, config) {
                 options: restOptions,
                 pagination,
                 ordenation: order,
+                withOrdenationAndPagination: true,
             });
             const start = showWorking
                 ? (0, logger_util_1.performanceLoggerStart)(tableName, "getAll", prismaArgs)

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

@@ -5,7 +5,7 @@ const method_options_validate_1 = require("../validation/method-options.validate
 const merge_wheres_resolve_1 = require("./merge-wheres.resolve");
 const select_resolve_1 = require("./select.resolve");
 function resolveDbAndPrismaArgs(data) {
-    const { baseConfig, instance, options, wherePkValue, withoutSelect, withoutWhere, specificSelect, dataPayload, createPayload, updatePayload, alreadyValidatedOptions, specificWhere, pushWhere, ordenation, pagination, skipDuplicates, forceSeeMode, } = data;
+    const { baseConfig, instance, options, wherePkValue, withoutSelect, withoutWhere, specificSelect, dataPayload, createPayload, updatePayload, alreadyValidatedOptions, specificWhere, pushWhere, ordenation, pagination, skipDuplicates, forceSeeMode, withOrdenationAndPagination, } = data;
     const validatedOptions = (alreadyValidatedOptions && options)
         ? options
         : (0, method_options_validate_1.validateMethodOptions)(options, instance);
@@ -31,13 +31,15 @@ function resolveDbAndPrismaArgs(data) {
     if (updatePayload) {
         prismaArgs.update = updatePayload;
     }
-    if (ordenation) {
-        prismaArgs.orderBy = ordenation;
-    }
-    if (pagination) {
-        prismaArgs.skip = pagination.skip;
-        prismaArgs.take = pagination.take;
-        prismaArgs.cursor = pagination.cursor;
+    if (withOrdenationAndPagination) {
+        if (instance.defaultOrdenation || ordenation) {
+            prismaArgs.orderBy = ordenation ?? instance.defaultOrdenation;
+        }
+        if (pagination) {
+            prismaArgs.skip = pagination.skip;
+            prismaArgs.take = pagination.take;
+            prismaArgs.cursor = pagination.cursor;
+        }
     }
     if (skipDuplicates !== undefined) {
         prismaArgs.skipDuplicates = skipDuplicates;

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

@@ -37,6 +37,7 @@ function validateConstructorConfig(config) {
             injectPagination: schemas_util_1.objectSchema.optional(),
         }))
             .optional(),
+        defaultOrdenation: schemas_util_1.objectSchema.or(zod_1.default.array(schemas_util_1.objectSchema)).optional(),
     })
         .superRefine((config, ctx) => {
         if (config.defaultSelectModel && !config.selectModels?.[config.defaultSelectModel]) {

package/package.json

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