Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
90.24%
74 / 82
33.33%
1 / 3
 CRAP
0.00%
0 / 1
SimplePropertiesCodeGenerator
90.24%
74 / 82
33.33%
1 / 3
 26.63
0.00%
0 / 1
 boot
100.00%
20 / 20
100.00%
1 / 1
 1
 run
89.74%
35 / 39
0.00%
0 / 1
 14.21
 allowsLargeStrings
82.61%
19 / 23
0.00%
0 / 1
 11.64
1<?php
2namespace Apie\StorageMetadataBuilder\CodeGenerators;
3
4use Apie\Core\Context\ApieContext;
5use Apie\Core\Enums\ScalarType;
6use Apie\Core\Identifiers\KebabCaseSlug;
7use Apie\Core\Metadata\Fields\FieldInterface;
8use Apie\Core\Metadata\MetadataFactory;
9use Apie\Core\RegexUtils;
10use Apie\Core\Utils\ConverterUtils;
11use Apie\Core\ValueObjects\Interfaces\AllowsLargeStringsInterface;
12use Apie\Core\ValueObjects\Interfaces\HasRegexValueObjectInterface;
13use Apie\Core\ValueObjects\Interfaces\LengthConstraintStringValueObjectInterface;
14use Apie\Core\ValueObjects\IsPasswordValueObject;
15use Apie\StorageMetadata\Attributes\OneToOneAttribute;
16use Apie\StorageMetadata\Attributes\PropertyAttribute;
17use Apie\StorageMetadataBuilder\Interfaces\BootGeneratedCodeInterface;
18use Apie\StorageMetadataBuilder\Interfaces\MixedStorageInterface;
19use Apie\StorageMetadataBuilder\Interfaces\RunGeneratedCodeContextInterface;
20use Apie\StorageMetadataBuilder\Mediators\GeneratedCode;
21use Apie\StorageMetadataBuilder\Mediators\GeneratedCodeContext;
22use Apie\TypeConverter\ReflectionTypeFactory;
23use DateTime;
24use DateTimeImmutable;
25use DateTimeInterface;
26use Nette\PhpGenerator\ClassType;
27use Nette\PhpGenerator\Parameter;
28use Psr\Http\Message\UploadedFileInterface;
29use ReflectionProperty;
30
31/**
32 * Maps simple properties that require no additional tables.
33 * - create apie_mixed_data table that can story any PHP object (which is used as a fallback)
34 * - create for a domain object property a property in the database table.
35 * - if this can be mapped to a scalar, it will be a regular property, else it will be mapped to apie_mixed_data as one to many
36 */
37final class SimplePropertiesCodeGenerator implements RunGeneratedCodeContextInterface, BootGeneratedCodeInterface
38{
39    public function boot(GeneratedCode $generatedCode): void
40    {
41        $mixedData = new ClassType('apie_mixed_data');
42        $mixedData->addImplement(MixedStorageInterface::class);
43        $mixedData->addProperty('serializedString')->setType('string')->setNullable(true);
44        $mixedData->addProperty('originalType')->setType('string')->setNullable(true);
45        $mixedData->addProperty('unserializedObject')->setType('mixed');
46        $mixedData->addMethod('__construct')->setParameters([new Parameter('input')])
47            ->setBody(
48                '$this->unserializedObject = $input;'
49                . PHP_EOL
50                . '$this->serializedString = serialize($input);'
51                . PHP_EOL
52                . '$this->originalType = get_debug_type($input);'
53            );
54        $mixedData->addMethod('toOriginalObject')
55            ->setReturnType('mixed')
56            ->setBody(
57                'if (!isset($this->unserializedObject)) {
58    $this->unserializedObject = unserialize($this->serializedString);
59    if (get_debug_type($this->unserializedObject) !== $this->originalType) {
60        throw new \LogicException("Could not unserialize object again");
61    }
62}
63return $this->unserializedObject;'
64            );
65
66        $generatedCode->generatedCodeHashmap['apie_mixed_data'] = $mixedData;
67    }
68
69    public function run(GeneratedCodeContext $generatedCodeContext): void
70    {
71        $property = $generatedCodeContext->getCurrentProperty();
72        $table = $generatedCodeContext->getCurrentTable();
73        if ($property === null || $table === null) {
74            return;
75        }
76        $propertyName = 'apie_'
77            . str_replace('-', '_', (string) KebabCaseSlug::fromClass($property->getDeclaringClass()))
78            . '_'
79            . str_replace('-', '_', (string) KebabCaseSlug::fromClass($property));
80        $metadata = MetadataFactory::getMetadataStrategyForType(
81            $property->getType() ?? ReflectionTypeFactory::createReflectionType('mixed')
82        )->getResultMetadata(new ApieContext());
83        $scalar = $metadata->toScalarType(true);
84        if ($table->hasProperty($propertyName)) {
85            return;
86        }
87        $nullable = (($metadata instanceof FieldInterface ? $metadata->allowsNull() : false) ? '?' : '');
88        $nullable = '?';
89        $declaredProperty = $table->addProperty($propertyName)
90            ->setType($nullable . $scalar->value);
91        if ($scalar === ScalarType::STRING && in_array((string) $property->getType(), [DateTimeInterface::class, DateTimeImmutable::class, DateTime::class])) {
92            $declaredProperty->setType($nullable . DateTimeImmutable::class);
93        }
94        if (in_array((string) $property->getType(), [UploadedFileInterface::class])) {
95            $declaredProperty->setType($nullable . 'string');
96            $scalar = ScalarType::STRING;
97        }
98        switch ($scalar) {
99            case ScalarType::ARRAY:
100            case ScalarType::STDCLASS:
101            case ScalarType::MIXED:
102                $declaredProperty->setType($nullable . 'apie_mixed_data')->addAttribute(OneToOneAttribute::class, [$property->name, $property->getDeclaringClass()->name]);
103                break;
104            case ScalarType::NULLVALUE:
105                $declaredProperty->setType(null)
106                    ->setValue(null); // fallthrough
107                // no break
108            default:
109                $declaredProperty->addAttribute(
110                    PropertyAttribute::class,
111                    [
112                        $property->name,
113                        $property->getDeclaringClass()->name,
114                        $this->allowsLargeStrings($property)
115                    ]
116                );
117        }
118    }
119
120    private function allowsLargeStrings(ReflectionProperty $property): bool
121    {
122        $propertyTypeAsString = ltrim((string) $property->getType(), '?');
123        if ('string' === $propertyTypeAsString) {
124            return true;
125        }
126        if (in_array($propertyTypeAsString, [UploadedFileInterface::class])) {
127            return true;
128        }
129        $class = ConverterUtils::toReflectionClass($property);
130        if (!$class) {
131            return false;
132        }
133        $interfaceNames = $class->getInterfaceNames();
134        
135        if (in_array(AllowsLargeStringsInterface::class, $interfaceNames)
136            || in_array(UploadedFileInterface::class, $interfaceNames)) {
137            return true;
138        }
139        if (in_array(LengthConstraintStringValueObjectInterface::class, $interfaceNames)) {
140            $maxLength = $class->getMethod('maxStringLength')->invoke(null);
141            return $maxLength > 127 || $maxLength === null;
142        }
143        if (in_array(IsPasswordValueObject::class, $class->getTraitNames())) {
144            $maxLength = $class->getMethod('getMaxLength')->invoke(null);
145            return $maxLength > 127;
146        }
147        if (in_array(HasRegexValueObjectInterface::class, $interfaceNames)) {
148            $regex = $class->getMethod('getRegularExpression')->invoke(null);
149            $maxLength = RegexUtils::getMaximumAcceptedStringLengthOfRegularExpression($regex, true);
150            return $maxLength > 127 || $maxLength === null;
151        }
152        return false;
153    }
154}