Got PHP attributes working as a cleaner approach.

src/Behaviours/Cacheable.php

@@ -2,7 +2,10 @@
 namespace Eloquence\Behaviours;
 
 use Closure;
+use Eloquence\Behaviours\SumCache\SummedBy;
 use Illuminate\Database\Eloquent\Model;
+use ReflectionClass;
+use ReflectionMethod;
 
 /**
  * The cacheable trait is concerned with the related models.
@@ -24,6 +27,26 @@ public static function for(Model $model): self
         return new self($model);
     }
 
+    public function reflect(string $attributeClass, \Closure $fn)
+    {
+        $reflect = new ReflectionClass($this->model);
+
+        // This behemoth cycles through all valid methods, and then gets only the attributes we care about,
+        // formatting it in a way that is usable by our various aggregate service classes.
+        return collect($reflect->getMethods())
+            ->filter(fn(ReflectionMethod $method) => count($method->getAttributes($attributeClass)) > 0)
+            ->flatten()
+            ->map(function(ReflectionMethod $method) use ($attributeClass) {
+                return collect($method->getAttributes($attributeClass))->map(fn(\ReflectionAttribute $attribute) => [
+                    'name' => $method->name,
+                    'attribute' => $attribute->newInstance(),
+                ])->toArray();
+            })
+            ->flatten(1)
+            ->mapWithKeys($fn)
+            ->toArray();
+    }
+
     /**
      * Applies the provided function using the relevant configuration to all configured relations. Configuration
      * would be one of countedBy, summedBy, averagedBy.etc.

src/Behaviours/CountCache/CountCache.php

@@ -1,8 +1,10 @@
 <?php
+
 namespace Eloquence\Behaviours\CountCache;
 
 use Eloquence\Behaviours\Cacheable;
 use Eloquence\Behaviours\CacheConfig;
+use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Str;
 
 /**
@@ -12,11 +14,14 @@ class CountCache
 {
     use Cacheable;
 
-    private function __construct(private Countable $model) {}
+    private function __construct(private Model $model) {}
 
     private function configuration(): array
     {
-        return $this->model->countedBy();
+        return $this->reflect(CountedBy::class, function(array $config) {
+            $aggregateField = $config['attribute']->as ?? Str::lower(Str::snake(class_basename($this->model))).'_count';
+            return [$config['name'] => $aggregateField];
+        });
     }
 
     /**
@@ -68,12 +73,6 @@ public function decrement(): void
      */
     protected function config($key, string $value): CacheConfig
     {
-        // If the key is numeric, it means only the relationship method has been referenced.
-        if (is_numeric($key)) {
-            $key = $value;
-            $value = Str::lower(Str::snake(class_basename($this->model))).'_count';
-        }
-
         return new CacheConfig($key, $value);
     }
 }

src/Behaviours/CountCache/CountedBy.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Eloquence\Behaviours\CountCache;
+
+#[\Attribute]
+class CountedBy
+{
+    public function __construct(readonly ?string $as = null) {}
+}

src/Behaviours/CountCache/Observer.php

@@ -1,15 +1,12 @@
 <?php
 namespace Eloquence\Behaviours\CountCache;
 
-use Closure;
-
 /**
  * The Observer is used for watching for model updates and making the appropriate changes
  * as required. This includes watching for created, deleted, updated and restored events.
  */
 class Observer
 {
-
     /**
      * When the model has been created, increment the count cache by 1.
      *
@@ -55,7 +52,7 @@ public function restored($model): void
      *
      * @param string $operation + or -
      */
-    private function update(Countable $model, string $operation): void
+    private function update($model, string $operation): void
     {
         $countCache = CountCache::for($model);
 

src/Behaviours/SumCache/Observer.php

@@ -4,23 +4,23 @@
 
 class Observer
 {
-    public function created(Summable $model)
+    public function created($model)
     {
         SumCache::for($model)->increase();
     }
 
-    public function updated(Summable $model)
+    public function updated($model)
     {
         SumCache::for($model)->update();
     }
 
-    public function deleted(Summable $model)
+    public function deleted($model)
     {
         SumCache::for($model)->decrease();
     }
 
-    public function restored(Summable $model)
+    public function restored($model)
     {
-
+        // @TODO
     }
 }

src/Behaviours/SumCache/SumCache.php

@@ -1,21 +1,23 @@
 <?php
+
 namespace Eloquence\Behaviours\SumCache;
 
 use Eloquence\Behaviours\Cacheable;
 use Eloquence\Behaviours\CacheConfig;
 use Illuminate\Database\Eloquent\Model;
-use Illuminate\Support\Arr;
-use Illuminate\Support\Str;
+use ReflectionMethod;
 
 class SumCache
 {
     use Cacheable;
 
-    private function __construct(private Summable $model) {}
+    private function __construct(private Model $model) {}
 
     private function configuration(): array
     {
-        return $this->model->summedBy();
+        return $this->reflect(SummedBy::class, function(array $config) {
+            return [$config['name'] => [$config['attribute']->as => $config['attribute']->from]];
+        });
     }
 
     /**
@@ -68,14 +70,10 @@ public function update(): void
      */
     protected function config($relation, string|array $sourceField): CacheConfig
     {
-        if (is_array($sourceField)) {
-            $keys = array_keys($sourceField);
-            $aggregateField = $keys[0];
-            $sourceField = $sourceField[$aggregateField];
-        }
-        else {
-            $aggregateField = 'total_'.$sourceField;
-        }
+        $keys = array_keys($sourceField);
+
+        $aggregateField = $keys[0];
+        $sourceField = $sourceField[$aggregateField];
 
         return new CacheConfig($relation, $aggregateField, $sourceField);
     }

src/Behaviours/SumCache/SummedBy.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Eloquence\Behaviours\SumCache;
+
+#[\Attribute]
+class SummedBy
+{
+    public function __construct(readonly string $from, readonly string $as) {}
+}

src/Commands/FindCacheableClasses.php

@@ -1,7 +1,7 @@
-<?php namespace Eloquence\Commands;
+<?php
+
+namespace Eloquence\Commands;
 
-use Eloquence\Behaviours\CountCache\Countable;
-use Eloquence\Behaviours\SumCache\Summable;
 use hanneskod\classtools\Iterator\ClassIterator;
 use Illuminate\Database\Eloquent\Model;
 use Symfony\Component\Finder\Finder;

src/Commands/RebuildCaches.php

@@ -1,10 +1,9 @@
 <?php
+
 namespace Eloquence\Commands;
 
-use Eloquence\Behaviours\CountCache\Countable;
 use Eloquence\Behaviours\CountCache\CountCache;
 use Eloquence\Behaviours\SumCache\SumCache;
-use Eloquence\Behaviours\SumCache\Summable;
 use hanneskod\classtools\Iterator\ClassIterator;
 use Illuminate\Console\Command;
 use Illuminate\Database\Eloquent\Model;
@@ -48,17 +47,17 @@ private function rebuild(string $className): void
     {
         $model = new $className;
 
-        if ($model instanceof Countable) {
-            $this->info("Rebuilding [$className] count caches");
-            $countCache = CountCache::for($model);
-            $countCache->rebuild();
-        }
-
-        if ($model instanceof Summable) {
-            $this->info("Rebuilding [$className] sum caches");
-            $sumCache = SumCache::for($model);
-            $sumCache->rebuild();
-        }
+//        if ($model instanceof Countable) {
+//            $this->info("Rebuilding [$className] count caches");
+//            $countCache = CountCache::for($model);
+//            $countCache->rebuild();
+//        }
+//
+//        if ($model instanceof Summable) {
+//            $this->info("Rebuilding [$className] sum caches");
+//            $sumCache = SumCache::for($model);
+//            $sumCache->rebuild();
+//        }
     }
 
     /**

tests/Acceptance/CountCacheTest.php

@@ -1,7 +1,6 @@
 <?php
 namespace Tests\Acceptance;
 
-use Tests\Acceptance\Models\Category;
 use Tests\Acceptance\Models\Comment;
 use Tests\Acceptance\Models\Post;
 use Tests\Acceptance\Models\User;

tests/Acceptance/Models/Comment.php

@@ -1,7 +1,7 @@
 <?php
 namespace Tests\Acceptance\Models;
 
-use Eloquence\Behaviours\CountCache\Countable;
+use Eloquence\Behaviours\CountCache\CountedBy;
 use Eloquence\Behaviours\CountCache\HasCounts;
 use Eloquence\Behaviours\CamelCased;
 use Illuminate\Database\Eloquent\Factories\Factory;
@@ -10,7 +10,7 @@
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\SoftDeletes;
 
-class Comment extends Model implements Countable
+class Comment extends Model
 {
     use CamelCased;
     use HasCounts;
@@ -22,21 +22,18 @@ class Comment extends Model implements Countable
         'post_id',
     ];
 
+    #[CountedBy]
     public function post(): BelongsTo
     {
         return $this->belongsTo(Post::class);
     }
 
+    #[CountedBy]
     public function user(): BelongsTo
     {
         return $this->belongsTo(User::class);
     }
 
-    public function countedBy(): array
-    {
-        return ['post', 'user'];
-    }
-
     protected static function newFactory(): Factory
     {
         return CommentFactory::new();

tests/Acceptance/Models/Item.php

@@ -3,22 +3,18 @@
 
 use Eloquence\Behaviours\SumCache\HasSums;
 use Eloquence\Behaviours\CamelCased;
-use Eloquence\Behaviours\SumCache\Summable;
+use Eloquence\Behaviours\SumCache\SummedBy;
 use Illuminate\Database\Eloquent\Factories\Factory;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 
-class Item extends Model implements Summable
+class Item extends Model
 {
     use CamelCased;
     use HasSums;
     use HasFactory;
 
-    public function summedBy(): array
-    {
-        return ['order' => 'amount'];
-    }
-
+    #[SummedBy('amount', 'total_amount')]
     public function order()
     {
         return $this->belongsTo(Order::class);