To be able to paginate a Collection

[khalyomede]

Currentlty, this is what you have to do to paginate a Collection:

// Get items from query builder, and use Collection methods to finish the job
$items = Item::forUser($user)
  ->when(!empty($request->search), fn (Builder $query): Builder => $query->search($request->search))
  ->get()
  ->groupBy(fn (Item $item): string => $item->scanned ? $item->bar_code : "{$item->name}-{$item->picture}")
  ->sortBy([
    fn (Collection $left, Collection $right): int => $right->count() <=> $left->count(),
  ])
  ->map(fn (Collection $items, string $key): Item => $items->first());

// prepare for the Paginator
$page = Paginator::resolveCurrentPage();

// Build the paginator
$items = app(LengthAwarePaginator::class, [
  "items" => $items->forPage($page, 6),
  "total" => $items->count(),
  "perPage" => 6,
  "currentPage" => $page,
  "options" => [
    "path" => Paginator::resolveCurrentPath(),
  ],
]);

I've lost myself in the web arcanes to figure this one out to be honest.

By naiveness I expected this one to be possible out of the box:

// Paginated from a Collection!
$items = Item::forUser($user)
  ->when(!empty($request->search), fn (Builder $query): Builder => $query->search($request->search))
  ->get()
  ->groupBy(fn (Item $item): string => $item->scanned ? $item->bar_code : "{$item->name}-{$item->picture}")
  ->sortBy([
    fn (Collection $left, Collection $right): int => $right->count() <=> $left->count(),
  ])
  ->map(fn (Collection $items, string $key): Item => $items->first())
  ->paginate(6);

Who also want this one to be possible? 🧐

[mikeydevelops]

This may be a feature and not a bug. Consider converting your code to filter and group using your database, databases are much faster and more efficient at doing that. Try to think about the future and how much load you will be having. I guess by your code, Item will be used almost always. And since you are loading all items for a user in memory, this will hurt performance as time goes on and items are being created.

[khalyomede]

Hi @mikeydevelops, thank you for your reply. I might have been misleading in my description. I think this is not a bug either, more like something I wish it exist.

For your following remark about using Eloquent instead of Collection to group my items, I thought about using the database to group my items, but I want to rely the least possible on custom, MySQL specific group by, as Eloquent does not allow this type of advanced group by. If tomorrow I want to switch to Postgres it will be less painful for me.

For the memory issue, you are right, I will see once my app begins to get a lot of traffic, I might switch to LazyCollection.

If the core team does not thinks Collections should benefit from this feature they will not react to this discuss and it is fine!

Thanks again to react to discuss.

[mikeydevelops]

You can always make a pull request to implement the feature you want. Then you will see the opinion of the devs. I don't think they watch the discussions as often as they tend to the pull requests. While you wait for the pull request, collections support macros, so you can make a macro for paginate.

I straight up copied the paginate method from Illuminate\Database\Query\Builder with minimal changes for Collection.

Here, put that in a service provider:

use Closure;
use Illuminate\Support\Collection;
use Illuminate\Container\Container;
use Illuminate\Pagination\Paginator;
use Illuminate\Pagination\LengthAwarePaginator;

public function register()
{
    $this->registerCollectionMacros();
}

public function registerCollectionMacros()
{
    Collection::macro('paginator', function ($items, $total, $perPage, $currentPage, $options) {
        return Container::getInstance()->makeWith(LengthAwarePaginator::class, compact(
            'items', 'total', 'perPage', 'currentPage', 'options'
        ));
    });

    Collection::macro('paginate', function ($perPage = 15, $columns = null, $pageName = 'page', $page = null) {
        /** @var \Illuminate\Support\Collection $this */
        $page = $page ?: Paginator::resolveCurrentPage($pageName);

        $total = $this->count();

        $perPage = $perPage instanceof Closure ? $perPage($total) : $perPage;

        $results = $total ? $this->forPage($page, $perPage)->only($columns) : collect();

        return $this->paginator($results, $total, $perPage, $page, [
            'path' => Paginator::resolveCurrentPath(),
            'pageName' => $pageName,
        ]);
    });
}

Now you can use it the same as the query builder.

collect(['foo', 'bar', 'yada', 'yada', '...'])
    ->paginate(2);

[khalyomede]

Looks appealing, thank you so much I will implement it as is!

[crissi]

also see: https://github.com/spatie/laravel-collection-macros