vsrepo 1.2.8 → 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/VSRepository.d.ts

@@ -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>]
@@ -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, 
@@ -644,6 +645,7 @@ 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>;
 
 // ─── refactored mapped type — optimized for the TS compiler ──────────────────
 
@@ -657,7 +659,8 @@ type AllBaseMethods<
     TPk       = ExtractPkName<T, Config>,
     TRelations = _Rel<Config>,
     TSoftKey  = _Soft<Config>,
-    I         = PrismaModelInputs<M>
+    I         = PrismaModelInputs<M>,
+    TDefaultOrdenation = _DOrd<Config>
 > = {
     /** Fetches a record by its primary key (PK). */
     get: <S extends keyof TSelects | false = _DS<Config, C, 'get', TSelects>>(
@@ -711,6 +714,11 @@ type AllBaseMethods<
     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>[]>;
@@ -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')
@@ -853,6 +862,7 @@ export type RepoConfig<T, M extends Prisma.ModelName, SM extends Record<string,
     selectModels?: SM;
     defaultSelectModel?: Extract<keyof SM, string>;
     requiredWhere?: WhereModel<M>;
+    defaultOrdenation?: OrdenationModel<M>;
     relations?: RepositoryRelations<T>;
     methods?: Record<string, MethodConfig<M, SM>>;
 };
@@ -942,6 +952,15 @@ export type ValidateRepoConfig<T extends object, M extends Prisma.ModelName, Con
      */
     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 

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.8",
+  "version": "1.2.9",
   "description": "Uma biblioteca de repository pattern para Prisma",
   "homepage": "https://github.com/jaobrabo123/VSRepository#readme",
   "repository": {