Filament v3 Table Pagination: Simple vs Cursor Trade‑offs and Missing Hybrid Mode

Answer to the Three Core Questions

1. Recommended pattern for a conditional paginator

• Use Table::resolvePaginatorUsing() to register a single custom paginator class.
• Inside that class, lazily count rows (e.g., Model::count() or a pre‑cached value) and compare against a configurable threshold.
• If the count is below the threshold, delegate to LengthAwarePaginator (simple pagination). If above, delegate to a custom CursorPaginator that preserves Filament's UI hooks.
• Expose the same perPage options and sorting parameters so the table behaves consistently.

2. Preserving sorting UI with cursor pagination

• Build the query builder with the requested orderBy clauses before applying cursor logic.
• Use a deterministic secondary key (e.g., id) to avoid ambiguous ordering.
• Wrap the cursor paginator in a view model that forwards the sortColumn and sortDirection to the underlying query.
• Because the cursor paginator never uses OFFSET, Filament's column headers still trigger a new query with the updated sort.

3. Future plans for a built‑in hybrid paginator

• As of Filament v3.2 the framework does not ship a hybrid paginator, and community channels indicate no official roadmap for an automatic switch in the next minor release.
• Until a built‑in solution appears, a custom conditional paginator is the only reliable path.

Step‑by‑Step Implementation

1. Create a service provider (e.g., App\Providers\FilamentTablePaginatorProvider) and register it in config/app.php.

   public function boot()
   {
       Filament::serving(function () {
           Table::resolvePaginatorUsing(function () {
               return app(HybridPaginator::class);
           });
       });
   }

2. Implement HybridPaginator.

   class HybridPaginator implements PaginatorContract
   {
       protected int $threshold;
       protected QueryBuilder $query;
       protected array $sort;
   
       public function __construct(int $threshold = 50000)
       {
           $this->threshold = $threshold;
       }
   
       public function paginate(QueryBuilder $query, int $perPage, string $pageName = 'page'): LengthAwarePaginator|CursorPaginator
       {
           $this->query = $query;
           $this->sort = $this->extractSort();
   
           $count = $query->count();
           if ($count <= $this->threshold) {
               return LengthAwarePaginator::resolveUsing($query, $perPage, $pageName);
           }
   
           // Apply deterministic ordering
           $query->orderBy($this->sort['column'], $this->sort['direction']);
           $query->orderBy('id');
   
           return new CustomCursorPaginator($query, $perPage, $pageName);
       }
   
       protected function extractSort(): array
       {
           // Retrieve sort info from Filament's request or state
           // Return ['column' => 'name', 'direction' => 'asc']
       }
   }

3. Define CustomCursorPaginator to extend Filament's CursorPaginator and expose the same sorting UI hooks.

   class CustomCursorPaginator extends CursorPaginator
   {
       public function toArray(): array
       {
           // Ensure the paginator data includes the sort state for the UI
           $data = parent::toArray();
           $data['sort'] = request()->input('sortColumn', 'id');
           $data['direction'] = request()->input('sortDirection', 'asc');
           return $data;
       }
   }

4. Optional: Create a config file (e.g., config/filament/paginator.php) to allow developers to tweak the threshold and other options.

5. Test the implementation with both 10,000 and 200,000 row tables. Verify that:

   • Simple pagination uses OFFSET and COUNT(*) for ≤ 50k rows.
   • Cursor pagination generates a single SELECT with LIMIT and no OFFSET for >50k rows.
   • Sortable column headers trigger the same sort behavior in both modes.
   • Direct page navigation is disabled in cursor mode, as expected.

Assumptions & Uncertainty

• We assume Filament's Table::resolvePaginatorUsing() accepts a closure that returns a paginator instance.
• Future Filament releases might change the paginator interface; keep the custom paginator updated accordingly.
• The threshold value should be tuned per application; a hard‑coded 50k is a starting point.
• No official hybrid paginator exists in Filament v3.x; community discussions suggest no imminent release.

If you have a specific database engine or indexing strategy that might affect cursor performance, let us know so the recommendation can be adjusted.

Summary

Register a single custom paginator via Table::resolvePaginatorUsing() that internally switches between LengthAwarePaginator and a cursor‑based paginator. Preserve sorting UI by applying the sort to the query before cursor logic and exposing the sort state in the paginator's data. Until Filament introduces a built‑in hybrid strategy, this custom approach is the most maintainable solution for large admin tables.