Inherit from an instance of CursorPaginator

[pimeo]

Hi.

I post my message here because it's more an evolution than a bug.

Most of apis i'm developing use pagination system but not use the next and previous pagination urls attributes. Pagination datas are passed to a json body contents including page and per_page attributes. In order to do not display theses attributes, I must extend the LengthAwarePaginator in my application and rewrite the toArray method (exemple above). And once I have fetched my records using paginate method, I recreate a new instance with own extended LengthAwarePaginator class and send it as response. Maybe it's not a pretty solution in the Laravel best practises but in my case, for security reasons, I have installed from Illuminate repositories only packages I need to run my application (my ecosystem is also a little bit different from a standard Laravel application). It works well in this way.

Example of my "extended" LengthAwarePaginator class:

<?php

namespace App\Extensions;

use Illuminate\Pagination\LengthAwarePaginator as IlluminateLengthAwarePaginator;

class LengthAwarePaginator extends IlluminateLengthAwarePaginator
{

  /**
   * Get the instance as an array.
   *
   * @return array
   */
  public function toArray()
  {
    return [
      'current_page' => $this->currentPage(),
      'data' => $this->items->toArray(),
      'from' => $this->firstItem(),
      'last_page' => $this->lastPage(),
      'per_page' => $this->perPage(),
      'to' => $this->lastItem(),
      'total' => $this->total(),
    ];
  }
}

Yesterday, I tried to do the same thing with created my own inherited CursorPaginator class :

<?php

namespace App\Extensions;

use Illuminate\Pagination\CursorPaginator as IlluminateCursorPaginator;

class CursorPaginator extends IlluminateCursorPaginator
{

  /**
   * Get the instance as an array.
   *
   * @return array
   */
  public function toArray()
  {
    $nextCursor = $this->nextCursor();
    $nextCursorHashed = false === is_null($nextCursor) ? $nextCursor->encode() : null;
    $previousCursor = $this->previousCursor();
    $previousCursorHashed = false === is_null($previousCursor) ? $previousCursor->encode() : null;
    return [
      'data' => $this->items->toArray(),
      'per_page' => $this->perPage(),
      'next_cursor' => $nextCursorHashed,
      'previous_cursor' => $previousCursorHashed,
    ];
  }
}

In order to return an formatted array like this :

array (
  'data' => 
  array (
    0 => 
    array (
      'title' => 'Aile droite batiment C',
      'created_at' => '2022-11-21T15:24:33.000000Z',
    ),
    1 => 
    array (
      'title' => 'Aile gauche batiment A - Groupe supprimé',
      'created_at' => '2022-11-21T15:24:33.000000Z',
    ),
  ),
  'per_page' => 2,
  'next_cursor' => "eyJ0aXRsZSI6IkFpbGUgZHJvaXRlIGJhdGltZW50IEMiLCJfcG9pbnRzVG9OZXh0SXRlbXMiOnRydWV9",
  'previous_cursor' => NULL,
)%             

Extending this class is possible but when it's time to instanciate my extended CursorPaginator class from the original, I lost next and previous cursors. That's due to the setItems method in constructor which overrides the $items property by removing items from per page property.

Actual behavior:

1. Fetched datas (2 items fetched / 2 items per page / 10 total records in database / this is the first page (no cursor) )
2. Illuminate CursorPaginator new instance (2 items)
3. Items are filtered by per page attribute (2 items, 1 next cursor)
4. Create a new CursorPaginator instance from the previous one (2 items)
   • use methods items, perPage, cursor et getOptions methods to create the new instance.
5. Items are filtered by per page attribute (2 items, no next cursor)

Expected behavior:

1. Fetched datas (2 items fetched / 2 items per page / 10 total records in database / this is the first page (no cursor) )
2. Illuminate CursorPaginator new instance (2 original items, 2 items)
3. Items are filtered by per page attribute (2 original items, 2 items, 1 next cursor)
4. Create a new CursorPaginator instance from the previous one (2 original items)
   • use methods **getOriginalItemsCollection**, perPage, cursor et getOptions methods to create the new instance.
5. Items are filtered by per page attribute (2 original items, 2 items, 1 next cursor)

The expected behavior needs to make changes to the CursorPaginator class:

• store the original items (in a collection by example)
• create an accessor to get the items collection

This is the edited Illuminate CursorPaginator instance (my code uses illuminate pagination v8.83.5 at this moment):

<?php

namespace Illuminate\Pagination;

use ArrayAccess;
use Countable;
use Illuminate\Contracts\Pagination\CursorPaginator as PaginatorContract;
use Illuminate\Contracts\Support\Arrayable;
use Illuminate\Contracts\Support\Jsonable;
use Illuminate\Support\Collection;
use IteratorAggregate;
use JsonSerializable;

class CursorPaginator extends AbstractCursorPaginator implements Arrayable, ArrayAccess, Countable, IteratorAggregate, Jsonable, JsonSerializable, PaginatorContract
{
  /**
   * Indicates whether there are more items in the data source.
   *
   * @return bool
   */
  protected $hasMore;

  /**
   * Original items
   *
   * @return Collection
   */
  protected $originalItemsCollection;

  /**
   * Create a new paginator instance.
   *
   * @param  mixed  $items
   * @param  int  $perPage
   * @param  \Illuminate\Pagination\Cursor|null  $cursor
   * @param  array  $options  (path, query, fragment, pageName)
   * @return void
   */
  public function __construct($items, $perPage, $cursor = null, array $options = [])
  {
    $this->options = $options;

    foreach ($options as $key => $value) {
      $this->{$key} = $value;
    }

    $this->perPage = $perPage;
    $this->cursor = $cursor;
    $this->path = $this->path !== '/' ? rtrim($this->path, '/') : $this->path;

    $this->setOriginalItems($items);
    $this->setItems($items);
  }
  
  /**
   * Set original items
   *
   * @param mixed $originalItems
   * @return void
   */
  protected function setOriginalItems($originalItems)
  {
    $this->originalItemsCollection = $originalItems instanceof Collection ? $originalItems : Collection::make($originalItems);
  }

  /**
   * Get the original items
   *
   * @return Collection
   */
  public function getOriginalItemsCollection(): Collection
  {
    return $this->originalItemsCollection;
  }

  /**
   * Set the items for the paginator.
   *
   * @param  mixed  $items
   * @return void
   */
  protected function setItems($items)
  {
    $this->items = $items instanceof Collection ? $items : Collection::make($items);

    $this->hasMore = $this->items->count() > $this->perPage;

    $this->items = $this->items->slice(0, $this->perPage);

    if (!is_null($this->cursor) && $this->cursor->pointsToPreviousItems()) {
      $this->items = $this->items->reverse()->values();
    }
  }

  /**
   * Render the paginator using the given view.
   *
   * @param  string|null  $view
   * @param  array  $data
   * @return \Illuminate\Contracts\Support\Htmlable
   */
  public function links($view = null, $data = [])
  {
    return $this->render($view, $data);
  }

  /**
   * Render the paginator using the given view.
   *
   * @param  string|null  $view
   * @param  array  $data
   * @return \Illuminate\Contracts\Support\Htmlable
   */
  public function render($view = null, $data = [])
  {
    return static::viewFactory()->make($view ?: Paginator::$defaultSimpleView, array_merge($data, [
      'paginator' => $this,
    ]));
  }

  /**
   * Determine if there are more items in the data source.
   *
   * @return bool
   */
  public function hasMorePages()
  {
    return (is_null($this->cursor) && $this->hasMore) ||
      (!is_null($this->cursor) && $this->cursor->pointsToNextItems() && $this->hasMore) ||
      (!is_null($this->cursor) && $this->cursor->pointsToPreviousItems());
  }

  /**
   * Determine if there are enough items to split into multiple pages.
   *
   * @return bool
   */
  public function hasPages()
  {
    return !$this->onFirstPage() || $this->hasMorePages();
  }

  /**
   * Determine if the paginator is on the first page.
   *
   * @return bool
   */
  public function onFirstPage()
  {
    return is_null($this->cursor) || ($this->cursor->pointsToPreviousItems() && !$this->hasMore);
  }

  /**
   * Get the instance as an array.
   *
   * @return array
   */
  public function toArray()
  {
    return [
      'data' => $this->items->toArray(),
      'path' => $this->path(),
      'per_page' => $this->perPage(),
      'next_page_url' => $this->nextPageUrl(),
      'prev_page_url' => $this->previousPageUrl(),
    ];
  }

  /**
   * Convert the object into something JSON serializable.
   *
   * @return array
   */
  #[\ReturnTypeWillChange]
  public function jsonSerialize()
  {
    return $this->toArray();
  }

  /**
   * Convert the object to its JSON representation.
   *
   * @param  int  $options
   * @return string
   */
  public function toJson($options = 0)
  {
    return json_encode($this->jsonSerialize(), $options);
  }
}

And then try to make a new instance, I can write my instructions like this:

// ... fetched results in a cursor paginator instance that is stored in $cursorPaginatorInstance variable.

$newCursorPaginatorInstance = new CursorPaginator(
    $cursorPaginatorInstance->getOriginalItemsCollection(),
    $cursorPaginatorInstance->perPage(),
    $cursorPaginatorInstance->cursor(),
    $cursorPaginatorInstance->getOptions()
)

What do you think about this evolution?
Thank for reading.