Optimized database queries.

mikebronner · mikebronner · commit 424293e8dca2 · 2021-06-07T08:51:13.000-07:00
diff --git a/.nova/Configuration.json b/.nova/Configuration.json
@@ -0,0 +1,3 @@
+{
+  "workspace.color" : 4
+}
diff --git a/src/Providers/Service.php b/src/Providers/Service.php
@@ -56,27 +56,12 @@ function () {
                 $entityClass = app(config('genealabs-laravel-governor.models.entity'));
 
                 return (new $entityClass)
-                    ->with("group")
+                    ->select("name")
+                    ->with("group:name")
                     ->orderBy("name")
                     ->get();
             }
         );
-        $this->app->singleton(
-            'governor-permissions',
-            function () {
-                $permissionClass = app(config('genealabs-laravel-governor.models.permission'));
-
-                return (new $permissionClass)
-                    ->where(function ($query) {
-                        $roleNames = auth()->user()->roles->pluck("name")->toArray();
-                        $teamIds = auth()->user()->teams->pluck("id")->toArray();
-
-                        $query->whereIn("role_name", $roleNames)
-                            ->orWhereIn("team_id", $teamIds);
-                    })
-                    ->get();
-            }
-        );
 
         $this->mergeConfigFrom(__DIR__ . '/../../config/config.php', 'genealabs-laravel-governor');
         $this->commands(Publish::class);
diff --git a/src/Traits/Governable.php b/src/Traits/Governable.php
@@ -1,23 +1,28 @@
-<?php namespace GeneaLabs\LaravelGovernor\Traits;
+<?php
+
+declare(strict_types=1);
+
+namespace GeneaLabs\LaravelGovernor\Traits;
 
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Relations\BelongsTo;
 use Illuminate\Database\Eloquent\Relations\MorphToMany;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
 
 trait Governable
 {
     use EntityManagement;
 
-    protected function applyPermissionToQuery(Builder $query, string $ability) : Builder
+    protected function applyPermissionToQuery(Builder $query, string $ability): Builder
     {
         $entityName = $this->getEntityFromModel(get_class($this));
         $ownerships = $this->getOwnershipsForEntity($entityName, $ability);
-        
+
         return $this->filterQuery($query, $ownerships);
     }
 
-    protected function filterQuery(Builder $query, Collection $ownerships) : Builder
+    protected function filterQuery(Builder $query, Collection $ownerships): Builder
     {
         if ($ownerships->contains("any")
             || auth()->user()->hasRole("SuperAdmin")
@@ -52,7 +57,7 @@ protected function filterQuery(Builder $query, Collection $ownerships) : Builder
             if ($query->getModel()->getTable() === $authTable) {
                 return $query->where($query->getModel()->getKeyName(), auth()->user()->getKey());
             }
-            
+
             return $query->where(
                 "{$query->getModel()->getTable()}.governor_owned_by",
                 auth()->user()->getKey()
@@ -62,29 +67,39 @@ protected function filterQuery(Builder $query, Collection $ownerships) : Builder
         return $query->whereRaw("1 = 2");
     }
 
-    protected function getOwnershipsForEntity(string $entityName, string $ability) : Collection
-    {
+    protected function getOwnershipsForEntity(
+        string $entityName,
+        string $ability,
+    ): Collection {
         if (! $entityName) {
             return collect();
         }
 
-        $result = app("governor-permissions")
-            ->where("action_name", $ability)
-            ->where("entity_name", $entityName)
-            ->pluck("ownership_name");
+        $permissionClass = app(config('genealabs-laravel-governor.models.permission'));
+        $result = Cache::remember(
+            "governor-permissions",
+            5,
+            function () use ($ability, $entityName, $permissionClass) {
+                return (new $permissionClass)
+                    ->select("ownership_name")
+                    ->where("action_name", $ability)
+                    ->where("entity_name", $entityName)
+                    ->get();
+            },
+        );
 
         return $result;
     }
 
-    public function ownedBy() : BelongsTo
+    public function ownedBy(): BelongsTo
     {
         return $this->belongsTo(
             config("genealabs-laravel-governor.models.auth"),
             "governor_owned_by"
         );
     }
 
-    public function teams() : MorphToMany
+    public function teams(): MorphToMany
     {
         return $this->MorphToMany(
             config("genealabs-laravel-governor.models.team"),
@@ -93,32 +108,32 @@ public function teams() : MorphToMany
         );
     }
 
-    public function scopeDeletable(Builder $query) : Builder
+    public function scopeDeletable(Builder $query): Builder
     {
         return $this->applyPermissionToQuery($query, "delete");
     }
 
-    public function scopeForceDeletable(Builder $query) : Builder
+    public function scopeForceDeletable(Builder $query): Builder
     {
         return $this->applyPermissionToQuery($query, "forceDelete");
     }
 
-    public function scopeRestorable(Builder $query) : Builder
+    public function scopeRestorable(Builder $query): Builder
     {
         return $this->applyPermissionToQuery($query, "restore");
     }
 
-    public function scopeUpdatable(Builder $query) : Builder
+    public function scopeUpdatable(Builder $query): Builder
     {
         return $this->applyPermissionToQuery($query, "update");
     }
 
-    public function scopeViewable(Builder $query) : Builder
+    public function scopeViewable(Builder $query): Builder
     {
         return $this->applyPermissionToQuery($query, "view");
     }
 
-    public function scopeViewAnyable(Builder $query) : Builder
+    public function scopeViewAnyable(Builder $query): Builder
     {
         return $this->applyPermissionToQuery($query, "viewAny");
     }
diff --git a/src/Traits/Governing.php b/src/Traits/Governing.php
@@ -1,47 +1,69 @@
-<?php namespace GeneaLabs\LaravelGovernor\Traits;
+<?php
+
+declare(strict_types=1);
+
+namespace GeneaLabs\LaravelGovernor\Traits;
 
 use Illuminate\Database\Eloquent\Relations\BelongsToMany;
 use Illuminate\Database\Eloquent\Relations\HasMany;
 use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
 
 trait Governing
 {
     use Governable;
-    
-    public function hasRole(string $name) : bool
+
+    public function hasRole(string $name): bool
     {
-        if ($this->roles->isEmpty()) {
+        $roles = Cache::remember(
+            "roles" . auth()->user()->getKey(),
+            5,
+            function () {
+                return $this->roles()
+                    ->select('name')
+                    ->get();
+            }
+        );
+
+        if ($roles->count() === 0) {
             return false;
         }
 
         $roleClass = config("genealabs-laravel-governor.models.role");
-        $role = (new $roleClass)
-            ->find($name);
+        $role = Cache::remember(
+            "role{$roleClass}{$name}",
+            5,
+            function () use ($name, $roleClass) {
+                return (new $roleClass)
+                    ->select('name')
+                    ->find($name);
+            },
+        );
 
         if (! $role) {
             return false;
         }
 
-        return $this->roles->contains($role->name)
-            || $this->roles->contains("SuperAdmin");
+        return $roles->contains($role->name)
+            || $roles->contains("SuperAdmin");
     }
 
-    public function roles() : BelongsToMany
+    public function roles(): BelongsToMany
     {
         $roleClass = config("genealabs-laravel-governor.models.role");
 
         return $this->belongsToMany($roleClass, 'governor_role_user', 'user_id', 'role_name');
     }
 
-    public function ownedTeams() : HasMany
+    public function ownedTeams(): HasMany
     {
         return $this->hasMany(
             config("genealabs-laravel-governor.models.team"),
             "governor_owned_by"
         );
     }
 
-    public function teams() : BelongsToMany
+    public function teams(): BelongsToMany
     {
         return $this->belongsToMany(
             config('genealabs-laravel-governor.models.team'),
@@ -51,15 +73,15 @@ public function teams() : BelongsToMany
         );
     }
 
-    public function getPermissionsAttribute() : Collection
+    public function getPermissionsAttribute(): Collection
     {
         $permissionClass = config("genealabs-laravel-governor.models.permission");
         $roleNames = $this->roles->pluck('name');
 
         return (new $permissionClass)->whereIn('role_name', $roleNames)->get();
     }
 
-    public function getEffectivePermissionsAttribute() : Collection
+    public function getEffectivePermissionsAttribute(): Collection
     {
         $results = collect();
         $groupedPermissions = $this->permissions
diff --git a/src/Traits/GovernorOwnedByField.php b/src/Traits/GovernorOwnedByField.php
@@ -1,8 +1,13 @@
-<?php namespace GeneaLabs\LaravelGovernor\Traits;
+<?php
+
+declare(strict_types=1);
+
+namespace GeneaLabs\LaravelGovernor\Traits;
 
 use GeneaLabs\LaravelGovernor\Policies\BasePolicy;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Cache;
 use Illuminate\Support\Facades\Schema;
 use ReflectionClass;
 
@@ -27,7 +32,7 @@ protected function createGovernorOwnedByFieldsByPolicy(BasePolicy $policy) : boo
         return $this->createGovernorOwnedByFields($model);
     }
 
-    protected function createGovernorOwnedByFields(Model $model) : bool
+    protected function createGovernorOwnedByFields(Model $model): bool
     {
         if (! in_array("GeneaLabs\\LaravelGovernor\\Traits\\Governable", class_uses_recursive($model))) {
             return false;
@@ -36,9 +41,17 @@ protected function createGovernorOwnedByFields(Model $model) : bool
         $connection = $model
             ->getConnection()
             ->getName();
-        $governorOwnedByExists = Schema::connection($connection)
-            ->hasColumn($model->getTable(), 'governor_owned_by');
-        
+        $table = $model->getTable();
+
+        $governorOwnedByExists = Cache::remember(
+            "{$connection}{$table}governor_owned_by",
+            5,
+            function () use ($connection, $model, $table) {
+                return Schema::connection($connection)
+                    ->hasColumn($model->getTable(), 'governor_owned_by');
+            },
+        );
+
         if ($governorOwnedByExists) {
             return false;
         }

Original file line number	Diff line number	Diff line change
`@@ -1,23 +1,28 @@`
`1`		`-<?php namespace GeneaLabs\LaravelGovernor\Traits;`
	`1`	`+<?php`
	`2`	`+`
	`3`	`+declare(strict_types=1);`
	`4`	`+`
	`5`	`+namespace GeneaLabs\LaravelGovernor\Traits;`
`2`	`6`
`3`	`7`	`use Illuminate\Database\Eloquent\Builder;`
`4`	`8`	`use Illuminate\Database\Eloquent\Relations\BelongsTo;`
`5`	`9`	`use Illuminate\Database\Eloquent\Relations\MorphToMany;`
`6`	`10`	`use Illuminate\Support\Collection;`
	`11`	`+use Illuminate\Support\Facades\Cache;`
`7`	`12`
`8`	`13`	`trait Governable`
`9`	`14`	`{`
`10`	`15`	`use EntityManagement;`
`11`	`16`
`12`		`- protected function applyPermissionToQuery(Builder $query, string $ability) : Builder`
	`17`	`+ protected function applyPermissionToQuery(Builder $query, string $ability): Builder`
`13`	`18`	`{`
`14`	`19`	`$entityName = $this->getEntityFromModel(get_class($this));`
`15`	`20`	`$ownerships = $this->getOwnershipsForEntity($entityName, $ability);`
`16`		`-`
	`21`	`+`
`17`	`22`	`return $this->filterQuery($query, $ownerships);`
`18`	`23`	`}`
`19`	`24`
`20`		`- protected function filterQuery(Builder $query, Collection $ownerships) : Builder`
	`25`	`+ protected function filterQuery(Builder $query, Collection $ownerships): Builder`
`21`	`26`	`{`
`22`	`27`	`if ($ownerships->contains("any")`
`23`	`28`	`\|\| auth()->user()->hasRole("SuperAdmin")`
`@@ -52,7 +57,7 @@ protected function filterQuery(Builder $query, Collection $ownerships) : Builder`
`52`	`57`	`if ($query->getModel()->getTable() === $authTable) {`
`53`	`58`	`return $query->where($query->getModel()->getKeyName(), auth()->user()->getKey());`
`54`	`59`	`}`
`55`		`-`
	`60`	`+`
`56`	`61`	`return $query->where(`
`57`	`62`	`"{$query->getModel()->getTable()}.governor_owned_by",`
`58`	`63`	`auth()->user()->getKey()`
`@@ -62,29 +67,39 @@ protected function filterQuery(Builder $query, Collection $ownerships) : Builder`
`62`	`67`	`return $query->whereRaw("1 = 2");`
`63`	`68`	`}`
`64`	`69`
`65`		`- protected function getOwnershipsForEntity(string $entityName, string $ability) : Collection`
`66`		`- {`
	`70`	`+ protected function getOwnershipsForEntity(`
	`71`	`+ string $entityName,`
	`72`	`+ string $ability,`
	`73`	`+ ): Collection {`
`67`	`74`	`if (! $entityName) {`
`68`	`75`	`return collect();`
`69`	`76`	`}`
`70`	`77`
`71`		`- $result = app("governor-permissions")`
`72`		`- ->where("action_name", $ability)`
`73`		`- ->where("entity_name", $entityName)`
`74`		`- ->pluck("ownership_name");`
	`78`	`+ $permissionClass = app(config('genealabs-laravel-governor.models.permission'));`
	`79`	`+ $result = Cache::remember(`
	`80`	`+ "governor-permissions",`
	`81`	`+ 5,`
	`82`	`+ function () use ($ability, $entityName, $permissionClass) {`
	`83`	`+ return (new $permissionClass)`
	`84`	`+ ->select("ownership_name")`
	`85`	`+ ->where("action_name", $ability)`
	`86`	`+ ->where("entity_name", $entityName)`
	`87`	`+ ->get();`
	`88`	`+ },`
	`89`	`+ );`
`75`	`90`
`76`	`91`	`return $result;`
`77`	`92`	`}`
`78`	`93`
`79`		`- public function ownedBy() : BelongsTo`
	`94`	`+ public function ownedBy(): BelongsTo`
`80`	`95`	`{`
`81`	`96`	`return $this->belongsTo(`
`82`	`97`	`config("genealabs-laravel-governor.models.auth"),`
`83`	`98`	`"governor_owned_by"`
`84`	`99`	`);`
`85`	`100`	`}`
`86`	`101`
`87`		`- public function teams() : MorphToMany`
	`102`	`+ public function teams(): MorphToMany`
`88`	`103`	`{`
`89`	`104`	`return $this->MorphToMany(`
`90`	`105`	`config("genealabs-laravel-governor.models.team"),`
`@@ -93,32 +108,32 @@ public function teams() : MorphToMany`
`93`	`108`	`);`
`94`	`109`	`}`
`95`	`110`
`96`		`- public function scopeDeletable(Builder $query) : Builder`
	`111`	`+ public function scopeDeletable(Builder $query): Builder`
`97`	`112`	`{`
`98`	`113`	`return $this->applyPermissionToQuery($query, "delete");`
`99`	`114`	`}`
`100`	`115`
`101`		`- public function scopeForceDeletable(Builder $query) : Builder`
	`116`	`+ public function scopeForceDeletable(Builder $query): Builder`
`102`	`117`	`{`
`103`	`118`	`return $this->applyPermissionToQuery($query, "forceDelete");`
`104`	`119`	`}`
`105`	`120`
`106`		`- public function scopeRestorable(Builder $query) : Builder`
	`121`	`+ public function scopeRestorable(Builder $query): Builder`
`107`	`122`	`{`
`108`	`123`	`return $this->applyPermissionToQuery($query, "restore");`
`109`	`124`	`}`
`110`	`125`
`111`		`- public function scopeUpdatable(Builder $query) : Builder`
	`126`	`+ public function scopeUpdatable(Builder $query): Builder`
`112`	`127`	`{`
`113`	`128`	`return $this->applyPermissionToQuery($query, "update");`
`114`	`129`	`}`
`115`	`130`
`116`		`- public function scopeViewable(Builder $query) : Builder`
	`131`	`+ public function scopeViewable(Builder $query): Builder`
`117`	`132`	`{`
`118`	`133`	`return $this->applyPermissionToQuery($query, "view");`
`119`	`134`	`}`
`120`	`135`
`121`		`- public function scopeViewAnyable(Builder $query) : Builder`
	`136`	`+ public function scopeViewAnyable(Builder $query): Builder`
`122`	`137`	`{`
`123`	`138`	`return $this->applyPermissionToQuery($query, "viewAny");`
`124`	`139`	`}`