Custom builder for migrations

composer.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "require": {
     "php": ">=8.0",
-    "cycle/database": "^2.0",
+    "cycle/database": "^2.3",
     "spiral/core": "^2.7",
     "spiral/files": "^2.7",
     "spiral/tokenizer": "^2.7",

src/FileRepository.php

@@ -136,7 +136,7 @@ private function getFiles(string $directory): \Generator
     {
         foreach ($this->files->getFiles($directory, '*.php') as $filename) {
             $reflection = new ReflectionFile($filename);
-            $definition = \explode('_', \basename($filename));
+            $definition = \explode('_', \basename($filename, '.php'), 3);
 
             if (\count($definition) < 3) {
                 throw new RepositoryException("Invalid migration filename '{$filename}'");
@@ -152,11 +152,7 @@ private function getFiles(string $directory): \Generator
                 'class' => $reflection->getClasses()[0],
                 'created' => $created,
                 'chunk' => $definition[1],
-                'name' => \str_replace(
-                    '.php',
-                    '',
-                    \implode('_', \array_slice($definition, 2))
-                ),
+                'name' => $definition[2],
             ];
         }
     }

src/Operation/Column/Column.php

@@ -43,21 +43,27 @@ protected function declareColumn(AbstractTable $schema): AbstractColumn
         //Type configuring
         if (method_exists($column, $this->type)) {
             $arguments = [];
+            $variadic = false;
 
             $method = new \ReflectionMethod($column, $this->type);
             foreach ($method->getParameters() as $parameter) {
                 if ($this->hasOption($parameter->getName())) {
-                    $arguments[] = $this->getOption($parameter->getName());
+                    $arguments[$parameter->getName()] = $this->getOption($parameter->getName());
                 } elseif (!$parameter->isOptional()) {
                     throw new ColumnException(
                         "Option '{$parameter->getName()}' are required to define column with type '{$this->type}'"
                     );
-                } else {
-                    $arguments[] = $parameter->getDefaultValue();
+                } elseif ($parameter->isDefaultValueAvailable()) {
+                    $arguments[$parameter->getName()] = $parameter->getDefaultValue();
+                } elseif ($parameter->isVariadic()) {
+                    $variadic = true;
                 }
             }
 
-            call_user_func_array([$column, $this->type], $arguments);
+            \call_user_func_array(
+                [$column, $this->type],
+                $variadic ? $arguments + $this->options + $column->getAttributes() : $arguments,
+            );
         } else {
             $column->type($this->type);
         }

src/Operation/Table/Truncate.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Cycle\Migrations\Operation\Table;
+
+use Cycle\Migrations\CapsuleInterface;
+use Cycle\Migrations\Exception\Operation\TableException;
+use Cycle\Migrations\Operation\AbstractOperation;
+
+final class Truncate extends AbstractOperation
+{
+    public function __construct(string $table, private string $strategy)
+    {
+        parent::__construct($table);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function execute(CapsuleInterface $capsule): void
+    {
+        $schema = $capsule->getSchema($this->getTable());
+        $database = $this->database ?? '[default]';
+
+        if (!$schema->exists()) {
+            throw new TableException(
+                "Unable to truncate table '{$database}'.'{$this->getTable()}', table does not exists"
+            );
+        }
+
+        $capsule->getDatabase()->execute(sprintf('TRUNCATE "%s" %s', $this->getTable(), $this->strategy));
+    }
+}

src/V2/Column.php

@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Migrations\V2;
+
+class Column
+{
+    protected string $type;
+    protected ?int $length = null;
+    protected bool $isUnique = false;
+    protected ?string $default = null;
+    protected bool $isNotNull = false;
+    protected ?string $check = null;
+    protected ?string $comment = null;
+
+    public function __construct(string $type, ?int $length = null)
+    {
+        $this->type = $type;
+        $this->length = $length;
+    }
+
+    public function notNull(): self
+    {
+        $this->isNotNull = true;
+        return $this;
+    }
+
+    public function null(): self
+    {
+        $this->isNotNull = false;
+        return $this;
+    }
+
+    public function unique(): self
+    {
+        $this->isUnique = true;
+        return $this;
+    }
+
+    public function check($check): self
+    {
+        $this->check = $check;
+        return $this;
+    }
+
+    public function defaultValue(?string $default): self
+    {
+        if ($default === null) {
+            $this->null();
+        }
+
+        $this->default = $default;
+        return $this;
+    }
+
+    public function comment(?string $comment): self
+    {
+        $this->comment = $comment;
+        return $this;
+    }
+}

src/V2/ColumnParser.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Migrations\V2;
+
+class ColumnParser extends Column
+{
+    private Column $column;
+
+    public function __construct(Column $column)
+    {
+        $this->column = $column;
+    }
+
+    public function getType(): string
+    {
+        return $this->column->type;
+    }
+
+    public function getLength(): ?int
+    {
+        return $this->column->length;
+    }
+
+    public function isUnique(): bool
+    {
+        return $this->column->isUnique;
+    }
+
+    public function getDefault(): ?string
+    {
+        return $this->column->default;
+    }
+
+    public function isNotNull(): bool
+    {
+        return $this->column->isNotNull;
+    }
+
+    public function getCheck(): ?string
+    {
+        return $this->column->check;
+    }
+
+    public function getComment(): ?string
+    {
+        return $this->column->comment;
+    }
+
+    public function getOptions(): array
+    {
+        $options = [];
+        $options['unique'] = $this->isUnique();
+        $options['nullable'] = !$this->isNotNull();
+
+        if ($this->getDefault() !== null) {
+            $options['default'] = $this->getDefault();
+        }
+
+        return $options;
+    }
+}

src/V2/ColumnTrait.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Migrations\V2;
+
+trait ColumnTrait
+{
+    protected function primaryKey($length = null): Column
+    {
+        $column = new Column(ColumnType::TYPE_PK, $length);
+        $column->notNull();
+
+        return $column;
+    }
+
+    protected function bigPrimaryKey($length = null): Column
+    {
+        $column = new Column(ColumnType::TYPE_BIGPK, $length);
+        $column->notNull();
+
+        return $column;
+    }
+
+    protected function string($length = null): Column
+    {
+        return new Column(ColumnType::TYPE_STRING, $length);
+    }
+
+    protected function text(): Column
+    {
+        return new Column(ColumnType::TYPE_TEXT);
+    }
+
+    protected function integer($length = null): Column
+    {
+        return new Column(ColumnType::TYPE_INTEGER, $length);
+    }
+
+    protected function bigInteger($length = null): Column
+    {
+        return new Column(ColumnType::TYPE_BIGINT, $length);
+    }
+
+    protected function numeric($precision = null): Column
+    {
+        return new Column(ColumnType::TYPE_NUMERIC, $precision);
+    }
+
+    protected function dateTime(): Column
+    {
+        return new Column(ColumnType::TYPE_DATETIME);
+    }
+
+    protected function boolean(): Column
+    {
+        return new Column(ColumnType::TYPE_BOOLEAN);
+    }
+
+    protected function money(): Column
+    {
+        return new Column(ColumnType::TYPE_MONEY);
+    }
+
+    protected function json(): Column
+    {
+        return new Column(ColumnType::TYPE_JSON);
+    }
+
+    protected function point(): Column
+    {
+        return new Column(ColumnType::TYPE_POINT);
+    }
+
+    protected function customType(string $type): Column
+    {
+        return new Column($type);
+    }
+}

src/V2/ColumnType.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Migrations\V2;
+
+class ColumnType
+{
+    public const TYPE_PK = 'primary';
+    public const TYPE_BIGPK = 'bigPrimary';
+    public const TYPE_CHAR = 'char';
+    public const TYPE_STRING = 'string';
+    public const TYPE_TEXT = 'text';
+    public const TYPE_TINYINT = 'tinyint';
+    public const TYPE_SMALLINT = 'smallint';
+    public const TYPE_INTEGER = 'integer';
+    public const TYPE_BIGINT = 'bigint';
+    public const TYPE_FLOAT = 'float';
+    public const TYPE_DOUBLE = 'double';
+    public const TYPE_DECIMAL = 'decimal';
+    public const TYPE_NUMERIC = 'numeric';
+    public const TYPE_DATETIME = 'datetime';
+    public const TYPE_TIMESTAMP = 'timestamp';
+    public const TYPE_TIME = 'time';
+    public const TYPE_DATE = 'date';
+    public const TYPE_BINARY = 'binary';
+    public const TYPE_BOOLEAN = 'boolean';
+    public const TYPE_MONEY = 'money';
+    public const TYPE_POINT = 'point';
+    public const TYPE_JSON = 'jsonb';
+}

src/V2/FKAction.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cycle\Migrations\V2;
+
+class FKAction
+{
+    public const CASCADE = 'CASCADE';
+    public const SET_NULL = 'SET NULL';
+    public const SET_DEFAULT = 'SET DEFAULT';
+    public const RESTRICT = 'RESTRICT';
+    public const NO_ACTION = 'NO ACTION';
+
+    private string $value;
+
+    private function __construct(string $value)
+    {
+        $this->value = $value;
+    }
+
+    public static function cascade(): self
+    {
+        return new self(self::CASCADE);
+    }
+
+    public static function setNull(): self
+    {
+        return new self(self::SET_NULL);
+    }
+
+    public static function setDefault(): self
+    {
+        return new self(self::SET_DEFAULT);
+    }
+
+    public static function restrict(): self
+    {
+        return new self(self::RESTRICT);
+    }
+
+    public static function noAction(): self
+    {
+        return new self(self::NO_ACTION);
+    }
+
+    public function value(): string
+    {
+        return $this->value;
+    }
+}