[5.x] Augmentation performance improvements

src/Auth/AugmentedUser.php

@@ -39,7 +39,7 @@ private function commonKeys()
         ];
     }
 
-    public function get($handle): Value
+    public function get($handle, $fieldtype = null): Value
     {
         if ($handle === 'is_user') {
             return new Value(true, 'is_user', null, $this->data);
@@ -57,7 +57,7 @@ public function get($handle): Value
             return new Value(in_array(Str::after($handle, 'in_'), $this->groups()), $handle, null, $this->data);
         }
 
-        return parent::get($handle);
+        return parent::get($handle, $fieldtype);
     }
 
     protected function roles()

src/Contracts/Data/BulkAugmentable.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Statamic\Contracts\Data;
+
+interface BulkAugmentable
+{
+    public function getAugmentationReferenceKey(): ?string;
+}

src/Data/AbstractAugmented.php

@@ -13,6 +13,7 @@ abstract class AbstractAugmented implements Augmented
     protected $data;
     protected $blueprintFields;
     protected $relations = [];
+    protected $isSelecting = false;
 
     public function __construct($data)
     {
@@ -29,38 +30,66 @@ public function except($keys)
         return $this->select(array_diff($this->keys(), Arr::wrap($keys)));
     }
 
-    public function select($keys = null)
+    public function select($keys = null, $fields = null)
     {
         $arr = [];
 
+        if (! $fields) {
+            $fields = $this->blueprintFields();
+        }
+
         $keys = $this->filterKeys(Arr::wrap($keys ?: $this->keys()));
 
+        $this->isSelecting = true;
+
         foreach ($keys as $key) {
-            $arr[$key] = $this->get($key);
+            $arr[$key] = (new TransientValue(null, $key, null))->withAugmentationReferences($this, $fields->get($key));
         }
 
+        $this->isSelecting = false;
+
         return (new AugmentedCollection($arr))->withRelations($this->relations);
     }
 
     abstract public function keys();
 
-    public function get($handle): Value
+    public function getAugmentedMethodValue($method)
+    {
+        if ($this->methodExistsOnThisClass($method)) {
+            return $this->$method();
+        }
+
+        return $this->data->$method();
+    }
+
+    protected function adjustFieldtype($handle, $fieldtype)
+    {
+        if ($this->isSelecting || $fieldtype !== null) {
+            return $fieldtype;
+        }
+
+        return $this->getFieldtype($handle);
+    }
+
+    public function get($handle, $fieldtype = null): Value
     {
         $method = Str::camel($handle);
 
         if ($this->methodExistsOnThisClass($method)) {
-            $value = $this->$method();
-
-            return $value instanceof Value
-                ? $value
-                : new Value($value, $method, null, $this->data);
+            $value = $this->wrapInvokable($method, true, $this, $handle, $fieldtype);
+        } elseif (method_exists($this->data, $method) && collect($this->keys())->contains(Str::snake($handle))) {
+            $value = $this->wrapInvokable($method, false, $this->data, $handle, $fieldtype);
+        } else {
+            $value = $this->wrapDeferredValue($handle, $fieldtype);
         }
 
-        if (method_exists($this->data, $method) && collect($this->keys())->contains(Str::snake($handle))) {
-            return $this->wrapValue($this->data->$method(), $handle);
+        // If someone is calling ->get() directly they probably
+        // don't want to remember to also ->materialize() it.
+        if (! $this->isSelecting) {
+            return $value->materialize();
         }
 
-        return $this->wrapValue($this->getFromData($handle), $handle);
+        return $value;
     }
 
     protected function filterKeys($keys)
@@ -80,7 +109,7 @@ private function methodExistsOnThisClass($method)
         return method_exists($this, $method) && ! in_array($method, ['select', 'except']);
     }
 
-    protected function getFromData($handle)
+    public function getFromData($handle)
     {
         $value = method_exists($this->data, 'value') ? $this->data->value($handle) : $this->data->get($handle);
 
@@ -93,19 +122,48 @@ protected function getFromData($handle)
         return $value;
     }
 
-    protected function wrapValue($value, $handle)
+    protected function wrapDeferredValue($handle, $fieldtype = null)
+    {
+        $fieldtype = $this->adjustFieldtype($handle, $fieldtype);
+
+        return (new DeferredValue(
+            null,
+            $handle,
+            $fieldtype,
+            $this->data
+        ))->withAugmentedReference($this);
+    }
+
+    protected function wrapInvokable(string $method, bool $proxy, $methodTarget, string $handle, $fieldtype = null)
+    {
+        $fieldtype = $this->adjustFieldtype($handle, $fieldtype);
+
+        return (new InvokableValue(
+            null,
+            $handle,
+            $fieldtype,
+            $this->data
+        ))->setInvokableDetails($method, $proxy, $methodTarget);
+    }
+
+    protected function wrapValue($value, $handle, $fieldtype = null)
     {
-        $fields = $this->blueprintFields();
+        $fieldtype = $this->adjustFieldtype($handle, $fieldtype);
 
         return new Value(
             $value,
             $handle,
-            optional($fields->get($handle))->fieldtype(),
+            $fieldtype,
             $this->data
         );
     }
 
-    protected function blueprintFields()
+    protected function getFieldtype($handle)
+    {
+        return optional($this->blueprintFields()->get($handle))->fieldtype();
+    }
+
+    public function blueprintFields()
     {
         if (! isset($this->blueprintFields)) {
             $this->blueprintFields = (method_exists($this->data, 'blueprint') && $blueprint = $this->data->blueprint())

src/Data/AugmentedCollection.php

@@ -47,6 +47,29 @@ public function withoutEvaluation()
         return $this;
     }
 
+    protected function requiresMaterialization($item)
+    {
+        return $item instanceof InvokableValue ||
+                $item instanceof DeferredValue ||
+                $item instanceof TransientValue;
+    }
+
+    public function all()
+    {
+        return collect($this->items)->map(function ($item) {
+            if ($this->requiresMaterialization($item)) {
+                return $item->materialize();
+            }
+
+            return $item;
+        })->all();
+    }
+
+    public function deferredAll()
+    {
+        return parent::all();
+    }
+
     public function toArray()
     {
         return $this->map(function ($value) {

src/Data/AugmentedData.php

@@ -20,7 +20,7 @@ public function keys()
         return array_keys($this->array);
     }
 
-    protected function getFromData($handle)
+    public function getFromData($handle)
     {
         return $this->array[$handle] ?? null;
     }

src/Data/BulkAugmentor.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Statamic\Data;
+
+use Statamic\Contracts\Data\BulkAugmentable;
+
+class BulkAugmentor
+{
+    protected $isTree = false;
+    protected $originalValues = [];
+    protected $augmentedValues = [];
+
+    protected function getAugmentationReference($item)
+    {
+        if ($item instanceof BulkAugmentable && $key = $item->getAugmentationReferenceKey()) {
+            return $key;
+        }
+
+        return 'Ref::'.get_class($item).spl_object_hash($item);
+    }
+
+    public function augment($items)
+    {
+        $count = count($items);
+
+        $referenceKeys = [];
+        $referenceFields = [];
+
+        for ($i = 0; $i < $count; $i++) {
+            $item = $items[$i];
+            $reference = $this->getAugmentationReference($item);
+
+            if (! $this->isTree) {
+                $this->originalValues[$i] = $item;
+            }
+
+            if (array_key_exists($reference, $referenceKeys)) {
+                continue;
+            }
+
+            $referenceKeys[$reference] = $item->augmented()->keys();
+            $referenceFields[$reference] = $item->augmented()->blueprintFields();
+        }
+
+        for ($i = 0; $i < $count; $i++) {
+            $item = $items[$i];
+            $reference = $this->getAugmentationReference($item);
+            $fields = $referenceFields[$reference];
+            $keys = $referenceKeys[$reference];
+
+            $this->augmentedValues[$i] = $item->toDeferredAugmentedArray($keys, $fields);
+        }
+
+        return $this;
+    }
+
+    public function augmentTree($tree)
+    {
+        $this->isTree = true;
+
+        if (! $tree) {
+            return $this;
+        }
+
+        $items = [];
+
+        for ($i = 0; $i < count($tree); $i++) {
+            $item = $tree[$i];
+
+            $items[] = $item['page'];
+            $this->originalValues[$i] = $item;
+        }
+
+        return $this->augment($items);
+    }
+
+    public function map(callable $callable)
+    {
+        $items = [];
+
+        for ($i = 0; $i < count($this->originalValues); $i++) {
+            $original = $this->originalValues[$i];
+            $augmented = $this->augmentedValues[$i];
+
+            $items[] = call_user_func_array($callable, [$original, $augmented, $i]);
+        }
+
+        return collect($items);
+    }
+
+    public function augmented()
+    {
+        return $this->augmentedValues;
+    }
+}

src/Data/Concerns/ResolvesValues.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Statamic\Data\Concerns;
+
+use Statamic\Fields\Value;
+
+trait ResolvesValues
+{
+    abstract protected function resolve();
+
+    public function materialize()
+    {
+        $this->resolve();
+
+        return $this->toValue();
+    }
+
+    protected function toValue()
+    {
+        return new Value($this->raw, $this->handle, $this->fieldtype, $this->augmentable, $this->shallow);
+    }
+
+    public function raw()
+    {
+        $this->resolve();
+
+        return parent::raw();
+    }
+
+    public function value()
+    {
+        $this->resolve();
+
+        return parent::value();
+    }
+
+    public function shallow()
+    {
+        $this->resolve();
+
+        return parent::shallow();
+    }
+
+    public function isRelationship(): bool
+    {
+        $this->resolve();
+
+        return parent::isRelationship();
+    }
+
+    public function fieldtype()
+    {
+        $this->resolve();
+
+        return parent::fieldtype();
+    }
+}