chore: Refactorisation du système Seeder

composer.json

@@ -23,6 +23,7 @@
     "require-dev": {
         "blitz-php/coding-standard": "^1.5",
         "blitz-php/framework": "^1.0.0-rc",
+        "fakerphp/faker": "^1.24",
         "kahlan/kahlan": "^6.1.0",
         "phpstan/phpstan": "^2.1.36"
     },

src/Commands/Seed.php

@@ -11,7 +11,7 @@
 
 namespace BlitzPHP\Database\Commands;
 
-use BlitzPHP\Container\Services;
+use BlitzPHP\Database\Connection\BaseConnection;
 use BlitzPHP\Database\Seeder\Seeder;
 use InvalidArgumentException;
 
@@ -34,55 +34,138 @@ class Seed extends DatabaseCommand
      * {@inheritDoc}
      */
     protected array $arguments = [
-        'name' => 'Nom du seedr a executer',
+        'name' => 'Nom du seeder à exécuter (ex: DatabaseSeeder ou Users\\UserSeeder)',
     ];
 
+    /**
+     * {@inheritDoc}
+     */
+    protected array $options = [
+        '--group'  => 'Groupe de connexion à utiliser',
+        '--silent' => 'Mode silencieux (pas de sortie)',
+        '--locale' => 'Langue à utiliser pour Faker (ex: fr_FR, en_US)',
+    ];
+
+    protected ?BaseConnection $db = null;
+
     /**
      * {@inheritDoc}
      */
     public function handle()
     {
-        if (empty($name = $this->argument('name'))) {
-            $name = $this->prompt(lang('Migrations.migSeeder'), null, static function ($val) {
+        $group = $this->option('group');
+        $silent = $this->option('silent') !== null;
+        $locale = $this->option('locale', config('app.language', 'fr_FR'));
+
+        $this->db = $this->resolver->connect($group);
+
+        $name = $this->getSeederName();
+
+        $seeder = $this->resolveSeeder($name);
+
+        $this->configureSeeder($seeder, $locale, $silent);
+
+        $this->runSeeder($seeder);
+
+        return EXIT_SUCCESS;
+    }
+
+    /**
+     * Récupère le nom du seeder
+     */
+    protected function getSeederName(): string
+    {
+        if (null !== $name = $this->argument('name')) {
+            return $name;
+        }
+
+        return $this->prompt(
+            'Quel seeder souhaitez-vous exécuter ?',
+            'DatabaseSeeder',
+            function ($val) {
                 if (empty($val)) {
                     throw new InvalidArgumentException('Veuillez entrer le nom du seeder.');
                 }
-
                 return $val;
-            });
-        }
+            }
+        );
+    }
 
-        $seedClass = APP_NAMESPACE . '\Database\Seeds\\';
-        $seedClass .= str_replace($seedClass, '', $name);
+    /**
+     * Résout la classe du seeder
+     */
+    protected function resolveSeeder(string $name): Seeder
+    {
+        // Chemins possibles
+        $paths = [
+            APP_NAMESPACE . '\\Database\\Seeds\\',
+            APP_NAMESPACE . '\\Database\\Seeders\\',
+            'Database\\Seeds\\',
+            'Database\\Seeders\\',
+        ];
+
+        $className = $name;
 
-        /**
-         * @var Seeder
-         */
-        $seeder = new $seedClass($this->db);
+        // Si le nom ne contient pas de namespace, on essaie les chemins standards
+        if (!str_contains($name, '\\')) {
+            foreach ($paths as $path) {
+                $fullClass = $path . $name;
+                if (class_exists($fullClass)) {
+                    $className = $fullClass;
+                    break;
+                }
+            }
+        }
 
-        if ($seeder->getLocale() === '') {
-            $seeder->setLocale(config('app.language'));
+        if (!class_exists($className)) {
+            throw new InvalidArgumentException(
+                "Le seeder '{$name}' n'a pas été trouvé.\n" .
+                "Chemins recherchés :\n" .
+                implode("\n", array_map(fn($p) => "- {$p}{$name}", $paths))
+            );
         }
 
-        $this->task('Demarrage du seed')->eol();
-        sleep(2);
-        $this->info('Remplissage en cours de traitement');
+        return new $className($this->db);
+    }
 
-        if (method_exists($seeder, 'run')) {
-            Services::container()->call([$seeder, 'run']);
+    /**
+     * Configure le seeder
+     */
+    protected function configureSeeder(Seeder $seeder, ?string $locale, bool $silent): void
+    {
+        if ($locale !== null) {
+            $seeder->setLocale($locale);
+        } elseif ($seeder->getLocale() === '') {
+            $seeder->setLocale(config('app.language', 'fr_FR'));
         }
 
-        $usedSeed = [
-            Services::container()->call([$seeder, 'execute']),
-            ...$seeder->getSeeded(),
+        if ($silent) {
+            $seeder->setSilent(true);
+        }
+    }
+
+    /**
+     * Exécute le seeder
+     */
+    protected function runSeeder(Seeder $seeder): void
+    {
+        $this->task('Démarrage du seed')->eol();
+
+        $this->info('Remplissage en cours...');
+
+        $seeder->setCommand($this)->execute();
+
+        $executed = [
+            $seeder::class,
+            ...$seeder->getCalled(),
         ];
 
-        $this->eol()->success('Opération terminée.');
+        $this->eol()->success('Opération terminée avec succès !');
 
-        foreach ($usedSeed as $seeded) {
-            $this->eol()->write('- ')->writer->yellow($seeded);
-        }
+        $this->eol()->write('Seeders exécutés :');
 
-        return EXIT_SUCCESS;
+        foreach (array_unique($executed) as $seeded) {
+            $this->eol()->write('  ✔ ')->writer->green($seeded);
+        }
     }
 }

src/Config/Services.php

@@ -12,6 +12,8 @@
 namespace BlitzPHP\Database\Config;
 
 use BlitzPHP\Container\Services as BaseServices;
+use BlitzPHP\Contracts\Database\BuilderInterface;
+use BlitzPHP\Contracts\Database\ConnectionInterface;
 use BlitzPHP\Database\Builder\BaseBuilder;
 use BlitzPHP\Database\Connection\BaseConnection;
 use BlitzPHP\Database\DatabaseManager;
@@ -32,7 +34,7 @@ class Services extends BaseServices
     /**
      * Récupère le gestionnaire de base de données
      */
-    protected static function manager(): DatabaseManager
+    public static function dbManager(): DatabaseManager
     {
         if (static::$manager === null) {
             static::$manager = new DatabaseManager(static::logger(), static::event());
@@ -43,10 +45,12 @@ protected static function manager(): DatabaseManager
 
     /**
      * Récupère une connexion à la base de données
+     * 
+     * @return BaseConnection
      */
-    public static function database(?string $group = null, bool $shared = true): BaseConnection
+    public static function database(?string $group = null, bool $shared = true): ConnectionInterface
     {
-        $connection = static::manager()->connect($group, $shared);
+        $connection = static::dbManager()->connect($group, $shared);
 
         if (!$connection instanceof BaseConnection) {
             throw new InvalidArgumentException('La connexion retournée n\'est pas une instance de BaseConnection');
@@ -57,16 +61,20 @@ public static function database(?string $group = null, bool $shared = true): Bas
 
     /**
      * Récupère un query builder
+     * 
+     * @return BaseBuilder
+     * 
+     * @deprecated 1.0 use static::database()->table($tablename) instead
      */
-    public static function builder(?string $group = null, bool $shared = true): BaseBuilder
+    public static function builder(?string $group = null, bool $shared = true): BuilderInterface
     {
         $key = 'builder_' . ($group ?? 'default');
 
         if ($shared && isset(static::$instances[$key])) {
             return static::$instances[$key];
         }
 
-        $builder = static::manager()->builder(static::database($group, $shared));
+        $builder = static::dbManager()->builder(static::database($group, $shared));
 
         if ($shared) {
             static::$instances[$key] = $builder;
@@ -78,7 +86,7 @@ public static function builder(?string $group = null, bool $shared = true): Base
     /**
      * Récupère un exportateur de base de données
      */
-    public static function dbExporter(?BaseConnection $db = null, array $config = [], bool $shared = true): Exporter
+    public static function dbExporter(?ConnectionInterface $db = null, array $config = [], bool $shared = true): Exporter
     {
         if ($shared) {
             return static::sharedInstance('dbExporter', $db, $config);
@@ -102,7 +110,7 @@ public static function dbExporter(?BaseConnection $db = null, array $config = []
     /**
      * Récupère un importateur de base de données
      */
-    public static function dbImporter(?BaseConnection $db = null, array $config = [], bool $shared = true): Importer
+    public static function dbImporter(?ConnectionInterface $db = null, array $config = [], bool $shared = true): Importer
     {
         if ($shared) {
             return static::sharedInstance('dbImporter', $db, $config);

src/Exceptions/DatabaseException.php

@@ -21,4 +21,9 @@ class DatabaseException extends Error implements ExceptionInterface
      * @var int
      */
     protected $code = 8;
+
+    protected static function t(string $message, array $args = []): string
+    {
+        return sprintf($message, $args);
+    }
 }

src/Exceptions/SeederException.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace BlitzPHP\Database\Exceptions;
+
+class SeederException extends DatabaseException
+{
+    public static function dataCannotBeEmpty()
+    {
+        return new static(static::t('Les données ne peuvent pas être vides.'));
+    }
+
+    public static function unspecifiedFakerMethod()
+    {
+        return new static(static::t('Méthode Faker non spécifiée.'));
+    }
+
+    public static function relationTableNotFound(string $table)
+    {
+        return new static(static::t("Table de relation '%s' non trouvée.", [$table]));
+    }
+
+    public static function propertyNotFound(string $property)
+    {
+        return new static(static::t("Propriété '%s' non trouvée.", [$property]));
+    }
+
+    public static function seederClassDoesNotExist(string $class)
+    {
+        return new static(static::t("La classe de seeder '%s' n'existe pas.", [$class]));
+    }
+}

src/Seeder/Factory.php

@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * This file is part of Blitz PHP framework - Database Layer.
+ *
+ * (c) 2022 Dimitri Sitchet Tomkeu <devcode.dst@gmail.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace BlitzPHP\Database\Seeder;
+
+use Faker\Factory as FakerFactory;
+use Faker\Generator as FakerGenerator;
+
+/**
+ * Générateur de configurations pour les seeders
+ * 
+ * @mixin FakerGenerator
+ */
+class Factory
+{
+    /**
+     * Instance Faker
+     */
+    protected FakerGenerator $faker;
+
+    /**
+     * Constructeur
+     */
+    public function __construct(string $locale = 'fr_FR')
+    {
+        $this->faker = FakerFactory::create($locale);
+    }
+
+    /**
+     * Appel Faker (retourne une configuration)
+     */
+    public function __call(string $name, array $arguments): array
+    {
+        if ($name === 'unique') {
+            return ['faker:unique', $arguments[0] ?? null, array_slice($arguments, 1) ?? []];
+        }
+
+        return ['faker', $name, $arguments];
+    }
+
+    /**
+     * Propriété Faker (retourne une configuration)
+     */
+    public function __get(string $name): array
+    {
+        return ['faker', $name, []];
+    }
+
+    /**
+     * Relation avec une autre table
+     */
+    public function relation(string $table, string $column = 'id'): array
+    {
+        return ['relation', $table, $column];
+    }
+
+    /**
+     * Valeur optionnelle
+     */
+    public function optional(float $weight = 0.5, mixed $default = null, mixed $value = null): array
+    {
+        if ($value === null) {
+            // Si pas de valeur fournie, on utilisera une closure
+            return ['optional', $weight, $default];
+        }
+        return ['optional', $weight, $default, $value];
+    }
+
+    /**
+     * Valeur fixe (pour compatibilité)
+     */
+    public function raw(mixed $value): mixed
+    {
+        return $value;
+    }
+}