you might want to look at jsondiffpatch (disclaimer: I'm the author),

you can try it online here, just some highlights:

• a smart array diff (uses LCS to detect adds/removes, and finds item moved in arrays)
• it's pretty customizable, you can even write plugins to change any part of diff/patch mechanism
• if 2 long strings are found anywhere in the graph, it will use the Neil Fraser's lib you mention internally to get a text unidiff
• multiple formatters, html (the one used at the online demo), console, annotated, and now jsonpatch (RFC6902)

this should work for diffing/patching any 2 objects, framework agnostic, if ExtJS defines special private properties on your objects, you can ignore them specifying a propertyFilter

Yes, I think you are on the right track.

JSON-Patch (RFC6902), at its core, tries to solve the very problem you facing here: partial updates. JSON Patch offers an atomic update request that patches your JSON using a series of "add", "remove", "replace", "move" and "copy" operations. To quote one of the authors of the JSON Patch RFC, Mark Nottingham (IETF):

This has a bunch of advantages. Since it’s a generic format, you can write server- and client-side code once, and share it among a number of applications. You can do QA once, and make sure you get it right. Furthermore, your API will become less complex, because it has less URI conventions, leading to more flexibility and making it easier to approach for new developers. Using this approach will also make caches operate more correctly; since modifications to a resource will “travel” through its URL, rather than some other one, the right stored responses will get invalidated.

ASP.NET Core offers JSON-Patch support. JSON Patch can be added by installing Microsoft JSON Patch library (Nuget) from the Package Manager console:

CopyInstall-Package Microsoft.AspNetCore.JsonPatch

Then you apply patches using the JsonPatchDocument class and its methods like ApplyTo, Add, Copy, Move, Remove, Replace.

In an ASP.NET Core Web API context, we can also make use of the Microsoft.AspNetCore.Mvc.NewtonsoftJson NuGet package.

And then use the PUT and PATCH methods to update an existing resource with JSON Patch operations.

This MSDN article has some good explanations and a sample project.

In a JavaScript/Node.js project, you could also choose from a larger list of JS implementations, notably fast-json-patch.

Resources:

• Official JSON Patch documentation.
• .NET CORE Tutorials: JSON Patch With ASP.NET Core

Side note: Another option is JSON Merge Patch (RFC7396), which can be used to send partial updates as well but works more like an actual diff/patch that simply contains the changes instead of using mutating operations. In this respect, JSON Merge Patch is simpler but more limited than JSON Patch, e.g. you cannot set a key to null (since null means remove), merging only works with objects {..}, arrays [..] can only be replaced as a whole, and merging never fails, could cause side-effects and is therefore not transactional. This renders Merge Patch (overly) simplistic and impractical for certain real-world applications. There are more related projects named like JSON-Diffpatch, etc that take similar approaches. Arguably, JSON-Patch is more flexible but both have advantages and disadvantages.