Merge branch 'main' into release

Author: toramanlis

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: toramanlis
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

Readme.md

@@ -19,6 +19,7 @@
 - [Configuration](#configuration)
     - [`database.model_paths`](#databasemodel_paths)
     - [`database.auto_infer_migrations`](#databaseauto_infer_migrations)
+    - [`database.implications.<implication_name_in_snake>`](#databaseimplicationsimplication_name_in_snake)
 - [Manual Migrations](#manual-migrations)
 - [Implication Reference](#implication-reference)
     - [`Table`](#table)
@@ -249,8 +250,6 @@ Alternatively, you can always install the package with `composer install toraman
 
 # Configuration
 
-There's very little configuration required for using this tool.
-
 ## `database.model_paths`
 
 An `array` of paths relative to the project directory where application models reside. The default is a single path the same as Laravel' default model path: `['app/Models']`
@@ -259,6 +258,10 @@ An `array` of paths relative to the project directory where application models r
 
 This is a `boolean` value that controls, you guessed it, whether or not to infer the migration information automatically. What this means is basically, unless specified otherwise with an implication, none of the models, properties or methods are going to be inspected for migration information. If a property or method of a model has an implication, that model will also be inspected. The default is `true`.
 
+## `database.implications.<implication_name_in_snake>`
+
+These are `boolean` values that can be used to enable or disable implications. The implication names have to be in snake case as per Laravel's convention of configuration keys e.g. `database.implications.foreign_key`. This set to `true` by default for all the implications.
+
 
 # Manual Migrations
 

src/Attributes/Applicable.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Toramanlis\ImplicitMigrations\Attributes;
+
+use Illuminate\Database\Schema\Blueprint;
+
+trait Applicable
+{
+    abstract public static function enabled(): bool;
+
+    abstract protected function process(Blueprint $table): Blueprint;
+
+    public function apply(Blueprint $table): Blueprint
+    {
+        if (!$this->enabled()) {
+            return $table;
+        }
+
+        return $this->process($table);
+    }
+}

src/Attributes/Column.php

@@ -3,18 +3,18 @@
 namespace Toramanlis\ImplicitMigrations\Attributes;
 
 use Attribute;
-use Exception;
+use Exception as BaseException;
 use Illuminate\Database\Schema\Blueprint;
 use ReflectionProperty;
 use Illuminate\Support\Str;
 use ReflectionNamedType;
 use ReflectionType;
-use Toramanlis\ImplicitMigrations\Blueprint\Exporters\ColumnExporter;
-use Toramanlis\ImplicitMigrations\Exceptions\ImplicationException;
 
 #[Attribute(Attribute::TARGET_PROPERTY | Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
 class Column extends MigrationAttribute
 {
+    use Applicable;
+
     public const TYPE_MAP = [
         'array' => 'json',
         'bool' => 'boolean',
@@ -49,6 +49,48 @@ class Column extends MigrationAttribute
         'computed' => ['expression'],
     ];
 
+    public const SUPPORTED_MODIFIERS = [
+        'after',
+        'autoIncrement',
+        'charset',
+        'collation',
+        'comment',
+        'default',
+        'first',
+        'from',
+        'invisible',
+        'nullable',
+        'storedAs',
+        'unsigned',
+        'useCurrent',
+        'useCurrentOnUpdate',
+        'virtualAs',
+        'generatedAs',
+        'always',
+    ];
+
+    public const SUPPORTED_ATTRIBUTES = [
+        'after',
+        'autoIncrement',
+        'comment',
+        'default',
+        'nullable',
+        'storedAs',
+        'unsigned',
+        'virtualAs',
+        'length',
+        'precision',
+        'total',
+        'places',
+        'allowed',
+        'fixed',
+        'subtype',
+        'srid',
+        'expression',
+        'collation',
+    ];
+
+
     protected bool $inferred = false;
 
     public function __construct(
@@ -115,53 +157,42 @@ public function inferFromReflectionProperty(ReflectionProperty $reflection): voi
     protected function validate(Blueprint $table)
     {
         if (empty($this->name)) {
-            throw new ImplicationException(ImplicationException::CODE_COL_NO_NAME, [$table->getTable()]);
+            throw new Exception(Exception::CODE_COL_NO_NAME, [$table->getTable()]);
         }
 
         if (null === $this->type) {
-            throw new ImplicationException(ImplicationException::CODE_COL_NO_TYPE, [$table->getTable(), $this->name]);
+            throw new Exception(Exception::CODE_COL_NO_TYPE, [$table->getTable(), $this->name]);
         }
     }
 
-    public function applyToBlueprint(Blueprint $table): Blueprint
+    protected function process(Blueprint $table): Blueprint
     {
         try {
             $this->validate($table);
-        } catch (ImplicationException $e) {
+        } catch (Exception $e) {
             if ($this->inferred) {
                 return $table;
             }
 
             throw $e;
-        } catch (Exception $e) {
+        } catch (BaseException $e) {
             $reportedName = $this->name ?? '???';
-            throw new ImplicationException(
-                ImplicationException::CODE_COL_GENERIC,
+            throw new Exception(
+                Exception::CODE_COL_GENERIC,
                 [$table->getTable(), $reportedName],
                 $e
             );
         }
 
-        $attributes = array_filter([
-            'after' => $this->after,
-            'autoIncrement' => $this->autoIncrement,
-            'comment' => $this->comment,
-            'default' => $this->default,
-            'nullable' => $this->nullable,
-            'storedAs' => $this->storedAs,
-            'unsigned' => $this->unsigned,
-            'virtualAs' => $this->virtualAs,
-            'length' => $this->length,
-            'precision' => $this->precision,
-            'total' => $this->total,
-            'places' => $this->places,
-            'allowed' => $this->allowed,
-            'fixed' => $this->fixed,
-            'subtype' => $this->subtype,
-            'srid' => $this->srid,
-            'expression' => $this->expression,
-            'collation' => $this->collation,
-        ], fn ($i) => null !== $i);
+        $attributes = [];
+
+        foreach (static::SUPPORTED_ATTRIBUTES as $attributeName) {
+            if (null === $this->{$attributeName}) {
+                continue;
+            }
+
+            $attributes[$attributeName] = $this->{$attributeName};
+        }
 
         $parameters = [];
         foreach (static::PARAMETER_MAP[$this->type] ?? [] as $parameterName) {
@@ -175,7 +206,7 @@ public function applyToBlueprint(Blueprint $table): Blueprint
         if (
             !empty(array_diff(
                 array_keys($attributes),
-                ColumnExporter::SUPPORTED_MODIFIERS,
+                static::SUPPORTED_MODIFIERS,
                 array_keys($parameters)
             ))
         ) {
@@ -185,7 +216,7 @@ public function applyToBlueprint(Blueprint $table): Blueprint
 
         $column = $table->{$this->type}($this->name, ...$parameters);
 
-        foreach (ColumnExporter::SUPPORTED_MODIFIERS as $modifier) {
+        foreach (static::SUPPORTED_MODIFIERS as $modifier) {
             if (!isset($attributes[$modifier])) {
                 continue;
             }

src/Exceptions/ImplicationException.php src/Attributes/Exception.phpsrc/Exceptions/ImplicationException.php renamed to src/Attributes/Exception.php

@@ -1,11 +1,11 @@
 <?php
 
-namespace Toramanlis\ImplicitMigrations\Exceptions;
+namespace Toramanlis\ImplicitMigrations\Attributes;
 
-use Exception;
+use Exception as BaseException;
 use Throwable;
 
-class ImplicationException extends Exception
+class Exception extends BaseException
 {
     final public const CODE_NONE = 0;
 

src/Attributes/ForeignKey.php

@@ -3,17 +3,18 @@
 namespace Toramanlis\ImplicitMigrations\Attributes;
 
 use Attribute;
-use Exception;
+use Exception as BaseException;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Schema\Blueprint;
 use ReflectionProperty;
 use Illuminate\Support\Str;
 use ReflectionClass;
-use Toramanlis\ImplicitMigrations\Exceptions\ImplicationException;
 
 #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 class ForeignKey extends MigrationAttribute
 {
+    use Applicable;
+
     protected string|Model $on;
     protected ?array $columns;
 
@@ -96,7 +97,7 @@ protected function getReferencedModelName(array $modelNames): string
             }
         }
 
-        throw new ImplicationException(ImplicationException::CODE_FK_NO_MODEL, [$this->columns[0]]);
+        throw new Exception(Exception::CODE_FK_NO_MODEL, [$this->columns[0]]);
     }
 
     protected function ensureColumn($columnName, Blueprint $table, array $blueprints, array $modelNames): void
@@ -112,7 +113,7 @@ protected function ensureColumn($columnName, Blueprint $table, array $blueprints
             $referencedTableName = $this->getReferenceTableName();
 
             if (!isset($blueprints[$referencedTableName])) {
-                throw new ImplicationException();
+                throw new Exception();
             }
 
             /** @var Blueprint */
@@ -136,8 +137,8 @@ protected function ensureColumn($columnName, Blueprint $table, array $blueprints
                     return;
                 }
 
-                throw new ImplicationException();
-            } catch (ImplicationException $e) {
+                throw new Exception();
+            } catch (Exception $e) {
                 $propertyReflection = new ReflectionProperty(
                     $this->getReferencedModelName($modelNames),
                     $this->references[0]
@@ -151,11 +152,11 @@ protected function ensureColumn($columnName, Blueprint $table, array $blueprints
                 $referencedTable->$type($this->references[0]);
                 return;
             }
-        } catch (ImplicationException $e) {
-            $table->unsignedBigInteger($columnName);
         } catch (Exception $e) {
-            throw new ImplicationException(
-                ImplicationException::CODE_FK_NO_COL,
+            $table->unsignedBigInteger($columnName);
+        } catch (BaseException $e) {
+            throw new Exception(
+                Exception::CODE_FK_NO_COL,
                 [$this->columns[0], $table->getTable()],
                 $e
             );
@@ -177,7 +178,7 @@ public function ensureColumns(Blueprint $table, array $blueprints, array $modelN
         $this->ensureColumn($columnName, $table, $blueprints, $modelNames);
     }
 
-    public function applyToBlueprint(Blueprint $table): Blueprint
+    protected function process(Blueprint $table): Blueprint
     {
         $references = is_array($this->references) && count($this->references) === 1
             ? $this->references[0]

src/Attributes/Index.php

@@ -7,13 +7,14 @@
 use Illuminate\Database\Schema\IndexDefinition;
 use ReflectionProperty;
 use Illuminate\Support\Str;
-use Toramanlis\ImplicitMigrations\Blueprint\IndexType;
-use Toramanlis\ImplicitMigrations\Exceptions\ImplicationException;
 use ValueError;
 
 #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 class Index extends MigrationAttribute
 {
+    use Applicable;
+
+
     protected ?array $columns;
 
     protected IndexType $type;
@@ -28,7 +29,7 @@ public function __construct(
         try {
             $this->type = IndexType::from(strtolower($type));
         } catch (ValueError $e) {
-            throw new ImplicationException(ImplicationException::CODE_IDX_NO_TYPE, [$type], $e);
+            throw new Exception(Exception::CODE_IDX_NO_TYPE, [$type], $e);
         }
 
         $this->columns = is_string($column) ? [$column] : $column;
@@ -69,14 +70,14 @@ public function ensureColumns(Blueprint $table): void
     protected function validate(Blueprint $table)
     {
         if (empty($this->columns)) {
-            throw new ImplicationException(
-                ImplicationException::CODE_IDX_NO_COL,
+            throw new Exception(
+                Exception::CODE_IDX_NO_COL,
                 [$table->getTable(), $this->type->name]
             );
         }
     }
 
-    public function applyToBlueprint(Blueprint $table): Blueprint
+    protected function process(Blueprint $table): Blueprint
     {
         $this->validate($table);
 

src/Blueprint/IndexType.php src/Attributes/IndexType.phpsrc/Blueprint/IndexType.php renamed to src/Attributes/IndexType.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace Toramanlis\ImplicitMigrations\Blueprint;
+namespace Toramanlis\ImplicitMigrations\Attributes;
 
 enum IndexType: string
 {

src/Attributes/MigrationAttribute.php

@@ -2,6 +2,8 @@
 
 namespace Toramanlis\ImplicitMigrations\Attributes;
 
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Str;
 use ReflectionClass;
 use ReflectionProperty;
 
@@ -18,4 +20,10 @@ public function inferFromReflectionClass(ReflectionClass $reflection): void
     public function inferFromExistingData(): void
     {
     }
+
+    public static function enabled(): bool
+    {
+        $key = Str::snake(last(explode('\\', static::class)));
+        return Config::get("database.implications.{$key}", false);
+    }
 }

src/Attributes/Primary.php

@@ -3,11 +3,6 @@
 namespace Toramanlis\ImplicitMigrations\Attributes;
 
 use Attribute;
-use Illuminate\Database\Schema\Blueprint;
-use Illuminate\Database\Schema\IndexDefinition;
-use ReflectionProperty;
-use Illuminate\Support\Str;
-use Toramanlis\ImplicitMigrations\Blueprint\IndexType;
 
 #[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
 class Primary extends Index