08_source_interfaces.php

<?php
declare(strict_types=1);

/**
 * Example 08 — Source Interfaces (EventSourceData, EventSourceHooks, EventSourcePolicy)
 *
 * When an instance implements these optional interfaces, the executor
 * automatically queries it for custom data, hooks, or policy — no need
 * to pass them as arguments to EventExecutor::run().
 *
 *   EventSourceDataInterface   -> getEventData($name, $data)
 *   EventSourceHooksInterface  -> getEventHooks($name, $hooks)
 *   EventSourcePolicyInterface -> getEventExecutorPolicy($name)
 */

require __DIR__ . '/../vendor/autoload.php';

use Minfra\Chains\EventExecutor;
use Minfra\Chains\EventInterface;
use Minfra\Chains\EventSourceDataInterface;
use Minfra\Chains\EventSourceHooksInterface;
use Minfra\Chains\EventSourcePolicyInterface;
use Minfra\Chains\EventExecutorPolicyInterface;
use Minfra\Chains\DefaultEventExecutorPolicy;
use Minfra\Chains\Result;
use Minfra\Chains\BasicResultInterface;
use Minfra\Chains\Meta;

echo "=== 08: Source Interfaces ===\n\n";

$b = fn(bool $v) => $v ? 'true' : 'false';

// ---- 8a. EventSourceDataInterface — instance provides its own data ----

$sensor = new class implements EventSourceDataInterface {
    private float $temperature = 36.6;

    function getEventData(string $name, mixed $data): mixed {
        if ($name === 'read') {
            $data->temperature = $this->temperature;
            $data->unit = '°C';
        }
        return $data;
    }
};

$result = EventExecutor::run(
    instance: $sensor,
    name: 'read',
    hooks: function (Meta $d) {
        return Result::true($d, completed: true);
    },
);

echo "8a) EventSourceDataInterface\n";
echo "    temperature = {$result->data()->temperature}{$result->data()->unit}\n\n";

// ---- 8b. EventSourceHooksInterface — instance provides its own hooks ----

$validator = new class implements EventSourceHooksInterface {
    public string $log = '';

    function getEventHooks(string $name, array $hooks): array {
        if ($name === 'submit') {
            // Inject a validation hook into ON_BEFORE
            $hooks[EventInterface::ON_BEFORE][] = function (Meta $d) {
                $d->this->log .= '[auto-validate]';
                return null;
            };
        }
        return $hooks;
    }
};

$result = EventExecutor::run(
    instance: $validator,
    name: 'submit',
    hooks: [
        EventInterface::ON_MID => function (Meta $d) {
            $d->this->log .= '[submit]';
            return Result::true($d, completed: true);
        },
    ],
);

echo "8b) EventSourceHooksInterface\n";
echo "    log = {$validator->log}\n\n";

// ---- 8c. EventSourcePolicyInterface — instance provides its own policy ----

$resilient = new class implements EventSourcePolicyInterface {
    function getEventExecutorPolicy(string $name): EventExecutorPolicyInterface {
        // This object always wants to continue on failure
        return new DefaultEventExecutorPolicy(jump_on_failure: true);
    }
};

$log = [];
$result = EventExecutor::run(
    instance: $resilient,
    name: 'process',
    hooks: [
        EventInterface::ON_MID => [
            function (Meta $d) use (&$log) {
                $log[] = 'step1(fail)';
                return Result::false('err', $d);
            },
            function (Meta $d) use (&$log) {
                $log[] = 'step2(ok)';
                return Result::true($d, completed: true);
            },
        ],
    ],
);

echo "8c) EventSourcePolicyInterface\n";
echo "    Executed: " . implode(' -> ', $log) . "\n";
echo "    ok={$b($result->ok())} (continued past failure via instance policy)\n\n";

// ---- 8d. All three interfaces combined ----

$service = new class implements EventSourceDataInterface, EventSourceHooksInterface, EventSourcePolicyInterface {
    public array $log = [];

    function getEventData(string $name, mixed $data): mixed {
        $data->source = 'auto';
        return $data;
    }

    function getEventHooks(string $name, array $hooks): array {
        $hooks[EventInterface::ON_AFTER][] = function (Meta $d) {
            $d->this->log[] = 'auto-cleanup';
            return null;
        };
        return $hooks;
    }

    function getEventExecutorPolicy(string $name): EventExecutorPolicyInterface {
        return new DefaultEventExecutorPolicy(keep_running_on_done: true);
    }
};

$result = EventExecutor::run(
    instance: $service,
    name: 'action',
    hooks: [
        EventInterface::ON_MID => function (Meta $d) {
            $d->this->log[] = "mid(source={$d->source})";
            return Result::true($d, completed: true)->setDone();
        },
    ],
);

echo "8d) All three interfaces combined\n";
echo "    log: " . implode(' -> ', $service->log) . "\n";
echo "    ok={$b($result->ok())}\n";

echo "\n--- 08 done ---\n";