Table field name method results ignoring fields in the selector when called inside hook

[adrianbj]

I have so far tested this with the User::changed hook (shown below), but also with Pages::saveReady so it seems to be universal with hooks

$wire->addHookAfter('User::changed(refund_test)', function($event) {
    $u = $event->object;
    bd($u->subscriptions('amount_paid>0, limit=1, sort=-date')->last());
});

will return the last row of the table, completing ignoring the amount_paid>0 condition.

However, this (using in-memory find on the table) works as expected:

$wire->addHookAfter('User::changed(refund_test)', function($event) {
    $u = $event->object;
    bd($u->subscriptions->find('amount_paid>0, limit=1, sort=-date')->last());
});

Outside of a hook, the method approach works as expected.

[adrianbj]

@ryancramerdesign - Claude thinks it has this figured out:

Core's API path for $page->fieldName(selector) flows like this:

1. Page::___callUnknown → PageValues::getFieldValue($page, $key, $selector) (wire/core/PageValues.php:935)
2. → $fieldtype->loadPageFieldFilter($page, $field, $selector)
3. → Fieldtype::___loadPageFieldFilter (wire/core/Fieldtype.php:1208), which:
   $this->setLoadPageFieldFilters($field, $selector);
   $value = $this->loadPageField($page, $field);
   $this->setLoadPageFieldFilters($field, null);
   return $value;

So before loadPageField() is called, the API selector is stashed on the Fieldtype singleton. FieldtypeMulti::getLoadQuery() then reads it back via getLoadPageFieldFilters($field) and applies the WHERE/sort/limit.

The problem is FieldtypeTable::___loadPageField() (around line 2115 of FieldtypeTable.module). Its first guard is:

  if(!$page->id || !$this->wire()->process instanceof WirePageEditor) {                                                                                                             
      return parent::___loadPageField($page, $field);
  }

That early-return preserves whatever the API just set. Everything below assumes "we're in the admin page editor, so build filters/sort from session and $input for the admin Table
UI." Specifically:

  $sessionData = $this->sessionData($page, $field);
  $orderByCols = array();
  ...                                                                                                                                                                               
  if($findRequest === null && isset($sessionData['find'])) {
      $findRequest = $sessionData['find'];           // session 'find' is often '' once set                                                                                         
  }                                                                                                                                                                                 
  if(!$adminAjax || $sortRequest || $findRequest !== null) {
      ...                                                                                                                                                                           
      if($findRequest !== null) {         
          $sessionData['find'] = trim((string) $findRequest, ', ');
          $this->setLoadPageFieldFilters($field, $sessionData['find']);   // <-- clobbers API filter                                                                                
      }
      ...                                                                                                                                                                           
  }                                       
  $value = parent::___loadPageField($page, $field);                                                                                                                                 
  ...                                     
  if($findRequest !== null) $this->setLoadPageFieldFilters($field, null);

When session 'find' has ever been set (even to ''), setLoadPageFieldFilters($field, '') lands at Fieldtype::setLoadPageFieldFilters, which treats empty as null and wipes the API filter:

  // wire/core/Fieldtype.php:1225         
  public function setLoadPageFieldFilters(Field $field, $selectors) {                                                                                                               
      if(empty($selectors)) {
          $this->loadPageFieldFilters = null;                                                                                                                                       

  ...                                                                                                                                                                           

So parent::___loadPageField runs with no filter → all rows of the table come back, and ->last() ends up returning whatever happens to be last in the natural sort. amount_paid>0, limit=1, and sort=-date all silently disappear.

This matches the "universal with hooks" observation: hooks fired during a page edit/save run with $wire->process set to ProcessPageEdit (a WirePageEditor), so the editor-aware branch fires. From a Tracy console / template render, $wire->process is not a WirePageEditor, the early-return is taken, and the API filter survives — exactly the difference reported.

->find('...') works inside the hook because that's a pure in-memory WireArray::find against the already-wakened TableRows — it never goes back through loadPageField.

Proposed fix

In FieldtypeTable.module's ___loadPageField, bail to parent any time the caller has already set a filter — that's the API path and the editor session machinery should not touch
it:

   public function ___loadPageField(Page $page, Field $field) {
  +
  +    // If filters were set by an API caller via loadPageFieldFilter() (e.g. $page->fieldName('selector')),
  +    // honor them and skip the page-editor session/find/sort handling that would otherwise overwrite them.                                                                       
  +    if($this->getLoadPageFieldFilters($field)) {                                                                                                                                 
  +        return parent::___loadPageField($page, $field);                                                                                                                          
  +    }                                                                                                                                                                            
                                          
       // non-paginated/sorted load or outside the context of the page editor                                                                                                       
       if(!$page->id || !$this->wire()->process instanceof WirePageEditor) {
           $result = parent::___loadPageField($page, $field);                                                                                                                       
           return $result;
       }

That preserves all the existing admin-table sort/find/pagination behavior (those code paths reach ___loadPageField without any pre-set filters), and just stops it from stomping on a filter that the ___loadPageFieldFilter wrapper just set.