Add support for computed values

resources/js/components/fieldtypes/Fieldtype.vue

@@ -49,7 +49,10 @@ export default {
         },
 
         isReadOnly() {
-            return this.readOnly || this.config.visibility === 'read_only' || false;
+            return this.readOnly
+                || this.config.visibility === 'read_only'
+                || this.config.visibility === 'computed'
+                || false;
         },
 
         replicatorPreview() {

src/Auth/Eloquent/User.php

@@ -284,11 +284,6 @@ public function get($key, $default = null)
         return is_null($value) ? $default : $value;
     }
 
-    public function value($key)
-    {
-        return $this->get($key);
-    }
-
     public function set($key, $value)
     {
         if ($key === 'password') {

src/Auth/File/User.php

@@ -57,11 +57,6 @@ public function data($data = null)
         return $this;
     }
 
-    public function value($key)
-    {
-        return $this->get($key);
-    }
-
     public function id($id = null)
     {
         return $this->fluentlyGetOrSet('id')->args(func_get_args());

src/Auth/User.php

@@ -17,6 +17,7 @@
 use Statamic\Contracts\Data\Augmentable;
 use Statamic\Contracts\Data\Augmented;
 use Statamic\Contracts\GraphQL\ResolvesValues as ResolvesValuesContract;
+use Statamic\Data\ContainsComputedData;
 use Statamic\Data\HasAugmentedInstance;
 use Statamic\Data\TracksQueriedColumns;
 use Statamic\Data\TracksQueriedRelations;
@@ -42,21 +43,30 @@ abstract class User implements
     ArrayAccess,
     Arrayable
 {
-    use Authorizable, Notifiable, CanResetPassword, HasAugmentedInstance, TracksQueriedColumns, TracksQueriedRelations, HasAvatar, ResolvesValues;
+    use Authorizable, Notifiable, CanResetPassword, HasAugmentedInstance, TracksQueriedColumns, TracksQueriedRelations, HasAvatar, ResolvesValues, ContainsComputedData;
 
     protected $afterSaveCallbacks = [];
     protected $withEvents = true;
 
-    abstract public function get($key, $fallback = null);
+    abstract public function data($data = null);
 
-    abstract public function value($key);
+    abstract public function get($key, $fallback = null);
 
     abstract public function has($key);
 
     abstract public function set($key, $value);
 
     abstract public function remove($key);
 
+    public function value($key)
+    {
+        if ($this->hasComputedCallback($key)) {
+            return $this->getComputed($key);
+        }
+
+        return $this->get($key);
+    }
+
     public function reference()
     {
         return "user::{$this->id()}";
@@ -285,4 +295,9 @@ public function setPreferredLocale($locale)
     {
         return $this->setPreference('locale', $locale);
     }
+
+    protected function getComputedCallbacks()
+    {
+        return Facades\User::getComputedCallbacks();
+    }
 }

src/Auth/UserRepository.php

@@ -4,12 +4,15 @@
 
 use Statamic\Contracts\Auth\User;
 use Statamic\Contracts\Auth\UserRepository as RepositoryContract;
+use Statamic\Data\StoresComputedFieldCallbacks;
 use Statamic\Events\UserBlueprintFound;
 use Statamic\Facades\Blueprint;
 use Statamic\OAuth\Provider;
 
 abstract class UserRepository implements RepositoryContract
 {
+    use StoresComputedFieldCallbacks;
+
     public function create()
     {
         // TODO: Factory?

src/Data/ContainsComputedData.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Statamic\Data;
+
+trait ContainsComputedData
+{
+    protected $withComputedData = true;
+
+    public function computedData()
+    {
+        if (! method_exists($this, 'getComputedCallbacks')) {
+            return collect();
+        }
+
+        return collect($this->getComputedCallbacks())->map(function ($callback, $field) {
+            return $this->getComputed($field);
+        });
+    }
+
+    public function getComputed($key)
+    {
+        $instance = $this->instanceWithoutComputed();
+
+        $value = method_exists($this, 'get') ? $instance->get($key) : null;
+
+        if ($this->withComputedData && $callback = $this->getComputedCallbacks()->get($key)) {
+            return $callback($instance, $value);
+        }
+
+        return $value;
+    }
+
+    protected function hasComputedCallback($key)
+    {
+        return $this->getComputedCallbacks()->has($key);
+    }
+
+    protected function instanceWithoutComputed()
+    {
+        $clone = clone $this;
+
+        $clone->withComputedData = false;
+
+        return $clone;
+    }
+}

src/Data/HasOrigin.php

@@ -8,14 +8,32 @@ trait HasOrigin
 
     public function values()
     {
+        $originFallbackValues = method_exists($this, 'getOriginFallbackValues') ? $this->getOriginFallbackValues() : collect();
+
         $originValues = $this->hasOrigin() ? $this->origin()->values() : collect();
 
-        return $originValues->merge($this->data);
+        $computedData = method_exists($this, 'computedData') ? $this->computedData() : [];
+
+        return collect()
+            ->merge($originFallbackValues)
+            ->merge($originValues)
+            ->merge($this->data)
+            ->merge($computedData);
     }
 
     public function value($key)
     {
-        return $this->values()->get($key);
+        $originFallbackValue = method_exists($this, 'getOriginFallbackValue') ? $this->getOriginFallbackValue($key) : null;
+
+        $originValue = $this->hasOrigin() ? $this->origin()->value($key) : $originFallbackValue;
+
+        $value = $this->has($key) ? $this->get($key) : $originValue;
+
+        if (method_exists($this, 'hasComputedCallback') && $this->hasComputedCallback($key)) {
+            return $this->getComputed($key) ?? $value;
+        }
+
+        return $value;
     }
 
     public function origin($origin = null)

src/Data/StoresComputedFieldCallbacks.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Statamic\Data;
+
+use Closure;
+use Illuminate\Support\Collection;
+
+trait StoresComputedFieldCallbacks
+{
+    protected $computedFieldCallbacks;
+
+    public function computed(string $field, Closure $callback)
+    {
+        $this->computedFieldCallbacks[$field] = $callback;
+    }
+
+    public function getComputedCallbacks(): Collection
+    {
+        return collect($this->computedFieldCallbacks);
+    }
+}

src/Data/StoresScopedComputedFieldCallbacks.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Statamic\Data;
+
+use Closure;
+use Illuminate\Support\Collection;
+use Statamic\Support\Str;
+
+trait StoresScopedComputedFieldCallbacks
+{
+    protected $computedFieldCallbacks;
+
+    public function computed(string $scope, string $field, Closure $callback)
+    {
+        $this->computedFieldCallbacks["$scope.$field"] = $callback;
+    }
+
+    public function getComputedCallbacks(string $scope): Collection
+    {
+        return collect($this->computedFieldCallbacks)
+            ->filter(fn ($_, $key) => Str::startsWith($key, "{$scope}."))
+            ->keyBy(fn ($_, $key) => Str::after($key, "{$scope}."));
+    }
+}

src/Entries/Entry.php

@@ -14,6 +14,7 @@
 use Statamic\Contracts\Entries\EntryRepository;
 use Statamic\Contracts\GraphQL\ResolvesValues as ResolvesValuesContract;
 use Statamic\Contracts\Query\ContainsQueryableValues;
+use Statamic\Data\ContainsComputedData;
 use Statamic\Data\ContainsData;
 use Statamic\Data\ExistsAsFile;
 use Statamic\Data\HasAugmentedInstance;
@@ -47,7 +48,7 @@ class Entry implements Contract, Augmentable, Responsable, Localization, Protect
         uri as routableUri;
     }
 
-    use ContainsData, ExistsAsFile, HasAugmentedInstance, FluentlyGetsAndSets, Revisable, Publishable, TracksQueriedColumns, TracksQueriedRelations, TracksLastModified;
+    use ContainsData, ContainsComputedData, ExistsAsFile, HasAugmentedInstance, FluentlyGetsAndSets, Revisable, Publishable, TracksQueriedColumns, TracksQueriedRelations, TracksLastModified;
     use ResolvesValues {
         resolveGqlValue as traitResolveGqlValue;
     }
@@ -734,9 +735,14 @@ protected function getOriginByString($origin)
         return Facades\Entry::find($origin);
     }
 
-    public function values()
+    protected function getOriginFallbackValues()
     {
-        return $this->collection()->cascade()->merge($this->originValues());
+        return $this->collection()->cascade();
+    }
+
+    protected function getOriginFallbackValue($key)
+    {
+        return $this->collection()->cascade()->get($key);
     }
 
     public function defaultAugmentedArrayKeys()
@@ -839,4 +845,9 @@ public function getQueryableValue(string $field)
 
         return $field->fieldtype()->toQueryableValue($value);
     }
+
+    protected function getComputedCallbacks()
+    {
+        return Facades\Collection::getComputedCallbacks($this->collection);
+    }
 }

src/Facades/Collection.php

@@ -14,6 +14,8 @@
  * @method static \Illuminate\Support\Collection handles()
  * @method static bool handleExists(string $handle)
  * @method static \Illuminate\Support\Collection whereStructured()
+ * @method static \Illuminate\Support\Collection getComputedCallbacks(string $collection)
+ * @method static void computed(string $collection, string $field, \Closure $callback)
  *
  * @see \Illuminate\Support\Collection
  * @see \Statamic\Entries\Collection

src/Facades/User.php

@@ -16,6 +16,8 @@
  * @method static void save(User $user);
  * @method static void delete(User $user);
  * @method static \Statamic\Fields\Blueprint blueprint();
+ * @method static \Illuminate\Support\Collection getComputedCallbacks()
+ * @method static void computed(string $field, \Closure $callback)
  *
  * @see \Statamic\Contracts\Auth\UserRepository
  */

src/Fields/Fields.php

@@ -17,6 +17,7 @@ class Fields
     protected $parentField;
     protected $filled = [];
     protected $withValidatableValues = false;
+    protected $withComputedValues = false;
 
     public function __construct($items = [], $parent = null, $parentField = null)
     {
@@ -82,6 +83,13 @@ public function withValidatableValues()
         return $this;
     }
 
+    public function withComputedValues()
+    {
+        $this->withComputedValues = true;
+
+        return $this;
+    }
+
     public function items()
     {
         return $this->items;
@@ -154,17 +162,20 @@ public function addValues(array $values)
 
     public function values()
     {
-        $values = $this->fields->mapWithKeys(function ($field) {
-            return [$field->handle() => $field->value()];
-        });
-
-        if ($this->withValidatableValues) {
-            $values = $values->filter(function ($field, $handle) {
-                return in_array($handle, $this->filled);
+        return $this->fields
+            ->reject(function ($field) {
+                return $this->withComputedValues === false
+                    ? $field->visibility() === 'computed'
+                    : false;
+            })
+            ->mapWithKeys(function ($field) {
+                return [$field->handle() => $field->value()];
+            })
+            ->filter(function ($field, $handle) {
+                return $this->withValidatableValues
+                    ? in_array($handle, $this->filled)
+                    : true;
             });
-        }
-
-        return $values;
     }
 
     public function process()
@@ -178,7 +189,7 @@ public function preProcess()
     {
         return $this->newInstance()->setFields(
             $this->fields->map->preProcess()
-        );
+        )->withComputedValues();
     }
 
     public function preProcessValidatables()

src/Http/Controllers/CP/Collections/EntriesController.php

@@ -257,7 +257,7 @@ public function create(Request $request, $collection, $site)
             $blueprint->ensureFieldHasConfig('author', ['visibility' => 'read_only']);
         }
 
-        $values = [];
+        $values = Entry::make()->collection($collection)->values()->all();
 
         if ($collection->hasStructure() && $request->parent) {
             $values['parent'] = $request->parent;
@@ -408,11 +408,11 @@ protected function extractFromFields($entry, $blueprint)
     {
         // The values should only be data merged with the origin data.
         // We don't want injected collection values, which $entry->values() would have given us.
+        $values = collect();
         $target = $entry;
-        $values = $target->data();
-        while ($target->hasOrigin()) {
+        while ($target) {
+            $values = $target->data()->merge($target->computedData())->merge($values);
             $target = $target->origin();
-            $values = $target->data()->merge($values);
         }
         $values = $values->all();
 

src/Http/Controllers/CP/Fields/FieldsController.php

@@ -135,6 +135,7 @@ protected function blueprint($blueprint)
                 'options' => [
                     'visible' => __('Visible'),
                     'read_only' => __('Read Only'),
+                    'computed' => __('Computed'),
                     'hidden' => __('Hidden'),
                 ],
                 'default' => 'visible',