Updating event context after the rule's execution

Here is a patch that is mirroring what is done when the rule is initializing and getting all the data from the event.

I haven't added a test yet, I first want to have a feedback on the request / proposed solution. What do you think?

Hi TR, thanks for your quick reply.

I checked the link from your comment, and I think it's similar to what I am currently doing:

    // $strategies is an array
    // Allow other modules to modify it.
    $event = new StrategiesOrderAlter($strategies);

    // Get the event_dispatcher service and dispatch the event.
    $this->eventDispatcher->dispatch(StrategiesOrderAlter::EVENT_NAME, $event);

    // Get updated strategies list.
    $strategies = $event->getStrategies();

So that event subscribers can alter the $event->strategies variable (which is an event context variable). My issue is that it doesn't seem that RulesAction can modify those directly. Is there any way to access the triggering event from a RulesAction?

And what do you think overall of this patch which update the event context variable after the rules execution? That way, I can use in my RulesAction eg

$typed_data = $this->getContext('strategies')->getContextData();
$typed_data->setValue(['abc', 'def']);

and it is properly picked up when I do $strategies = $event->getStrategies();

Hi TR,

And thanks again for answering so fast. You are right I am sending a "list" conditions as context (so a TypedData)
But I don't want to modify an entity object (just a list of string), and I don't want to persist the result of the rule (so I cannot use 'Save')

Let me try to explain a bit better what I am doing (I feel that giving more explanations could help you see what I am trying to achieve):
- I am developping a module Libraries Delay Load where administrators can define various 'strategies' of delaying some javascripts load to improve performance

- On each page, this module finds out which strategy best applies. Basically, the first strategy from the list is the one applied.

When the delay load module executes, it loads the ordered list of strategies (just an array of machine names, not the configuration entity collection) and triggers a Drupal event with this strategies list as event context so that other modules can alter this list (remove a strategy if not applicable on that page /put 1 strategy first so that it's the one applied / ...).

I don't want to save / persist the result as on another page (or the same but with different conditions, eg a different user), the strategy to use can be a different one. So I want the rules to be evaluated every time with the same default set of strategies and return to the event an updated version of the strategies list.

- Then, retrieving the updated list for this page list is done by doing $strategies = $event->getStrategies();after the event has been triggered which is retrieving the (maybe modified) list of strategies from the event's context.

From what I understood from looking into the Rules engine, it is reading the Drupal event's context, but never updating it: it's creating its own rules context which can then be evaluated/modified through actions but changes are never propagated back to the Drupal event's context.

So in my RulesAction, I already have the 'strategies' context provided by the Rules Event. I am updating the strategies list doing eg:

$typed_data = $this->getContext('strategies')->getContextData();
$typed_data->setValue(['abc', 'def']);

This strategies list is available for further rules actions - but after the event executes, doing $strategies = $event->getStrategies(); in my module, I can see that the list hasn't been updated (this is because the rules' context hasn't been propagated back to the triggering Drupal event)

This is what I am fixing with the patch attached in #3. Which is working great for what I am trying to achieve.

But as I am quite new to Rules, I want to make sure that what I am explaining here makes sense, that I didn't miss an important concept, and that sending the (possibly updated) event's context back to the Drupal event is a desirable behavior for Rules.

PS I would like to avoid using Rules Components to avoid having a hard dependancy to the Rules modules (users can either implement the event subscriber or use Rules or even do nothing if they only want 1 global strategy that will always be applied)

For additional information, this is my event in module.events.yml:

libraries_delay_load_strategies_order_alter:
  label: 'Before choosing the JS Delay Strategy'
  category: 'JS Delay Load'
  context_definitions:
    strategies:
      type: 'list'
      label: 'Ordered list of strategies machine names'

And let's imagine I have a RulesAction to pick a strategy at random. RulesAction definition:

...
 * @RulesAction(
 *   id = "libraries_delay_load_randomstrategies",
 *   label = @Translation("Random JS Strategies"),
 *   category = @Translation("JS Delay Load"),
 *   context_definitions = {
 *     "strategies" = @ContextDefinition("string",
 *       label = @Translation("Ordered list of strategies machine names"),
 *       multiple = TRUE,
 *       assignment_restriction = "selector",
 *     )
 *   }
 * )
...
protected function doExecute(array $strategies) {  
    shuffle($strategies);
    $this->getContext('strategies')->getContextData()->setValue($strategies);
  }

This is working well (with the patch attached in #3. I properly have my strategies randomized.

I thought about this a bit more and I think this is the best way to go.

Attached a test case only, which should fail - and then the patch with the test case - which should pass.

Results are as expected, please review :)