Value.Diff, Value.Patch and rfc6902?

[jessekrubin]

Howdy @sinclairzx81 !

Hope all is well! parse-box looks very cool!

Is there a reason that Value.Diff and Value.Patch do not adhere to rfc6902?

Just curious!

ref: https://datatracker.ietf.org/doc/html/rfc6902

[sinclairzx81]

@jessekrubin Hi!

Is there a reason that Value.Diff and Value.Patch do not adhere to rfc6902?

Ah, I did look at this specification prior to writing the Diff / Patch functions. Implementing a Patch function proved to be quite straight forward, however generating an optimal set of Diff ops based on RFC6902 proved to be the difficult part (and didn't have much time to implement the functionality at the time of writing)

I ended up opting for the current Insert, Update, Delete protocol (where these operation were much simpler to generate Diffs for), and decided that should I revisit RFC6902, updating the protocol should be fine so long as implementations treat the Edit array as some opaque data structure (meaning TypeBox can change the protocol underneath, and so long as versions match at either end, everything should just work)

Would like to revisit Diff / Patch with a focus on RFC6902, but needs research into an efficient Diff algorithm. It's a nice focused bit of work actually, but need to prioritize other aspects of the library in the short to medium term.

Hope this brings some insight!
S

[jessekrubin]

Thanks for the info!

What about migrating the current diff output to match RFC6902 in terms of the structure? Or is that not as straightforward as I imagine it to be?

[sinclairzx81]

@jessekrubin Hi,

What about migrating the current diff output to match RFC6902 in terms of the structure? Or is that not as straightforward as I imagine it to be?

Hmmm, maybe ... but only if it's possible to translate the current Edit structures into compatible RFC6902 structures. Looking at the spec again, it might be possible to replace Insert, Update and Delete ops with add, replace and remove ops (respectively). As a fun experiment, do you want to try map the current structures?

const A = { a: 1, b: 2 }
const B = { b: 3, c: 4 }

const E = Value.Diff(A, B)

// Map Edits to RFC6902 ops
const M = E.map(edit => {
  return {
    edit.type === 'Insert' ? { op: 'add', .... } :
    edit.type === 'Update' ? { op: 'replace', .... } :
    edit.type === 'Delete' ? { op: 'remove', .... } :
    (() => { throw Error('unreachable') })()
  }
})

If a direct mapping is possible AND if the mapped edits are understood by existing tooling that understands RFC6902 (will need to find a project that works on the spec), then I think it would be possible to just have the Diff and Patch be updated to emit the specification directly (this would be a nice update for TypeBox)

Would you like to do a bit of research into this?

[jessekrubin]

Happy to!

Do you mean research on the changes that would have to occur within typebox specifically?

This would constitute a breaking change, right?

Food for thought: I do think it would be nice to have a package containing common/standard schemas (eg tsconfig/package.json) people might wish existed. I cannot think of a name for such a package which is always a good first step (I think something about typebox + some-sort-of-boxed/storage-pun).