14107464245

Committed 27 Mar 2025 01:12PM UTC coverage: 79.476% (+0.1%) from 79.334%

Build # 14107464245

Build Type

Pull #1076

github

Committed by

web-flow

Commit Message

Merge 882d93136 into 6af05d563

Pull Request Pull Request #1076: refactor(database): remove `DatabaseModel` interface

Run Details

476 of 504 new or added lines in 37 files covered. (94.44%)

1 existing line in 1 file now uncovered.

10684 of 13443 relevant lines covered (79.48%)

92.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.08

/src/Tempest/Database/src/Builder/QueryBuilders/InsertQueryBuilder.php

<?php

namespace Tempest\Database\Builder\QueryBuilders;

use Tempest\Database\Builder\ModelDefinition;
use Tempest\Database\Builder\TableDefinition;
use Tempest\Database\Id;
use Tempest\Database\Query;
use Tempest\Database\QueryStatements\InsertStatement;
use Tempest\Mapper\SerializerFactory;
use Tempest\Reflection\ClassReflector;
use Tempest\Support\Arr\ImmutableArray;

final readonly class InsertQueryBuilder
{
    private InsertStatement $insertStatement;

    public function __construct(
        private string|object $model,
        private array $rows,
        private SerializerFactory $serializerFactory,
    ) {
        $this->insertStatement = new InsertStatement($this->resolveTableDefinition());
    }

    public function execute(...$bindings): Id
    {
        return $this->build()->execute(...$bindings);
    }

    public function build(): Query
    {
        $bindings = [];

        foreach ($this->resolveEntries() as $entry) {
            $this->insertStatement->addEntry($entry);

            foreach ($entry as $value) {
                $bindings[] = $value;
            }
        }

        return new Query(
            $this->insertStatement,
            $bindings,
        );
    }

    private function resolveEntries(): array
    {
        $entries = [];

        foreach ($this->rows as $model) {
            // Raw entries are straight up added
            if (is_array($model) || $model instanceof ImmutableArray) {
                $entries[] = $model;

                continue;
            }

            // The rest are model objects
            $modelClass = new ClassReflector($model);

            $entry = [];

            // Including all public properties
            foreach ($modelClass->getPublicProperties() as $property) {
                if (! $property->isInitialized($model)) {
                    continue;
                }

                // HasMany relations are skipped
                if ($property->getIterableType()?->isRelation()) {
                    continue;
                }

                $column = $property->getName();

                $value = $property->getValue($model);

                // BelongsTo and HasMany relations are included
                if ($property->getType()->isRelation()) {
                    $column .= '_id';

                    $value = match (true) {
                        $value === null => null,
                        isset($value->id) => $value->id->id,
                        default => new InsertQueryBuilder(
                            $value::class,
                            [$value],
                            $this->serializerFactory,
                        )->build(),
                    };
                }

                // Check if value needs serialization
                $serializer = $this->serializerFactory->forProperty($property);

                if ($value !== null && $serializer !== null) {
                    $value = $serializer->serialize($value);
                }

                $entry[$column] = $value;
            }

            $entries[] = $entry;
        }

        return $entries;
    }

    private function resolveTableDefinition(): TableDefinition
    {
        $modelDefinition = ModelDefinition::tryFrom($this->model);

        if ($modelDefinition === null) {
            return new TableDefinition($this->model);
        }

        return $modelDefinition->getTableDefinition();
    }
}

1	<?php
2
3	namespace Tempest\Database\Builder\QueryBuilders;
4
5	use Tempest\Database\Builder\ModelDefinition;
6	use Tempest\Database\Builder\TableDefinition;
7	use Tempest\Database\Id;
8	use Tempest\Database\Query;
9	use Tempest\Database\QueryStatements\InsertStatement;
10	use Tempest\Mapper\SerializerFactory;
11	use Tempest\Reflection\ClassReflector;
12	use Tempest\Support\Arr\ImmutableArray;
13
14	final readonly class InsertQueryBuilder
15	{
16	private InsertStatement $insertStatement;
17
18	public function __construct(	63✔
19	private string\|object $model,
20	private array $rows,
21	private SerializerFactory $serializerFactory,
22	) {
23	$this->insertStatement = new InsertStatement($this->resolveTableDefinition());	63✔
24	}
25
NEW 26	public function execute(...$bindings): Id	×
27	{
NEW 28	return $this->build()->execute(...$bindings);	×
29	}
30
31	public function build(): Query	63✔
32	{
33	$bindings = [];	63✔
34
35	foreach ($this->resolveEntries() as $entry) {	63✔
36	$this->insertStatement->addEntry($entry);	63✔
37
38	foreach ($entry as $value) {	63✔
39	$bindings[] = $value;	63✔
40	}
41	}
42
43	return new Query(	63✔
44	$this->insertStatement,	63✔
45	$bindings,	63✔
46	);	63✔
47	}
48
49	private function resolveEntries(): array	63✔
50	{
51	$entries = [];	63✔
52
53	foreach ($this->rows as $model) {	63✔
54	// Raw entries are straight up added
55	if (is_array($model) \|\| $model instanceof ImmutableArray) {	63✔
56	$entries[] = $model;	3✔
57
58	continue;	3✔
59	}
60
61	// The rest are model objects
62	$modelClass = new ClassReflector($model);	61✔
63
64	$entry = [];	61✔
65
66	// Including all public properties
67	foreach ($modelClass->getPublicProperties() as $property) {	61✔
68	if (! $property->isInitialized($model)) {	61✔
69	continue;	61✔
70	}
71
72	// HasMany relations are skipped
73	if ($property->getIterableType()?->isRelation()) {	61✔
74	continue;	33✔
75	}
76
77	$column = $property->getName();	61✔
78
79	$value = $property->getValue($model);	61✔
80
81	// BelongsTo and HasMany relations are included
82	if ($property->getType()->isRelation()) {	61✔
83	$column .= '_id';	31✔
84
85	$value = match (true) {	31✔
86	$value === null => null,	8✔
87	isset($value->id) => $value->id->id,	24✔
88	default => new InsertQueryBuilder(	12✔
89	$value::class,	12✔
90	[$value],	12✔
91	$this->serializerFactory,	12✔
92	)->build(),	12✔
93	};	31✔
94	}
95
96	// Check if value needs serialization
97	$serializer = $this->serializerFactory->forProperty($property);	61✔
98
99	if ($value !== null && $serializer !== null) {	61✔
100	$value = $serializer->serialize($value);	61✔
101	}
102
103	$entry[$column] = $value;	61✔
104	}
105
106	$entries[] = $entry;	61✔
107	}
108
109	return $entries;	63✔
110	}
111
112	private function resolveTableDefinition(): TableDefinition	63✔
113	{
114	$modelDefinition = ModelDefinition::tryFrom($this->model);	63✔
115
116	if ($modelDefinition === null) {	63✔
117	return new TableDefinition($this->model);	2✔
118	}
119
120	return $modelDefinition->getTableDefinition();	61✔
121	}
122	}

tempestphp / tempest-framework / 14107464245

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous