Is applyPatch atomic?

[BrianHung]

The description for applyPatch reads

applies a JSON-patch to the given model instance or bails out if the patch couldn't be applied

Does this imply that when given a list of patches, if applying one of the patches fails, it will revert all patches that have been applied so far?

I am looking for function that tries to apply a list of patches, and if fails, it reverts the patches applied so far and also returns a list of inversePatches that it used to revert.

[coolsoftwaretyler]

I don't think it'll revert anything. I made a quick demo and it looks like it will apply as many good patches as it can, and then throw an error without any type of cleanup. You may want to handle the error yourself and keep track of patches/revert on error or something.

[BrianHung]

Ah, thanks for the code sandbox; yeah it looks like applyPatch doesn't revert patches leading up to the patch that errors.

The solution here is to create an action at the root level that wraps applyPatch in atomic.

const TwitterStore = types
  .model("TwitterStore", {
    tweets: types.array(Tweet)
  })
  .actions((self) => ({
    applyPatch: decorate(atomic, (patches) => applyPatch(self, patches))
  }));

This will reverse all patches that have gone through so far.

It is important to note that when a patch errors, there is no inverse patch that is created by atomic since the patch was not successful.

To generate a list of inverse patches, we can use the following

import { IReversibleJsonPatch, IAnyStateTreeNode, IJsonPatch, resolvePath } from "mobx-state-tree";

/**
 * https://github.com/mobxjs/mobx-state-tree/blob/ff2afa0a124e86a9173d6912f43d783daf655ab0/packages/mobx-state-tree/src/core/node/object-node.ts#L498-L512
 */

function revertPatch(tree: IAnyStateTreeNode, patch: IJsonPatch): IReversibleJsonPatch {
  const node = resolvePath(tree, patch.path);
  return {
    ...patch,
    oldValue: node.toJSON(),
  };
}

export function invertPatches(tree: IAnyStateTreeNode, patches: IJsonPatch[]) {
  return patches.map(p => revertPatch(tree, p)).map(invertPatch);
}

export function invertPatch(patch: IReversibleJsonPatch): IJsonPatch {
  switch (patch.op) {
    case "add":
      return {
        op: "remove",
        path: patch.path,
      };
    case "remove":
      return {
        op: "add",
        path: patch.path,
        value: patch.oldValue,
      };
    case "replace":
      return {
        op: "replace",
        path: patch.path,
        value: patch.oldValue,
      };
  }
}

This is useful when you need to invert the patches sent to a client since applying remote patches failed. Atomic only stores successful patches and their inverses, but we also need inverse patches for failed patches too.

[coolsoftwaretyler]

Might also be a good use case for a custom middleware or somethin'. Thanks for all the extra details here!