Improve on jk patch

[dlespiau]

Currently, patch will always "deep merge" objects, ie, given:

const a = {
   key: {
     n: 2,
     s: "aString",
   },
};

patch(a, { key: { s: "anotherString" } });

will give:

{
   key: {
     n: 2,
     s: "anotherString",
   },
};

We could support an alternative merging strategy, which is to replace the value instead of deep merging it:

patch(a, { key: { s: "anotherString" } });

will give:

{
   key: {
     s: "anotherString",
   },
};

Jsonnet let people the choice of the strategy. By default, it will override the value but, by appending a +: operator to the key, the user can signal they want a deep merge instead (look for "+:" in the page: https://jsonnet.org/learning/tutorial.html)

We could support something similar, even borrowing the syntax:

patch(a, { key: { s: "anotherString" } });
->
{
   key: {
     s: "anotherString",
   },
};

patch(a, { 'key+': { s: "anotherString" } });
->
{
   key: {
     n: 2,
     s: "anotherString",
   },
};

We could also make the '+' work for arrays and say, concatenate arrays of replacing them.

[squaremo]

This is nice for merging a literal into another value ✔️

I think we will always need a procedure which will merge two values that came from computation or a file, since going through and annotating such a thing would be painful. (It doesn't have to unconditionally do deep-merge).

[dlespiau]

Other things we talked about:

• Have Symbols attached to an object describing merge strategies for that specific object
• Have a separate list of merging strategies/operations next to an object.

[rndstr]

Just wanted to put some other known merge/patch strategies on the table:

• Strategic Merge Patch (what kubectl uses for non-customresources)
• JSONPatch
• JSON merge patch

[dlespiau]

Also the merge behaviour in Hiera

[dlespiau]

There are many merging strategies, eg.:

• For objects:
  • replace the orignal object by the patch object: strategy could be named assign or replace.
  • deep merge it with the orignal value: deep
  • Ramda's mergeDeepWith and mergeDeepWithKey are a nice escape for people to define extra stratgies
• For arrays:
  • assign
  • concatenate the second one to the first one
  • final array is sorted with both sources elements
  • only keep unique array items

At the lower level, we should be able to configure the merging strategy for specific paths in objects. So it would look like:

const a = {
   key: {
     n: 2,
     s: "aString",
   },
};

const rules = {
  '.': deep,
  'key': assign:,
}

patch(a, b, rules)

If unspecified, we need a default: deep for objects (?), assign for primitive types, not sure what should be the default for arrays (assign?).

I think it'd be nice of the right hand side of rules are functions so people can define their own. This way they could define special merging strategies, even for primitive types! For instance if two objects have a count field, it could make sense that the resulting merged object has a count field with is the sum of the two counts.

Once we have that low level representation and if we want to support jsonnet patches, it should be straightforward to take a jsonnet patch and compile down a set of rules from it.

[dlespiau]

Another source of inspiration: https://reclass.pantsfullofunix.net/