php-delta-orchestrator/src/Action.php at master · vaened/php-delta-orchestrator · 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
<?php
/**
 * @author enea dhack <contact@vaened.dev>
 * @link https://vaened.dev DevFolio
 */

declare(strict_types=1);

namespace Vaened\DeltaOrchestrator;

use Closure;
use Throwable;
use Vaened\DeltaOrchestrator\Bindings\Behavior;
use Vaened\DeltaOrchestrator\Exceptions\InvalidActionDefinition;
use Vaened\DeltaOrchestrator\Rules\Rule;

final class Action
{
    /**
     * @param array<int, Field|Behavior> $fields
     * @param Closure(Field ...$fields): mixed $apply
     * @param (Closure(Field ...$fields): Rule)|null $when
     * @param string|null $description
     * @param (Closure(ActionFailure): Throwable)|null $failureFactory
     */
    public function __construct(
        private readonly array   $fields,
        private readonly Closure $apply,
        private ?Closure         $when = null,
        private ?string          $description = null,
        private ?Closure         $failureFactory = null,
    )
    {
        if ($this->fields === []) {
            throw new InvalidActionDefinition(
                reason     : 'Action fields cannot be empty',
                description: $this->description,
            );
        }
    }

    /**
     * @param array<int, Field|Behavior> $fields
     * @param Closure(Field ...$fields): mixed $apply
     */
    public static function from(array $fields, Closure $apply): self
    {
        return new self(
            fields: $fields,
            apply : $apply,
        );
    }

    /**
     * @return array<int, Field|Behavior>
     */
    public function fields(): array
    {
        return $this->fields;
    }

    /**
     * @return Closure(Field ...$fields): mixed
     */
    public function apply(): Closure
    {
        return $this->apply;
    }

    /**
     * @return (Closure(Field ...$fields): Rule)|null
     */
    public function condition(): ?Closure
    {
        return $this->when;
    }

    public function description(): ?string
    {
        return $this->description;
    }

    /**
     * @return (Closure(ActionFailure): Throwable)|null
     */
    public function failureFactory(): ?Closure
    {
        return $this->failureFactory;
    }

    /**
     * @param Closure(Field ...$fields): Rule $when
     */
    public function when(Closure $when): self
    {
        $this->when = $when;

        return $this;
    }

    public function describe(string $description): self
    {
        $this->description = $description;

        return $this;
    }

    /**
     * @param Closure(ActionFailure): Throwable $failureFactory
     */
    public function or(Closure $failureFactory): self
    {
        $this->failureFactory = $failureFactory;

        return $this;
    }
}