wip

Author: riccardodallavia

README.md

@@ -16,19 +16,6 @@ You can install the package via composer:
 composer require maize-tech/laravel-prunable-fields
 ```
 
-You can publish the config file with:
-
-```bash
-php artisan vendor:publish --tag="prunable-fields-config"
-```
-
-This is the contents of the published config file:
-
-```php
-return [
-];
-```
-
 ## Usage
 
 ```php

composer.json

@@ -17,8 +17,11 @@
     ],
     "require": {
         "php": "^8.0",
-        "spatie/laravel-package-tools": "^1.9.2",
-        "illuminate/contracts": "^9.0"
+        "illuminate/console": "^9.0",
+        "illuminate/database": "^9.0",
+        "illuminate/events": "^9.0",
+        "illuminate/support": "^9.0",
+        "spatie/laravel-package-tools": "^1.9.2"
     },
     "require-dev": {
         "friendsofphp/php-cs-fixer": "^3.8",
@@ -57,10 +60,7 @@
         "laravel": {
             "providers": [
                 "Maize\\PrunableFields\\PrunableFieldsServiceProvider"
-            ],
-            "aliases": {
-                "PrunableFields": "Maize\\PrunableFields\\Facades\\PrunableFields"
-            }
+            ]
         }
     },
     "minimum-stability": "dev",

config/prunable-fields.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Maize\PrunableFields\Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Maize\PrunableFields\Tests\Models\MassPrunableUser;
+
+class MassPrunableUserFactory extends Factory
+{
+    protected $model = MassPrunableUser::class;
+
+    public function definition()
+    {
+        return [
+            'first_name' => $this->faker->firstName,
+            'last_name' => $this->faker->lastName,
+            'email' => $this->faker->email,
+        ];
+    }
+}

database/factories/MassPrunableUserFactory.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Maize\PrunableFields\Database\Factories;
+
+use Illuminate\Database\Eloquent\Factories\Factory;
+use Maize\PrunableFields\Tests\Models\PrunableUser;
+
+class PrunableUserFactory extends Factory
+{
+    protected $model = PrunableUser::class;
+
+    public function definition()
+    {
+        return [
+            'first_name' => $this->faker->firstName,
+            'last_name' => $this->faker->lastName,
+            'email' => $this->faker->email,
+        ];
+    }
+}

database/factories/ModelFactory.php

@@ -0,0 +1,121 @@
+<?php
+
+namespace Maize\PrunableFields\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Database\Eloquent\SoftDeletes;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Support\Str;
+use InvalidArgumentException;
+use Maize\PrunableFields\Events\ModelsFieldsPruned;
+use Maize\PrunableFields\MassPrunableFields;
+use Maize\PrunableFields\PrunableFields;
+use Symfony\Component\Finder\Finder;
+
+class PruneFieldsCommand extends Command
+{
+    protected $signature = 'model:prune-fields
+                                {--model=* : Class names of the models to be pruned}
+                                {--chunk=1000 : The number of models to retrieve per chunk of models to be pruned}
+                                {--pretend : Display the number of prunable records found instead of pruning them}';
+
+    public $description = 'Prune model fields that are no longer needed';
+
+    public function handle(): void
+    {
+        $models = $this->models();
+
+        if ($models->isEmpty()) {
+            $this->info('No prunable models found.');
+
+            return;
+        }
+
+        if ($this->option('pretend')) {
+            $models->each(fn ($model) => $this->pretendToPrune($model));
+
+            return;
+        }
+
+        Event::listen(ModelsFieldsPruned::class, function ($event) {
+            $this->info("{$event->count} [{$event->model}] records have been pruned.");
+        });
+
+        $models->each(function ($model) {
+            $instance = new $model();
+
+            $chunkSize = property_exists($instance, 'prunableFieldsChunkSize')
+                ? $instance->prunableFieldsChunkSize
+                : $this->option('chunk');
+
+            $total = $this->isPrunable($model)
+                ? $instance->pruneAllFields($chunkSize)
+                : 0;
+
+            if ($total === 0) {
+                $this->info("No prunable [$model] records found.");
+            }
+        });
+
+        Event::forget(ModelsFieldsPruned::class);
+    }
+
+    protected function models(): Collection
+    {
+        if (! empty($models = $this->option('model'))) {
+            return collect($models)
+                ->filter(fn ($model) => class_exists($model))
+                ->values();
+        }
+
+        $except = $this->option('except');
+
+        if (! empty($models) && ! empty($except)) {
+            throw new InvalidArgumentException('The --models and --except options cannot be combined.');
+        }
+
+        return collect((new Finder())->in($this->getDefaultPath())->files()->name('*.php'))
+            ->map(function ($model) {
+                $namespace = $this->laravel->getNamespace();
+
+                return $namespace.str_replace(
+                    ['/', '.php'],
+                    ['\\', ''],
+                    Str::after($model->getRealPath(), realpath(app_path()).DIRECTORY_SEPARATOR)
+                );
+            })
+            ->when(! empty($except), function ($models) use ($except) {
+                return $models->reject(fn ($model) => in_array($model, $except));
+            })
+            ->filter(fn ($model) => $this->isPrunable($model))
+            ->filter(fn ($model) => class_exists($model))
+            ->values();
+    }
+
+    protected function isPrunable(string $model): bool
+    {
+        $uses = class_uses_recursive($model);
+
+        return in_array(PrunableFields::class, $uses) || in_array(MassPrunableFields::class, $uses);
+    }
+
+    protected function pretendToPrune(string $model): void
+    {
+        $instance = new $model();
+
+        $count = $instance
+            ->prunableFields()
+            ->when(
+                in_array(SoftDeletes::class, class_uses_recursive(get_class($instance))),
+                fn ($query) => $query->withTrashed()
+            )
+            ->count();
+
+        if ($count === 0) {
+            $this->info("No prunable [$model] records found.");
+        } else {
+            $this->info("{$count} [{$model}] records will be pruned.");
+        }
+    }
+}