Rule Variables

[johngeorgewright]

There can be the case where a large structure is used as a payload. For example:

foo:
  rules:
    - payload:
        a:
          b: 123
          c:
            d: dee
            e: 999

And imagine that we want to change a.c.d to something else when the target changes.

foo:
  rules:
    - targeting:
        channel: [news] 
      payload:
        a:
          b: 123
          c:
            d: D'e
            e: 999
    - payload:
        a:
          b: 123
          c:
            d: dee
            e: 999

These rules could get very large, especially if there's a lot of properties that might change depending on targeting.

Until now, we've relied on setting external rules and making use of things like @targetd/expode in the final (or next) stage.

foo:
  rules:
    - payload:
        a:
          b: 123
          c:
            d: dee
            e: 999

foo.a.c.d:
  rules:
    - targeting:
        channel: [news] 
      payload: D'e
    - payload: dee

Neither of these options are ideal. If anything, they're a flaw in the design. Why not consider using some kind of variables? For example:

foo:
  variables:
    d:
      - targeting:
          channel: [news]
        payload: D'e
      - payload: dee

  rules:
    - payload:
        a:
          b: 123
          c:
            d: {{ d }}
            e: 999

The API could look something like:

Data.create()
  .usePayload('foo', z.strictObject({
    a: z.strictObject({
      b: z.number(),
      c: z.strictObject({
        d: z.string(),
        e: z.number()
      })
    })
  }))
  .useTargeting({
    channel: targetIncludes(z.enum(['news', 'weather'])),
  })
  .addRules('foo', {
    variables: {
      d: [
        {
          targeting: {
            channel: ['news']
          },
          payload: "D'e",
        },
        {
          payload: 'dee'
        }
      ]
    },
    rules: (variable) => [
      {
        payload: {
          a: {
            b: 123,
            c: {
              d: variable.d // This would be a function that resolves variable `d`
            }
          }
        }
      }
    ]
  })

[johngeorgewright]

I took a stab at this a while back and noticed a very difficult problem. You don't really want to specifically type your variables because that would require a schema change for, what is essentially, just changing data. So when it comes to knowing what variables can be used where (especially in a YAML file) it's very difficult.

A solution that is seemingly easier to implement is adding rules within the payload. IE:

foo:
  rules:
    - payload:
        a:
          b: 123
          c:
            d:
              $rules:
                - targeting:
                    channel: [news]
                  payload: D'e
                - payload: dee
            e: 999

The only problem with the above is not utilising the idea of "embedded" rules across all rules.

[johngeorgewright]

Maybe allowing another field in the data item could aid language utilities, like YAML anchors.

foo:
  $defs:
    d: &d
      - targeting:
          channel: [news]
        payload: D'e
      - payload: dee

  rules:
    - payload:
        a:
          b: 123
          c:
            d:
              $rules: *d # This anchor can now be used multiple times.
            e: 999

[johngeorgewright]

We went for the following in the end:

foo:
  variables:
    d:
      - targeting:
          channel: [news]
        payload: D'e
      - payload: dee

  rules:
    - payload:
        a:
          b: 123
          c:
            d: {{ d }}
            e: 999