Struct OPager 

pub struct OPager<'a, E, C>
where
    E: EntityTrait,
    E::Column: ColumnTrait + Copy,
    C: DBRunner,
{ /* private fields */ }

Minimal fluent builder for Secure + OData pagination.

This builder combines security-scoped queries with OData pagination in a single, ergonomic interface. It enforces tenant isolation and access control while providing cursor-based pagination with filtering and ordering.

Type Parameters

• E: The SeaORM entity type (must implement ScopableEntity)
• C: The secure database capability (e.g. &SecureConn or &SecureTx)

Usage

OPager::<UserEntity, _>::new(db, ctx, db, &FMAP)
  .tiebreaker("id", SortDir::Desc)  // optional, defaults to ("id", Desc)
  .limits(25, 1000)                  // optional, defaults to (25, 1000)
  .fetch(&query, |m| dto_from(m))
  .await

Default Behavior

• Tiebreaker: ("id", SortDir::Desc) - ensures stable pagination
• Limits: { default: 25, max: 1000 } - reasonable defaults for most APIs

Implementations

impl<'a, E, C> OPager<'a, E, C>

where E: EntityTrait, E::Column: ColumnTrait + Copy, C: DBRunner,

pub fn new(scope: &'a AccessScope, conn: &'a C, fmap: &'a FieldMap<E>) -> Self

Construct a new pager over a secured, scoped Select.

Parameters

• scope: Security scope defining access boundaries (tenant/resource)
• conn: Database connection runner for executing queries
• fmap: Field map defining OData field → entity column mappings

Example

let pager = OPager::<UserEntity, _>::new(
    &scope,
    &conn,
    &USER_FIELD_MAP
);

pub fn tiebreaker(self, field: &'a str, dir: SortDir) -> Self

Override the default tiebreaker (“id”, Desc).

The tiebreaker ensures stable, deterministic pagination by providing a final sort key when the primary order has duplicate values.

Parameters

• field: The field name (as defined in the FieldMap) to use as tiebreaker
• dir: Sort direction for the tiebreaker field

Example

pager.tiebreaker("created_at", SortDir::Asc)

pub fn limits(self, default: u64, max: u64) -> Self

Override default/max limits (defaults: 25/1000).

Controls pagination limits:

• default: Used when client doesn’t specify a limit
• max: Maximum limit value (client requests clamped to this)

Parameters

• default: Default page size (if client doesn’t specify)
• max: Maximum allowed page size (requests clamped to this)

Example

pager.limits(10, 100)  // Smaller pages for this endpoint

pub async fn fetch<D, F>( self, q: &ODataQuery, map: F, ) -> Result<Page<D>, ODataError>

where E: ScopableEntity, F: Fn(E::Model) -> D + Copy,

Execute paging and map models to domain DTOs.

This is the terminal operation that:

1. Applies security scope (tenant/resource filtering)
2. Applies OData filter (if present in query)
3. Applies cursor-based pagination
4. Fetches limit+1 rows (to detect “has more”)
5. Maps entity models to domain DTOs
6. Returns a Page<D> with items and pagination metadata

Type Parameters

• D: The domain DTO type (result of mapping)
• F: Mapper function from E::Model to D

Parameters

• q: OData query containing filter, order, cursor, and limit
• map: Function to convert entity models to domain DTOs

Errors

Returns ODataError if:

• Security scope cannot be applied
• OData filter is invalid
• Database query fails
• Cursor is malformed or inconsistent

Example

let page: Page<UserDto> = pager
    .fetch(&odata_query, |model| UserDto {
        id: model.id,
        name: model.name,
        email: model.email,
    })
    .await?;