Skip to content

Open-source event management and ticket selling platform — perfect for concerts, conferences, and everything in between 🎟️ If you find this project helpful, please consider giving us a star ⭐️

8.5 KB
Raw Blame
<?php

declare(strict_types=1);

namespace HiEvents\Services\Infrastructure\DomainObjectGenerator;

use Doctrine\DBAL\Exception;
use Doctrine\DBAL\Schema\AbstractSchemaManager;
use Doctrine\DBAL\Schema\Column;
use Doctrine\DBAL\Schema\Table;
use Doctrine\DBAL\Types\Type;
use Doctrine\DBAL\Types\Types;
use HiEvents\DomainObjects\AbstractDomainObject;
use HiEvents\Exceptions\NoDefaultValueAvailableForGeneratedDoProperty;
use Illuminate\Foundation\Application;
use Illuminate\Support\Pluralizer;
use Illuminate\Support\Str;
use Nette\PhpGenerator\ClassType;
use Nette\PhpGenerator\PhpFile;
use Nette\PhpGenerator\PhpNamespace;
use Nette\PhpGenerator\PsrPrinter;

/**
 * @todo - move properties to config
 */
class ClassGenerator
{
    public const NO_TYPE = 'no-type';

    private string $defaultAbstractNamespace = 'HiEvents\DomainObjects\Generated';

    private string $defaultConcreteNamespace = 'HiEvents\DomainObjects';

    private string $defaultAbstractModelPath = 'DomainObjects/Generated';

    private string $defaultConcreteModelPath = 'DomainObjects';

    private string $defaultExtends = AbstractDomainObject::class;

    private array $defaultIgnoreProperties = [];

    private array $ignoredTables = [
        'migrations',
        'job_batches',
        'failed_jobs',
    ];

    private AbstractSchemaManager $schemaManager;

    private Application $app;

    private ClassType $currentClass;

    private Table $currentTable;

    private array $currentColumns;

    public function __construct(Application $app, AbstractSchemaManager $schemaManager)
    {
        $this->schemaManager = $schemaManager;
        $this->app = $app;
    }

    /**
     * @throws Exception
     */
    public function run(): void
    {
        foreach ($this->schemaManager->listTables() as $table) {
            if (in_array($table->getName(), $this->ignoredTables, true)) {
                continue;
            }

            $namespace = new PhpNamespace($this->defaultAbstractNamespace);
            $className = ucfirst(Str::camel(Pluralizer::singular($table->getName()))).'DomainObjectAbstract';

            $this->currentClass = $namespace->addClass($className);
            $this->currentTable = $table;
            $this->currentColumns = $table->getColumns();

            $this->currentClass
                ->setAbstract()
                ->setExtends($this->defaultExtends)
                ->addComment('THIS FILE IS AUTOGENERATED - DO NOT EDIT IT DIRECTLY.')
                ->addComment("@package $this->defaultAbstractNamespace");

            $this->buildConstants();
            $this->buildProperties();
            $this->buildPublicMethods();
            $this->buildGettersAndSetters();

            $namespace->add($this->currentClass);

            $file = new PhpFile;
            $file->addNamespace($namespace);
            $this->writeFile($table, (new PsrPrinter)->printFile($file));
        }
    }

    private function buildConstants(): void
    {
        $singularName = Str::singular($this->currentTable->getName());
        $pluralName = Str::plural($singularName);

        $this->currentClass->addConstant('SINGULAR_NAME', $singularName)
            ->setPublic()
            ->setFinal();

        $this->currentClass->addConstant('PLURAL_NAME', $pluralName)
            ->setPublic()
            ->setFinal();

        foreach ($this->currentColumns as $column) {
            if ($this->shouldIgnoreProperty($column->getName())) {
                continue;
            }

            $constName = Str::upper($column->getName());

            $this->currentClass->addConstant($constName, $column->getName())
                ->setPublic()
                ->setFinal();
        }
    }

    private function shouldIgnoreProperty(string $property): bool
    {
        return in_array($property, $this->defaultIgnoreProperties, true);
    }

    private function buildProperties(): void
    {
        foreach ($this->currentColumns as $column) {
            if ($this->shouldIgnoreProperty($column->getName())) {
                continue;
            }

            $prop = $this->currentClass
                ->addProperty($column->getName())
                ->setProtected()
                ->setType($this->getType($column->getType()))
                ->setNullable(! $column->getNotnull());

            $defaultValue = $this->getDefaultValue($column);
            if ($defaultValue !== self::NO_TYPE) {
                $prop->setValue($defaultValue);
            }
        }
    }

    private function getType(Type $type): ?string
    {
        return match (strtolower($type->getName())) {
            Types::INTEGER, Types::BIGINT, Types::SMALLINT => 'int',
            Types::BOOLEAN => 'bool',
            Types::DECIMAL, Types::FLOAT => 'float',
            Types::JSON => 'array|string',
            default => 'string',
        };
    }

    private function getDefaultValue(Column $column): mixed
    {
        if (is_null($column->getDefault())) {
            return $column->getNotnull() ? self::NO_TYPE : null;
        }

        return match ($column->getType()->getName()) {
            Types::STRING, Types::TEXT, Types::DATE_MUTABLE, Types::TIME_MUTABLE, Types::DATETIMETZ_MUTABLE, Types::DATETIME_MUTABLE => $column->getDefault(),
            Types::INTEGER, Types::BIGINT, Types::SMALLINT => (int) $column->getDefault(),
            Types::FLOAT, Types::DECIMAL => (float) $column->getDefault(),
            Types::GUID => self::NO_TYPE,
            Types::BOOLEAN => (bool) $column->getDefault(),
            default => throw new NoDefaultValueAvailableForGeneratedDoProperty(
                sprintf('Unable to handle %s', $column->getType()->getName())
            ),
        };
    }

    private function buildPublicMethods(): void
    {
        $response[] = 'return [';
        foreach ($this->currentColumns as $column) {
            if ($this->shouldIgnoreProperty($column->getName())) {
                continue;
            }

            $response[] = "
            '{$column->getName()}' => \$this->{$column->getName()} ?? null,";
        }
        $response[] = '
        ];
    ';
        $this->currentClass
            ->addMethod('toArray')
            ->setReturnType('array')
            ->setBody(implode('', $response))
            ->setPublic();
    }

    private function buildGettersAndSetters(): void
    {
        foreach ($this->currentColumns as $column) {
            if ($this->shouldIgnoreProperty($column->getName())) {
                continue;
            }

            $model = ucfirst(Str::camel($column->getName()));
            $setterName = 'set'.$model;
            $getterName = 'get'.$model;

            $this->currentClass->addMethod($setterName)
                ->setPublic()
                ->addBody("\$this->{$column->getName()} = \${$column->getName()};\nreturn \$this;")
                ->setReturnType('self')
                ->addParameter($column->getName())
                ->setType($this->getType($column->getType()))
                ->setNullable(! $column->getNotnull());

            $this->currentClass->addMethod($getterName)
                ->setPublic()
                ->addBody("return \$this->{$column->getName()};")
                ->setReturnType($this->getType($column->getType()))
                ->setReturnNullable(! $column->getNotnull());
        }
    }

    private function writeFile(Table $table, string $modelContent): void
    {
        $abstractPath = $this->app->path($this->defaultAbstractModelPath);
        $concretePath = $this->app->path($this->defaultConcreteModelPath);

        $model = Pluralizer::singular(ucfirst(Str::camel($table->getName()))).'DomainObject';
        $abstractFile = $abstractPath.'/'.$model.'Abstract'.'.php';
        $concreteFile = $concretePath.'/'.$model.'.php';

        if (file_exists($abstractFile)) {
            unlink($abstractFile);
        }

        if (! file_exists($concreteFile)) {
            $this->writeConcreteFile($table, $concreteFile);
        }

        file_put_contents($abstractFile, $modelContent);
    }

    private function writeConcreteFile(Table $table, string $concreteFile): void
    {
        $namespace = new PhpNamespace($this->defaultConcreteNamespace);
        $className = ucfirst(Str::camel(Pluralizer::singular($table->getName()))).'DomainObject';

        $class = $namespace->addClass($className);
        $class->setExtends($this->defaultConcreteNamespace.'\Generated'.'\\'.$className.'Abstract');

        $file = new PhpFile;
        $file->addNamespace($namespace);

        file_put_contents($concreteFile, (new PsrPrinter)->printFile($file));
    }
}