Create SimpleMigration option

[mylesduncanking]

Migration classes seem to be very bloated especially when creating a simple migration that just adds set of columns.

I have created a "SimpleMigration" class which I use to add columns but think others may find it useful if it was added properly.

I think there is more that could be done with this and my code below is best viewed as a "proof of concept" sort of thing.

A useful point to note is that there is also "predefined" types based on the column names so if the name contains "_id" but no type is specified it will default to "unsignedBigInteger".

Migration file:

<?php

use App\Helpers\Classes\SimpleMigration;

class AddOwnerToOpportunities extends SimpleMigration
{
    public $table = 'opportunities'; // Use $table property to update existing table, $create property to create new table
    public $up = [
        'user_id' => ['after:id', 'nullable', 'index'], // Translates to $table->unsignedBigInteger('user_id')->after('id')->index()->nullable()
        'assigned_at' => ['after:user_id', 'nullable'], // Translates to $table->timestamp('assigned_at')->nullable()
        'set:type,arr:private|corporate' => ['after:assigned_at', 'index'] // Translates to $table->set('type', array('private', 'corporate'))->after('assigned_at')->index()
    ];
}

SimpleMigration class:

<?php

namespace App\Helpers\Classes;

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class SimpleMigration extends Migration
{
    private $presetMethods = [
        '_id' => 'unsignedBigInteger',
        '_at' => 'timestamp',
    ];

    private $nonDefaultable = [
        'softDeletesTz',
        'softDeletes',
        'timestampsTz',
        'timestamps',
        'id',
        'rememberToken',
    ];

    public function up()
    {
        $schemaMethod = property_exists($this, 'table') ? 'table' : 'create';
        $tableName    = $this->$schemaMethod;

        Schema::$schemaMethod($tableName, function (Blueprint $table) {
            foreach ($this->up as $typeName => $options) {
                list($type, $args) = $this->getMethodArgs($typeName, 'string');
                $column = call_user_func_array([$table, $type], $args);

                foreach ($options as $option) {
                    list($method, $args) = $this->getMethodArgs($option);
                    call_user_func_array([$column, $method], $args);
                }
            }
        });
    }

    public function down()
    {
        if (property_exists($this, 'create')) {
            Schema::dropIfExists($this->create);
        } else {
            Schema::table($this->table, function (Blueprint $table) {
                foreach (array_keys($this->up) as $typeName) {
                    $column = $this->getMethodArgs($typeName, 'string')[1][0];

                    if (Schema::hasColumn($this->table, $column)) {
                        $table->dropColumn($column);
                    }
                }
            });
        }
    }

    public function getMethodArgs(string $colonSeperatedString, ?string $defaultMethod = null): array
    {
        if (strpos($colonSeperatedString, ':') === false) {
            $colonSeperatedString = $colonSeperatedString . ':';
        }

        $method = explode(':', $colonSeperatedString)[0];
        $args   = array_filter(explode(',', substr($colonSeperatedString, strlen($method) + 1)));

        if (empty($args)) {
            foreach ($this->presetMethods as $needle => $presetMethod) {
                if (stripos($method, $needle)) {
                    $args = [$method];
                    $method = $presetMethod;
                    break;
                }
            }
        }

        if (empty($args) && !is_null($defaultMethod) && !in_array($method, $this->nonDefaultable)) {
            $args = [$method];
            $method = $defaultMethod;
        }

        foreach ($args as &$arg) {
            $arg = trim($arg);

            if (substr($arg, 0, 4) == 'arr:') {
                $arg = explode('|', substr($arg, 4));
                $arg = array_map('trim', $arg);
            }
        }

        return [$method, $args];
    }
}

[Sophist-UK]

I like the concept, but do have a couple of comments:

1. $up is also used for down() so perhaps $columns might be a better choice?
2. It might actually be better to have a nested array like this:

   $migration = [
       'roles' => [
           'id' => [], // $table->id(); // = id so $table->id();
           'softdeletes' => [], // $table->softDeletes(); - Note: more friendly handling of case using lookup table.
           'string:role,64' => [], // $table->string('role', 64);
           'unique:arr:deleted_at|role,roles_unique_role' => [], // $table->unique(['deleted_at', 'role'], 'roles_unique_role');
       ],
       "users" => [
           'role_id' => ['after:id', 'nullable', 'index'], // ends in _id so $table:foreignId('role_id');
           'assigned_at' => ['after:role_id', 'nullable'], // ends in _at so $table->timestamp('assigned_at');
           'foreign:role_id' => ['references:id', 'on:roles'], // $table->foreign('role_id')->references('id')->on('roles');
       ]
   ];
   

3. If you are going to iterate over the $migration array for down() then you need to iterate in reverse order (because you need to delete the foreign key table before you delete the original table).
4. Because performance is far less important in a Migration, for up() you can either check whether the table actually exists to decide whether to create a new table or assume that inclusion of id or an array value with primary means a new table, and for down() you can either check whether the columns to be deleted are all existing columns or whether an id/primary exists (in which case delete the table rather than delete individual columns). So in the above example, it would determine that roles was a create / drop table, whilst users was an add / drop columns.
5. It would be great if this could be turned into a package that can be required using Composer.
6. It would also be useful if you could output the translated statement so that you can see what is being created.

[mylesduncanking]

https://github.com/mylesduncanking/laravel-simple-migration

This should work if you would like to use it / contribute.

I have added points 1 and 3 and working on point 2 and 4 at the moment but like the feedback thanks 👍

[Sophist-UK]

Once it is available in packagist I will certainly consider using it as part of the new open source project I am working on. 😃

And if I use and find areas to improve it, then I will certainly contribute as I generally do.