Cycle\Annotated\Configurator

Complexity

Total Complexity

65

Size/Duplication

Total Lines	366
Duplicated Lines	0 %

Test Coverage

Coverage

85.51%

Importance

Changes	3
Bugs	3	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
B	initColumns()	0	32	8
B	initForeignKeys()	0	35	8
A	__construct()	0	7	1
A	getPropertyMetadata()	0	6	2
A	isOnInsertGeneratedField()	0	5	1
B	initField()	0	35	7
A	exists()	0	3	2
A	resolveTypecast()	0	18	6
A	initGeneratedFields()	0	10	4
A	resolveName()	0	17	4
A	initFields()	0	20	6
B	initRelations()	0	51	8
A	initModifiers()	0	9	2
A	initEmbedding()	0	11	1
A	initEntity()	0	31	3
A	getClassMetadata()	0	6	2

<?php

declare(strict_types=1);

namespace Cycle\Annotated;

use Cycle\Annotated\Annotation\Column;
use Cycle\Annotated\Annotation\Embeddable;
use Cycle\Annotated\Annotation\Entity;
use Cycle\Annotated\Annotation\ForeignKey;
use Cycle\Annotated\Annotation\GeneratedValue;
use Cycle\Annotated\Annotation\Relation as RelationAnnotation;
use Cycle\Annotated\Exception\AnnotationException;
use Cycle\Annotated\Exception\AnnotationRequiredArgumentsException;
use Cycle\Annotated\Exception\AnnotationWrongTypeArgumentException;
use Cycle\Annotated\Utils\EntityUtils;
use Cycle\ORM\Schema\GeneratedField;
use Cycle\Schema\Definition\Entity as EntitySchema;
use Cycle\Schema\Definition\ForeignKey as ForeignKeySchema;
use Cycle\Schema\Definition\Field;
use Cycle\Schema\Definition\Relation;
use Cycle\Schema\Generator\SyncTables;
use Cycle\Schema\SchemaModifierInterface;
use Doctrine\Common\Annotations\Reader as DoctrineReader;
use Doctrine\Inflector\Inflector;
use Doctrine\Inflector\Rules\English\InflectorFactory;
use Spiral\Attributes\ReaderInterface;

final class Configurator
{
    private ReaderInterface $reader;
    private Inflector $inflector;
    private EntityUtils $utils;

    public function __construct(
        DoctrineReader|ReaderInterface $reader,
        private int $tableNamingStrategy = Entities::TABLE_NAMING_PLURAL,
    ) {
        $this->reader = ReaderFactory::create($reader);
        $this->inflector = (new InflectorFactory())->build();
        $this->utils = new EntityUtils($this->reader);
    }

    public function initEntity(Entity $ann, \ReflectionClass $class): EntitySchema
    {
        $e = new EntitySchema();
        $e->setClass($class->getName());

        $e->setRole($ann->getRole() ?? $this->inflector->camelize($class->getShortName()));

        // representing classes
        $e->setMapper($this->resolveName($ann->getMapper(), $class));
        $e->setRepository($this->resolveName($ann->getRepository(), $class));
        $e->setSource($this->resolveName($ann->getSource(), $class));
        $e->setScope($this->resolveName($ann->getScope(), $class));
        $e->setDatabase($ann->getDatabase());
        $e->setTableName(
            $ann->getTable() ?? $this->utils->tableName($e->getRole(), $this->tableNamingStrategy)
        );

        $typecast = $ann->getTypecast();
        if (is_array($typecast)) {
            $typecast = array_map(fn (string $value): string => $this->resolveName($value, $class), $typecast);
        } else {
            $typecast = $this->resolveName($typecast, $class);
        }

        $e->setTypecast($typecast);

        if ($ann->isReadonlySchema()) {
            $e->getOptions()->set(SyncTables::READONLY_SCHEMA, true);
        }

        return $e;
    }

    public function initEmbedding(Embeddable $emb, \ReflectionClass $class): EntitySchema
    {
        $e = new EntitySchema();
        $e->setClass($class->getName());

        $e->setRole($emb->getRole() ?? $this->inflector->camelize($class->getShortName()));

        // representing classes
        $e->setMapper($this->resolveName($emb->getMapper(), $class));

        return $e;
    }

    public function initFields(EntitySchema $entity, \ReflectionClass $class, string $columnPrefix = ''): void
    {
        foreach ($class->getProperties() as $property) {
            try {
                $column = $this->reader->firstPropertyMetadata($property, Column::class);
            } catch (\Exception $e) {
                throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
            } catch (\ArgumentCountError $e) {
                throw AnnotationRequiredArgumentsException::createFor($property, Column::class, $e);
            } catch (\TypeError $e) {
                throw AnnotationWrongTypeArgumentException::createFor($property, $e);
            }

            if ($column === null) {
                continue;
            }

            $field = $this->initField($property->getName(), $column, $class, $columnPrefix);
            $field->setEntityClass($property->getDeclaringClass()->getName());
            $entity->getFields()->set($property->getName(), $field);
        }
    }

    public function initRelations(EntitySchema $entity, \ReflectionClass $class): void
    {
        foreach ($class->getProperties() as $property) {
            $metadata = $this->getPropertyMetadata($property, RelationAnnotation\RelationInterface::class);

            foreach ($metadata as $meta) {
                assert($meta instanceof RelationAnnotation\RelationInterface);

                if ($meta->getTarget() === null) {
                    throw new AnnotationException(
                        "Relation target definition is required on `{$entity->getClass()}`.`{$property->getName()}`"
                    );
                }

                $relation = new Relation();
                $relation->setTarget($this->resolveName($meta->getTarget(), $class));
                $relation->setType($meta->getType());

                $inverse = $meta->getInverse() ?? $this->reader->firstPropertyMetadata(
                    $property,
                    RelationAnnotation\Inverse::class
                );
                if ($inverse !== null) {
                    $relation->setInverse(
                        $inverse->getName(),
                        $inverse->getType(),
                        $inverse->getLoadMethod()
                    );
                }

                if ($meta instanceof RelationAnnotation\Embedded && $meta->getPrefix() === null) {
                    /** @var Embeddable|null $embeddable */
                    $embeddable = $this->reader->firstClassMetadata(
                        new \ReflectionClass($relation->getTarget()),
                        Embeddable::class
                    );
                    $meta->setPrefix($embeddable->getColumnPrefix());
                }

                foreach ($meta->getOptions() as $option => $value) {
                    $value = match ($option) {
                        'collection' => $this->resolveName($value, $class),
                        'though', 'through' => $this->resolveName($value, $class),
                        default => $value
                    };

                    $relation->getOptions()->set($option, $value);
                }

                // need relation definition
                $entity->getRelations()->set($property->getName(), $relation);
            }
        }
    }

    public function initModifiers(EntitySchema $entity, \ReflectionClass $class): void
    {
        $metadata = $this->getClassMetadata($class, SchemaModifierInterface::class);

        foreach ($metadata as $meta) {
            assert($meta instanceof SchemaModifierInterface);

            // need relation definition
            $entity->addSchemaModifier($meta);
        }
    }

    /**
     * @param Column[] $columns
     */
    public function initColumns(EntitySchema $entity, array $columns, \ReflectionClass $class): void
    {
        foreach ($columns as $key => $column) {
            $isNumericKey = is_numeric($key);
            $propertyName = $column->getProperty();

            if (!$isNumericKey && $propertyName !== null && $key !== $propertyName) {
                throw new AnnotationException(
                    "Can not use name \"{$key}\" for Column of the `{$entity->getRole()}` role, because the "
                    . "\"property\" field of the metadata class has already been set to \"{$propertyName}\"."
                );
            }

            $propertyName = $propertyName ?? ($isNumericKey ? null : $key);
            $columnName = $column->getColumn() ?? $propertyName;
            $propertyName = $propertyName ?? $columnName;

            if ($columnName === null) {
                throw new AnnotationException(
                    "Column name definition is required on `{$entity->getClass()}`"
                );
            }

            if ($column->getType() === null) {
                throw new AnnotationException(
                    "Column type definition is required on `{$entity->getClass()}`.`{$columnName}`"
                );
            }

            $field = $this->initField($columnName, $column, $class, '');
            $field->setEntityClass($entity->getClass());
            $entity->getFields()->set($propertyName, $field);

It seems like $propertyName can also be of type null; however, parameter $name of Cycle\Schema\Definition\Map\FieldMap::set() does only seem to accept string, maybe add an additional type check?

        }
    }

    public function initField(string $name, Column $column, \ReflectionClass $class, string $columnPrefix): Field
    {
        $field = new Field();

        $field->setType($column->getType());
        $field->setColumn($columnPrefix . ($column->getColumn() ?? $this->inflector->tableize($name)));
        $field->setPrimary($column->isPrimary());
        if ($this->isOnInsertGeneratedField($field)) {
            $field->setGenerated(GeneratedField::ON_INSERT);
        }

        $field->setTypecast($this->resolveTypecast($column->getTypecast(), $class));

        if ($column->isNullable()) {
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_NULLABLE, true);
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_DEFAULT, null);
        }

        if ($column->hasDefault()) {
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_DEFAULT, $column->getDefault());
        }

        if ($column->castDefault()) {
            $field->getOptions()->set(\Cycle\Schema\Table\Column::OPT_CAST_DEFAULT, true);
        }

        if ($column->isReadonlySchema()) {
            $field->getAttributes()->set('readonlySchema', true);
        }

        foreach ($column->getAttributes() as $k => $v) {
            $field->getAttributes()->set($k, $v);
        }

        return $field;
    }

    public function initForeignKeys(Entity $ann, EntitySchema $entity, \ReflectionClass $class): void
    {
        $foreignKeys = [];
        foreach ($ann->getForeignKeys() as $foreignKey) {
            $foreignKeys[] = $foreignKey;
        }

        foreach ($this->getClassMetadata($class, ForeignKey::class) as $foreignKey) {
            $foreignKeys[] = $foreignKey;
        }

        foreach ($class->getProperties() as $property) {
            foreach ($this->getPropertyMetadata($property, ForeignKey::class) as $foreignKey) {
                if ($foreignKey->innerKey === null) {
                    $foreignKey->innerKey = [$property->getName()];
                }
                $foreignKeys[] = $foreignKey;
            }
        }

        foreach ($foreignKeys as $foreignKey) {
            if ($foreignKey->innerKey === null) {
                throw new AnnotationException(
                    "Inner column definition for the foreign key is required on `{$entity->getClass()}`"
                );
            }

            $fk = new ForeignKeySchema();
            $fk->setTarget($foreignKey->target);
            $fk->setInnerColumns((array) $foreignKey->innerKey);
            $fk->setOuterColumns((array) $foreignKey->outerKey);
            $fk->createIndex($foreignKey->indexCreate);
            $fk->setAction($foreignKey->action);

            $entity->getForeignKeys()->set($fk);
        }
    }

    public function initGeneratedFields(EntitySchema $entity, \ReflectionClass $class): void
    {
        foreach ($class->getProperties() as $property) {
            try {
                $generated = $this->reader->firstPropertyMetadata($property, GeneratedValue::class);
                if ($generated !== null) {
                    $entity->getFields()->get($property->getName())->setGenerated($generated->getFlags());
                }
            } catch (\Throwable $e) {
                throw new AnnotationException($e->getMessage(), (int) $e->getCode(), $e);
            }
        }
    }

    /**
     * Resolve class or role name relative to the current class.
     */
    public function resolveName(?string $name, \ReflectionClass $class): ?string
    {
        if ($name === null || $this->exists($name)) {
            return $name;
        }

        $resolved = \sprintf(
            '%s\\%s',
            $class->getNamespaceName(),
            \ltrim(\str_replace('/', '\\', $name), '\\')
        );

        if ($this->exists($resolved)) {
            return \ltrim($resolved, '\\');
        }

        return $name;
    }

    private function exists(string $name): bool
    {
        return \class_exists($name, true) || \interface_exists($name, true);
    }

    private function resolveTypecast(mixed $typecast, \ReflectionClass $class): mixed
    {
        if (\is_string($typecast) && \str_contains($typecast, '::')) {
            // short definition
            $typecast = \explode('::', $typecast);

            // resolve class name
            $typecast[0] = $this->resolveName($typecast[0], $class);
        }

        if (\is_string($typecast)) {
            $typecast = $this->resolveName($typecast, $class);
            if (\class_exists($typecast) && \method_exists($typecast, 'typecast')) {
                $typecast = [$typecast, 'typecast'];
            }
        }

        return $typecast;
    }

    /**
     * @template T
     *
     * @param class-string<T>|null
     *
     * @throws AnnotationException
     *
     * @return iterable<T>
     */
    private function getClassMetadata(\ReflectionClass $class, string $name): iterable
    {
        try {
            return $this->reader->getClassMetadata($class, $name);
        } catch (\Exception $e) {
            throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * @template T
     *
     * @param class-string<T>|null $name

The doc comment class-string<T>|null at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>|null.

     *
     * @throws AnnotationException
     *
     * @return iterable<T>
     */
    private function getPropertyMetadata(\ReflectionProperty $property, string $name): iterable
    {
        try {
            return $this->reader->getPropertyMetadata($property, $name);
        } catch (\Exception $e) {
            throw new AnnotationException($e->getMessage(), $e->getCode(), $e);
        }
    }

    private function isOnInsertGeneratedField(Field $field): bool
    {
        return match ($field->getType()) {
            'serial', 'bigserial', 'smallserial' => true,
            default => $field->isPrimary()
        };
    }
}