feat: add console commands to back up tables

Author: WatheqAlshowaiter

README.md

@@ -25,6 +25,9 @@ composer require watheqalshowaiter/backup-tables
 Use the `BackupTables::generateBackup($tableToBackup)` Facade anywhere in your application and it will
 generate `$tableToBackup_backup_2024_08_22_17_40_01` table in the database with all the data and structure. Note that
 the datetime `2024_08_22_17_40_01` will be varied based on your datetime.
+ 
+You can also use the `php artisan backup:tables <targets>` command to back up tables,
+where `<targets>` is a space-separated list of tables names or models.
 
 ```php
 use WatheqAlshowaiter\BackupTables\BackupTables; // import the facade
@@ -35,7 +38,7 @@ class ChangeSomeData
     {
         BackupTables::generateBackup('users'); // will result: users_backup_2024_08_22_17_40_01
 
-        // change some data.. 
+        // change some data..
     }
 }
 ```
@@ -75,6 +78,12 @@ BackupTables::generateBackup('users', 'Y_d_m_H'); // can not generate the same b
 BackupTables::generateBackup('users', 'Y_d_m'); // can not generate the same backup in the same day
 ```
 
+- Using the artisan command for one or more tables/models
+```bash
+php artisan backup:tables users posts # users_backup_2024_08_22_17_40_01, posts_backup_2024_08_22_17_40_01
+php artisan backup:tables \App\Models\User \App\Models\Post # users_backup_2024_08_22_17_40_01, posts_backup_2024_08_22_17_40_01
+```
+
 ## Why?
 
 Sometimes you want to backup some database tables before changing data for whatever reason, this package serves this
@@ -84,6 +93,8 @@ beforehand.
 
 ## Features
 
+✅ Backup tables from the code or from the console command.
+ 
 ✅ Supports Laravel versions: 11, 10, 9, 8, 7, and 6.
 
 ✅ Supports PHP versions: 8.2, 8.1, 8.0, and 7.4.

src/BackupTablesServiceProvider.php

@@ -3,6 +3,7 @@
 namespace WatheqAlshowaiter\BackupTables;
 
 use Illuminate\Support\ServiceProvider;
+use WatheqAlshowaiter\BackupTables\Commands\BackupTableCommand;
 
 class BackupTablesServiceProvider extends ServiceProvider
 {
@@ -13,9 +14,14 @@ public function register()
 
     public function boot()
     {
-        // This migration works only in the package test
-        if ($this->app->runningInConsole() && $this->app->environment() === 'testing') {
-            $this->loadMigrationsFrom(__DIR__.'/../tests/database/migrations');
+        if ($this->app->runningInConsole()) {
+            $this->commands([
+                BackupTableCommand::class,
+            ]);
+
+            if($this->app->environment() === 'testing'){
+                $this->loadMigrationsFrom(__DIR__.'/../tests/database/migrations');
+            }
         }
     }
 }

src/Commands/BackupTableCommand.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace WatheqAlshowaiter\BackupTables\Commands;
+
+use Illuminate\Console\Command;
+use Symfony\Component\Console\Command\Command as CommandCodes;
+use WatheqAlshowaiter\BackupTables\BackupTables;
+
+class BackupTableCommand extends Command
+{
+    protected $signature = 'backup:tables {targets* : The table names or model classes to backup (space-separated)}';
+
+    protected $description = 'Backup a specific database table/s based on provided table names or model classes';
+
+    public function handle()
+    {
+        $tables = $this->argument('targets');
+
+        $tables = $this->getMultipleTables($tables);
+
+        try {
+            $result = BackupTables::generateBackup($tables);
+
+            if (!$result) {
+                $this->error('Failed to backup table.');
+                return CommandCodes::FAILURE;
+            }
+
+            return CommandCodes::SUCCESS;
+        } catch (\Exception $e) {
+            $this->error("Error backing up table: {$e->getMessage()}");
+            return CommandCodes::FAILURE;
+        }
+    }
+
+    /**
+     * @param $table
+     *
+     * @return false|string[]
+     */
+    private function getMultipleTables($table)
+    {
+        $tablesArr = explode(' ', $table);
+
+        return array_filter($tablesArr, function ($item) {
+            return !empty($item);
+        });
+    }
+}

tests/BackupTableCommandTest.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace WatheqAlshowaiter\BackupTables\Tests;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Schema;
+use WatheqAlshowaiter\BackupTables\Commands\BackupTableCommand;
+use WatheqAlshowaiter\BackupTables\Tests\Models\Father;
+use WatheqAlshowaiter\BackupTables\Tests\Models\Mother;
+
+class BackupTableCommandTest extends TestCase
+{
+    use RefreshDatabase;
+
+    /** @test */
+    public function it_can_backup_a_table()
+    {
+        Schema::create('test_table', function ($table) {
+            $table->id();
+            $table->string('name');
+            $table->timestamps();
+        });
+
+        $this->artisan('backup:tables', ['targets' => 'test_table'])
+            ->assertSuccessful();
+
+        $backupTablePattern = 'test_table_backup_'.now()->format('Y_m_d_H_i_s');
+
+        $this->assertTrue(
+            Schema::hasTable($backupTablePattern),
+            "Backup table was not created"
+        );
+    }
+
+    /** @test */
+    public function it_can_backup_a_table_by_classname()
+    {
+        Schema::create('test_table', function ($table) {
+            $table->id();
+            $table->string('name');
+            $table->timestamps();
+        });
+
+        $this->artisan(BackupTableCommand::class, ['targets' => 'test_table'])
+            ->assertSuccessful();
+
+        $backupTablePattern = 'test_table_backup_'.now()->format('Y_m_d_H_i_s');
+
+        $this->assertTrue(
+            Schema::hasTable($backupTablePattern),
+            "Backup table was not created"
+        );
+    }
+
+    /** @test */
+    public function it_fails_when_table_does_not_exist()
+    {
+        $this->artisan('backup:tables', ['targets' => 'non_existent_table'])
+            ->assertFailed();
+    }
+
+    /** @test */
+    public function it_can_backup_multiple_tables()
+    {
+        $tables = ['test_table_1', 'test_table_2'];
+
+        foreach ($tables as $table) {
+            Schema::create($table, function ($table) {
+                $table->id();
+                $table->string('name');
+                $table->timestamps();
+            });
+        }
+
+        $this->artisan('backup:tables', ['targets' => implode('  ', $tables)])
+            ->assertSuccessful();
+
+        foreach ($tables as $table) {
+            $backupTablePattern = $table.'_backup_'.now()->format('Y_m_d_H_i_s');
+
+            $this->assertTrue(
+                Schema::hasTable($backupTablePattern),
+                "Backup table was not created"
+            );
+        }
+
+    }
+
+    /** @test */
+    public function it_can_backup_multiple_models()
+    {
+        $models = [Father::class, Mother::class];
+
+        $this->artisan('backup:tables', ['targets' => implode('  ', $models)])
+            ->assertSuccessful();
+
+        $backupTablePattern1 = 'fathers_backup_'.now()->format('Y_m_d_H_i_s');
+        $backupTablePattern2 = 'mothers_backup_'.now()->format('Y_m_d_H_i_s');
+
+        $this->assertTrue(
+            Schema::hasTable($backupTablePattern1),
+            "Backup table was not created"
+        );
+
+        $this->assertTrue(
+            Schema::hasTable($backupTablePattern2),
+            "Backup table was not created"
+        );
+    }
+
+    /** @test */
+    public function it_fails_when_any_table_does_not_exist()
+    {
+        Schema::create('existing_table', function ($table) {
+            $table->id();
+            $table->timestamps();
+        });
+
+        $this->artisan('backup:tables', ['targets' => 'existing_table non_existent_table'])
+            ->assertSuccessful();
+    }
+}