FIX exclusion exceptions (#26)

Author: enricodelazzari

LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2023 MAIZE SRL <[email protected]>
+Copyright (c) 2024 MAIZE SRL <[email protected]>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -13,10 +13,10 @@
 [![GitHub Code Style Action Status](https://img.shields.io/github/actions/workflow/status/maize-tech/laravel-excludable/fix-php-code-style-issues.yml?branch=main&label=code%20style&style=flat-square)](https://github.com/maize-tech/laravel-excludable/actions?query=workflow%3A"Fix+PHP+code+style+issues"+branch%3Amain)
 [![Total Downloads](https://img.shields.io/packagist/dt/maize-tech/laravel-excludable.svg?style=flat-square)](https://packagist.org/packages/maize-tech/laravel-excludable)
 
-Easily exclude model entities from eloquent queries. 
+Easily exclude model entities from eloquent queries.
 
 This package allows you to define a subset of model entities that should be excluded from eloquent queries.
-You will be able to override the default `Exclusion` model and its associated migration, so you can eventually restrict the exclusion context by defining the entity that should effectively exclude the subset. 
+You will be able to override the default `Exclusion` model and its associated migration, so you can eventually restrict the exclusion context by defining the entity that should effectively exclude the subset.
 
 An example usage could be an application with a multi tenant scenario and a set of global entities.
 While those entities should be accessible by all tenants, some of them might want to hide a subset of those entities for their users.
@@ -57,6 +57,17 @@ return [
     */
 
     'exclusion_model' => Maize\Excludable\Models\Exclusion::class,
+    
+    /*
+    |--------------------------------------------------------------------------
+    | Has exclusion query
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the fully qualified class name of the exclusion query.
+    |
+    */
+
+    'has_exclusion_query' => Maize\Excludable\Queries\HasExclusionQuery::class,
 ];
 
 ```
@@ -143,14 +154,24 @@ Article::excludeAllModels([1,2,3]); // passing the model keys
 Article::query()->count(); // returns 3
 ```
 
+To check whether a specific model has a wildcard or not you can use the `hasExclusionWildcard` method:
+
+``` php
+use App\Models\Article;
+
+Article::excludeAllModels();
+
+$hasWildcard = Article::hasExclusionWildcard(); // returns true
+```
+
 ### Include all model entities
 
-To re-include all entities of a specific model you can use the `includeAllModels` method: 
+To re-include all entities of a specific model you can use the `includeAllModels` method:
 
 ``` php
 use App\Models\Article;
 
-Article::includeAllModels()
+Article::includeAllModels();
 
 Article::query()->count(); // returns 0
 ```
@@ -180,7 +201,7 @@ The package automatically throws two separate events when excluding an entity:
 - `excluding` which is thrown before the entity is actually excluded.
   This could be useful, for example, with an observer which listens to this event and does some sort of 'validation' to the related entity.
   If the given validation does not succeed, you can just return `false`, and the entity will not be excluded;
-- `excluded` which is thrown right after the entity has been marked as excluded. 
+- `excluded` which is thrown right after the entity has been marked as excluded.
 
 ## Testing
 

config/excludable.php

@@ -12,4 +12,15 @@
     */
 
     'exclusion_model' => Maize\Excludable\Models\Exclusion::class,
+
+    /*
+    |--------------------------------------------------------------------------
+    | Has exclusion query
+    |--------------------------------------------------------------------------
+    |
+    | Here you may specify the fully qualified class name of the exclusion query.
+    |
+    */
+
+    'has_exclusion_query' => Maize\Excludable\Queries\HasExclusionQuery::class,
 ];

src/Excludable.php

@@ -25,6 +25,13 @@ trait Excludable
     public static function bootExcludable(): void
     {
         static::addGlobalScope(new ExclusionScope);
+
+        static::deleting(
+            fn (Model $model) => Config::getExclusionModel()->where([
+                'excludable_type' => $model->getMorphClass(),
+                'excludable_id' => $model->getKey(),
+            ])->delete()
+        );
     }
 
     public function exclusions(): MorphManyWildcard
@@ -49,34 +56,73 @@ public function excluded(): bool
         return $this->exclusions()->count() === 1;
     }
 
-    public function addToExclusion(): bool
+    public static function hasExclusionWildcard(): bool
     {
-        if ($this->excluded()) {
-            return true;
-        }
-
-        if ($this->fireModelEvent('excluding') === false) {
-            return false;
-        }
-
-        $exclusion = $this->exclusion()->firstOrCreate([
-            'type' => Exclusion::TYPE_EXCLUDE,
-            'excludable_type' => $this->getMorphClass(),
-            'excludable_id' => $this->getKey(),
-        ]);
+        return Config::getExclusionModel()
+            ->query()
+            ->where('excludable_type', app(static::class)->getMorphClass())
+            ->where('excludable_id', '*')
+            ->exists();
+    }
 
-        if ($exclusion->wasRecentlyCreated) {
-            $this->fireModelEvent('excluded', false);
-        }
+    public function addToExclusion(): bool
+    {
+        return DB::transaction(function () {
+            if ($this->fireModelEvent('excluding') === false) {
+                return false;
+            }
+
+            $wasRecentlyDeleted = (bool) $this->exclusions()->where([
+                'type' => Exclusion::TYPE_INCLUDE,
+                'excludable_type' => $this->getMorphClass(),
+                'excludable_id' => $this->getKey(),
+            ])->delete();
+
+            if ($wasRecentlyDeleted) {
+                $this->fireModelEvent('excluded', false);
+            }
+
+            if ($this->excluded()) {
+                return true;
+            }
+
+            $exclusion = $this->exclusion()->firstOrCreate([
+                'type' => Exclusion::TYPE_EXCLUDE,
+                'excludable_type' => $this->getMorphClass(),
+                'excludable_id' => $this->getKey(),
+            ]);
+
+            if ($exclusion->wasRecentlyCreated) {
+                $this->fireModelEvent('excluded', false);
+            }
 
-        return true;
+            return true;
+        });
     }
 
     public function removeFromExclusion(): bool
     {
-        $this->exclusion()->delete();
+        return DB::transaction(function () {
+            if (! $this->excluded()) {
+                return false;
+            }
+
+            $this->exclusion()
+                ->where('excludable_id', '!=', '*')
+                ->delete();
 
-        return true;
+            if (! static::hasExclusionWildcard()) {
+                return true;
+            }
+
+            Config::getExclusionModel()->create([
+                'type' => Exclusion::TYPE_INCLUDE,
+                'excludable_type' => $this->getMorphClass(),
+                'excludable_id' => $this->getKey(),
+            ]);
+
+            return true;
+        });
     }
 
     public static function excludeAllModels(array|Model $exceptions = []): void

src/Queries/HasExclusionQuery.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Maize\Excludable\Queries;
+
+use Illuminate\Database\Eloquent\Builder;
+use Illuminate\Database\Query\Builder as QueryBuilder;
+use Maize\Excludable\Models\Exclusion;
+use Maize\Excludable\Support\Config;
+
+class HasExclusionQuery
+{
+    public function __invoke(Builder $builder, $not = false): Builder
+    {
+        $model = $builder->getModel();
+        $exclusionModel = Config::getExclusionModel();
+
+        return $builder
+            ->whereHas(
+                relation: 'exclusion',
+                operator: $not ? '<' : '>='
+            )
+            ->whereIn(
+                column: $model->getQualifiedKeyName(),
+                values: fn (QueryBuilder $query) => $query
+                    ->select($exclusionModel->qualifyColumn('excludable_id'))
+                    ->from($exclusionModel->getTable())
+                    ->where($exclusionModel->qualifyColumn('type'), Exclusion::TYPE_INCLUDE)
+                    ->where($exclusionModel->qualifyColumn('excludable_type'), $model->getMorphClass())
+                    ->whereColumn($exclusionModel->qualifyColumn('excludable_id'), $model->getQualifiedKeyName()),
+                boolean: $not ? 'or' : 'and',
+                not: ! $not
+            );
+    }
+}

src/Scopes/ExclusionScope.php

@@ -5,8 +5,6 @@
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Scope;
-use Illuminate\Database\Query\Builder as QueryBuilder;
-use Maize\Excludable\Models\Exclusion;
 use Maize\Excludable\Support\Config;
 
 class ExclusionScope implements Scope
@@ -28,26 +26,8 @@ public function extend(Builder $builder): void
     protected function addWhereHasExclusion(Builder $builder): void
     {
         $builder->macro('whereHasExclusion', function (Builder $builder, $not = false) {
-            $model = $builder->getModel();
-            $exclusionModel = Config::getExclusionModel();
-
             return $builder->where(
-                fn (Builder $query) => $query
-                    ->whereHas(
-                        relation: 'exclusion',
-                        operator: $not ? '<' : '>='
-                    )
-                    ->whereIn(
-                        column: $model->getQualifiedKeyName(),
-                        values: fn (QueryBuilder $query) => $query
-                            ->select($exclusionModel->qualifyColumn('excludable_id'))
-                            ->from($exclusionModel->getTable())
-                            ->where($exclusionModel->qualifyColumn('type'), Exclusion::TYPE_INCLUDE)
-                            ->where($exclusionModel->qualifyColumn('excludable_type'), $model->getMorphClass())
-                            ->whereColumn($exclusionModel->qualifyColumn('excludable_id'), $model->getQualifiedKeyName()),
-                        boolean: $not ? 'or' : 'and',
-                        not: ! $not
-                    )
+                fn (Builder $query) => Config::getHasExclusionQuery()($query, $not)
             );
         });
     }

src/Support/Config.php

@@ -3,6 +3,7 @@
 namespace Maize\Excludable\Support;
 
 use Maize\Excludable\Models\Exclusion;
+use Maize\Excludable\Queries\HasExclusionQuery;
 
 class Config
 {
@@ -13,4 +14,12 @@ public static function getExclusionModel(): Exclusion
 
         return new $model;
     }
+
+    public static function getHasExclusionQuery(): HasExclusionQuery
+    {
+        /** @var string $query */
+        $query = config('excludable.has_exclusion_query') ?? HasExclusionQuery::class;
+
+        return new $query();
+    }
 }

src/Support/HasWildcardRelationships.php

@@ -7,7 +7,7 @@
 
 trait HasWildcardRelationships
 {
-    public function morphOneWildcard(string|Model $related, string $name, string $type = null, string $id = null, string $localKey = null): MorphOneWildcard
+    public function morphOneWildcard(string|Model $related, string $name, ?string $type = null, ?string $id = null, ?string $localKey = null): MorphOneWildcard
     {
         $instance = $this->newRelatedInstance($related);
 
@@ -25,7 +25,7 @@ protected function newMorphOneWildcard(Builder $query, Model $parent, string $ty
         return new MorphOneWildcard($query, $parent, $type, $id, $localKey);
     }
 
-    public function morphManyWildcard(string|Model $related, string $name, string $type = null, string $id = null, string $localKey = null): MorphManyWildcard
+    public function morphManyWildcard(string|Model $related, string $name, ?string $type = null, ?string $id = null, ?string $localKey = null): MorphManyWildcard
     {
         $instance = $this->newRelatedInstance($related);
 

tests/Events/ArticleExcludedEvent.php

@@ -6,10 +6,8 @@
 
 class ArticleExcludedEvent
 {
-    public Article $article;
-
-    public function __construct(Article $article)
-    {
-        $this->article = $article;
+    public function __construct(
+        public Article $article
+    ) {
     }
 }

tests/Events/ArticleExcludingEvent.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Maize\Excludable\Tests\Events;
+
+use Maize\Excludable\Tests\Models\Article;
+
+class ArticleExcludingEvent
+{
+    public function __construct(
+        public Article $article
+    ) {
+    }
+}