Implements multiple events

src/Commands/ProjectModelsCommand.php

@@ -51,7 +51,7 @@ public function handle(): void
             ->flatten()
             ->sortBy('created_at')
             ->each
-            ->projectModel();
+            ->projectModel('created');
 
         $this->info('Projections have been refreshed!');
     }

src/Commands/stubs/KeyedProjection.php.stub

@@ -34,7 +34,7 @@ class {{ class }} extends Projection implements ProjectionContract
     /**
      * Compute the projection.
      */
-    public static function handle(array $content, Model $model): array
+    public static function projectableCreated(array $content, Model $model): array
     {
         return [];
     }

src/Commands/stubs/Projection.php.stub

@@ -26,7 +26,7 @@ class {{ class }} extends Projection implements ProjectionContract
     /**
      * Compute the projection.
      */
-    public static function handle(array $content, Model $model): array
+    public static function projectableCreated(array $content, Model $model): array
     {
         return [];
     }

src/Contracts/ProjectionContract.php

@@ -2,17 +2,10 @@
 
 namespace TimothePearce\Quasar\Contracts;
 
-use Illuminate\Database\Eloquent\Model;
-
 interface ProjectionContract
 {
     /**
      * The default projection content.
      */
     public static function defaultContent(): array;
-
-    /**
-     * Compute the projection.
-     */
-    public static function handle(array $content, Model $model): array;
 }

src/Exceptions/MissingCallableMethodException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace TimothePearce\Quasar\Exceptions;
+
+use Exception;
+
+class MissingCallableMethodException extends Exception
+{
+    protected $message = "Missing callable method from Projection.";
+}

src/Jobs/ProcessProjection.php

@@ -19,16 +19,16 @@ class ProcessProjection implements ShouldQueue
     /**
      * Create a new job instance.
      */
-    public function __construct(protected Model $model)
+    public function __construct(protected Model $model, protected string $eventName)
     {
         $this->onQueue(config('quasar.queue_name'));
     }
 
     /**
      * Execute the job.
      */
-    public function handle()
+    public function created()
     {
-        $this->model->bootProjectors();
+        $this->model->bootProjectors($this->eventName);
     }
 }

src/Models/Traits/Projectable.php

@@ -16,42 +16,44 @@ trait Projectable
      */
     public static function bootProjectable(): void
     {
-        static::created(fn (Model $model) => $model->projectModel());
+        static::created(fn (Model $model) => $model->projectModel('created'));
+        static::updated(fn (Model $model) => $model->projectModel('updated'));
+        static::deleted(fn (Model $model) => $model->projectModel('deleted'));
     }
 
     /**
      * Projects the model.
      * @throws ReflectionException
      */
-    public function projectModel(): void
+    public function projectModel(string $eventName): void
     {
         config('quasar.queue') ?
-            ProcessProjection::dispatch($this) :
-            $this->bootProjectors();
+            ProcessProjection::dispatch($this, $eventName) :
+            $this->bootProjectors($eventName);
     }
 
     /**
      * Boot the projectors.
      * @throws ReflectionException
      */
-    public function bootProjectors(): void
+    public function bootProjectors(string $eventName): void
     {
         collect($this->projections)->each(
-            fn (string $projection) => (new Projector($this, $projection))->parsePeriods()
+            fn (string $projection) => (new Projector($this, $projection, $eventName))->parsePeriods()
         );
     }
 
     /**
      * Get all the projections of the model.
      */
     public function projections(
-        string|null       $projectorName = null,
+        string|null       $projectionName = null,
         string|array|null $periods = null,
     ): MorphToMany {
         $query = $this->morphToMany(Projection::class, 'projectable', 'quasar_projectables');
 
-        if (isset($projectorName)) {
-            $query->where('projection_name', $projectorName);
+        if (isset($projectionName)) {
+            $query->where('projection_name', $projectionName);
         }
 
         if (isset($periods) && gettype($periods) === 'string') {
@@ -73,10 +75,10 @@ public function projections(
      * Get the first projection.
      */
     public function firstProjection(
-        string|null       $projectorName = null,
+        string|null       $projectionName = null,
         string|array|null $periods = null,
     ): null|Projection {
-        return $this->projections($projectorName, $periods)->first();
+        return $this->projections($projectionName, $periods)->first();
     }
 
     /**

src/Projector.php

@@ -6,6 +6,7 @@
 use Illuminate\Support\Str;
 use ReflectionException;
 use ReflectionProperty;
+use TimothePearce\Quasar\Exceptions\MissingCallableMethodException;
 use TimothePearce\Quasar\Models\Projection;
 
 class Projector
@@ -15,13 +16,17 @@ class Projector
      */
     protected array $periods;
 
-    public function __construct(protected Model $projectedModel, protected string $projectionName)
-    {
+    public function __construct(
+        protected Model  $projectedModel,
+        protected string $projectionName,
+        protected string $eventName
+    ) {
     }
 
     /**
      * Parses the periods defined as class attribute.
      * @throws ReflectionException
+     * @throws MissingCallableMethodException
      */
     public function parsePeriods(): void
     {
@@ -32,6 +37,7 @@ public function parsePeriods(): void
 
     /**
      * Parses the given period.
+     * @throws MissingCallableMethodException
      */
     private function parsePeriod(string $period): void
     {
@@ -45,22 +51,21 @@ private function parsePeriod(string $period): void
     }
 
     /**
-     * Try to find the projection.
+     * Finds the projection if it exists.
      */
     private function findProjection(string $period, int $quantity, string $periodType): Projection|null
     {
-        $query = Projection::where([
+        return Projection::firstWhere([
             ['projection_name', $this->projectionName],
             ['key', $this->hasKey() ? $this->key() : null],
             ['period', $period],
             ['start_date', $this->projectedModel->created_at->floorUnit($periodType, $quantity)],
         ]);
-
-        return $query->first();
     }
 
     /**
      * Creates the projection.
+     * @throws MissingCallableMethodException
      */
     private function createProjection(string $period, int $quantity, string $periodType): void
     {
@@ -69,16 +74,17 @@ private function createProjection(string $period, int $quantity, string $periodT
             'key' => $this->hasKey() ? $this->key() : null,
             'period' => $period,
             'start_date' => $this->projectedModel->created_at->floorUnit($periodType, $quantity),
-            'content' => $this->getProjectedContent($this->projectionName::defaultContent()),
+            'content' => $this->mergeProjectedContent($this->projectionName::defaultContent()),
         ]);
     }
 
     /**
      * Updates the projection.
+     * @throws MissingCallableMethodException
      */
     private function updateProjection(Projection $projection): void
     {
-        $projection->content = $this->getProjectedContent($projection->content);
+        $projection->content = $this->mergeProjectedContent($projection->content);
 
         $projection->save();
     }
@@ -100,10 +106,32 @@ public function key(): bool|int|string
     }
 
     /**
-     * Get the projected content.
+     * Merges the projected content with the given one.
+     * @throws MissingCallableMethodException
+     */
+    private function mergeProjectedContent(array $content): array
+    {
+        return array_merge($content, $this->resolveCallableMethod($content));
+    }
+
+    /**
+     * Resolves the callable method.
+     * @throws MissingCallableMethodException
      */
-    private function getProjectedContent(array $baseContent): array
+    private function resolveCallableMethod(array $content): array
     {
-        return $this->projectionName::handle($baseContent, $this->projectedModel);
+        $modelName = Str::of($this->projectedModel::class)->explode('\\')->last();
+        $callableMethod = lcfirst($modelName) . ucfirst($this->eventName);
+        $defaultCallable = 'projectable' . ucfirst($this->eventName);
+
+        if (method_exists($this->projectionName, $callableMethod)) {
+            return $this->projectionName::$callableMethod($content, $this->projectedModel);
+        }
+
+        if (method_exists($this->projectionName, $defaultCallable)) {
+            return $this->projectionName::$defaultCallable($content, $this->projectedModel);
+        }
+
+        throw new MissingCallableMethodException();
     }
 }

src/Quasar.php

@@ -5,6 +5,7 @@
 use Illuminate\Support\Collection;
 use Illuminate\Support\Str;
 use ReflectionClass;
+use TimothePearce\Quasar\Models\Traits\Projectable;
 
 class Quasar
 {
@@ -19,7 +20,7 @@ public function resolveProjectableModels(): Collection
             $rc = new ReflectionClass($model);
             $classes = $rc->getTraits();
 
-            return isset($classes["TimothePearce\Quasar\Models\Traits\Projectable"]);
+            return isset($classes[Projectable::class]);
         });
     }
 
@@ -38,11 +39,9 @@ private function getModels(string $path): Collection
 
             $filename = $path . '/' . $result;
 
-            if (is_dir($filename)) {
-                $models = $models->concat($this->getModels($filename));
-            } else {
+            is_dir($filename) ?
+                $models = $models->concat($this->getModels($filename)) :
                 $models->push($this->getModelNamespace($filename));
-            }
         }
 
         return collect($models);

tests/Commands/CreateProjectionCommandTest.php

@@ -90,7 +90,7 @@ public static function defaultContent(): array
     /**
      * Compute the projection.
      */
-    public static function handle(array \$content, Model \$model): array
+    public static function projectableCreated(array \$content, Model \$model): array
     {
         return [];
     }
@@ -142,7 +142,7 @@ public static function key(Model \$model): string
     /**
      * Compute the projection.
      */
-    public static function handle(array \$content, Model \$model): array
+    public static function projectableCreated(array \$content, Model \$model): array
     {
         return [];
     }

tests/Commands/ProjectModelsCommandTest.php

@@ -44,6 +44,9 @@ public function it_projects_the_models_when_executed()
         $this->assertDatabaseCount('quasar_projections', 1);
     }
 
+    /**
+     * Mocks the `resolveProjectableModels` methods from the Quasar class.
+     */
     private function mockResolveProjectableModels()
     {
         $this->partialMock(

tests/Models/Log.php

@@ -12,6 +12,8 @@ class Log extends Model
     use HasFactory;
     use Projectable;
 
+    protected $guarded = [];
+
     /**
      * The projections list.
      */

tests/Models/Projections/MultiplePeriodsProjection.php

@@ -28,17 +28,17 @@ class MultiplePeriodsProjection extends Projection implements ProjectionContract
     public static function defaultContent(): array
     {
         return [
-            'number of logs' => 0,
+            'created_count' => 0,
         ];
     }
 
     /**
      * Compute the projection's content.
      */
-    public static function handle(array $content, Model $model): array
+    public static function projectableCreated(array $content, Model $model): array
     {
         return [
-            'number of logs' => $content['number of logs'] + 1,
+            'created_count' => $content['created_count'] + 1,
         ];
     }
 }

tests/Models/Projections/SinglePeriodKeyedProjection.php

@@ -19,7 +19,7 @@ class SinglePeriodKeyedProjection extends Projection implements ProjectionContra
     public static function defaultContent(): array
     {
         return [
-            'number of logs' => 0,
+            'created_count' => 0,
         ];
     }
 
@@ -34,10 +34,10 @@ public static function key(Model $model): string
     /**
      * Compute the projection.
      */
-    public static function handle(array $content, Model $model): array
+    public static function projectableCreated(array $content, Model $model): array
     {
         return [
-            'number of logs' => $content['number of logs'] + 1,
+            'created_count' => $content['created_count'] + 1,
         ];
     }
 }