orm/src/Adapter/SQL/Encode.php at da565092dfd15f2f66748317de568c62434cf17a · formal-php/orm · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
<?php
declare(strict_types = 1);

namespace Formal\ORM\Adapter\SQL;

use Formal\ORM\Raw\Aggregate;
use Formal\AccessLayer\Query;
use Innmind\Immutable\Sequence;

/**
 * @internal
 * @psalm-immutable
 * @template T of object
 */
final class Encode
{
    /**
     * @param MainTable<T> $mainTable
     */
    private function __construct(private MainTable $mainTable)
    {
    }

    /**
     * @return Sequence<Query>
     */
    public function __invoke(Aggregate $data): Sequence
    {
        $main = $this->main($data);
        $entities = $this->entities($data);
        $optionals = $this->optionals($data);
        $collections = $this->collections($data);

        return Sequence::of($main)
            ->append($entities)
            ->append($optionals)
            ->append($collections);
    }

    /**
     * @internal
     * @psalm-pure
     * @template A of object
     *
     * @param MainTable<A> $mainTable
     *
     * @return self<A>
     */
    public static function of(MainTable $mainTable): self
    {
        return new self($mainTable);
    }

    /**
     * @return Sequence<Query>
     */
    private function entities(Aggregate $data): Sequence
    {
        $mainTable = $this->mainTable;

        return $data
            ->entities()
            ->flatMap(
                static fn($entity) => $mainTable
                    ->entity($entity->name())
                    ->map(
                        static fn($table) => $table->insert($data->id(), $entity->properties()),
                    )
                    ->toSequence(),
            );
    }

    /**
     * @return Sequence<Query>
     */
    private function optionals(Aggregate $data): Sequence
    {
        $mainTable = $this->mainTable;

        return $data
            ->optionals()
            ->flatMap(
                static fn($optional) => $mainTable
                    ->optional($optional->name())
                    ->flatMap(
                        static fn($table) => $optional->properties()->map(
                            static fn($properties) => $table->insert($data->id(), $properties),
                        ),
                    )
                    ->toSequence(),
            );
    }

    private function main(Aggregate $data): Query
    {
        return $this->mainTable->insert(
            $data->id(),
            $data->properties(),
        );
    }

    /**
     * @return Sequence<Query>
     */
    private function collections(Aggregate $data): Sequence
    {
        $mainTable = $this->mainTable;

        return $data
            ->collections()
            ->flatMap(
                static fn($collection) => $mainTable
                    ->collection($collection->name())
                    ->toSequence()
                    ->flatMap(
                        static fn($table) => $table->insert(
                            $data->id(),
                            $collection->entities(),
                        ),
                    ),
            );
    }
}