When does a node become dead?

[aniket-banyal]

I am seeing issues of these types

You are trying to read or write to an object that is no longer part of a state tree. (Object type: 'AnonymousModel', Path upon death: '/contactsStore/searchedContactsData/contactList/contacts/0/logData', Subpath: 'loading', Action: '/contactsStore/searchedContactsData/contactList/contacts/0/logData.refreshLogs()'). Either detach nodes first, or don't use objects after removing / replacing them in the tree.

Cannot modify 'AnonymousModel@/contactsStore/searchedContactsData/contactList/contacts/0/logData [dead]', the object is protected and can only be modified by using an action.

So, I am trying to understand under which cases does a node become dead.
Here are the cases as per my understanding:

• when the node was part of some collection and is either removed from the collection or collection itself is cleared
• when we explicitly call destroy on the node

Are there some other cases?

[coolsoftwaretyler]

Hey @aniket-banyal - I have a few ideas that might be helpful

One specific case you missed in your list

Let's say you have three levels in a tree:

1. The root of the tree knows about a company
2. The company knows about an employee, which is an instance of a Person node
3. The root's company gets changed into a new company with a different Person. The original Person is now dead (this example got more morbid than I expected).

Here's code to that effect:

import { types } from "mobx-state-tree";

(async function () {
  const Person = types.model("Person", {
    name: types.string,
  });

  const Company = types.model("Company", {
    name: types.string,
    employee: Person,
  });

  const RootStore = types
    .model("RootStore", {
      company: Company,
    })
    .actions((self) => ({
      changeCompanies(name: string, personName: string) {
        const person2 = Person.create({ name: personName });
        self.company = Company.create({
          name,
          employee: person2,
        });
      },
    }));

  const person1 = Person.create({ name: "John" });

  const company = Company.create({
    name: "Acme",
    employee: person1,
  });

  const root = RootStore.create({
    company,
  });

  console.log(person1.name);

  root.changeCompanies("Acme 2", "Jane");

  console.log(person1.name);
})();

CodeSandbox.

This is similar to your first case, but I wanted to clarify that the node doesn't have to be a part of a collection like an Array or Map. If it's a child of a node that gets removed from the tree, it'll die. All of the children of the node being removed die. The code above will error in the console.

Digging through the code for die()

In the codebase, I see die() called explicitly in a few places:

1. When calling destroy() directly
2. When reconciling a type
3. When reconciling array children - this is probably your first case, when a node was part of the collection
4. Looks like custom types have a reconciliation type that will call die as well
5. And so do types.lazy
6. types.reference also has a reconcile method that will kill a node

Reconciliation

I wasn't exactly sure what reconciliation is, but it looks like it's generally used in snapshots: https://github.com/mobxjs/mobx-state-tree/blob/bbcd423e413370134dcac7fa211c09ba94f4ad3c/docs/concepts/reconciliation.md

This comes up in tree semantics as well, where it's stated that:

1. Nodes in the MST tree will be reconciled (the exact same instance will be reused) when updating the tree by any means, based on their identifier property. If there is no identifier property, instances won't be reconciled.
2. If a node in the tree is replaced by another node, the original node will die and become unusable. This makes sure you are not accidentally holding on to stale objects anywhere in your application.

It looks like that comes up a lot in the private willChange method on types.model, which is called when finalizing a new instance.

Is that at all helpful? I wonder if you've got some custom type, lazy type, or reference that's getting reconciled and killing a node? Or perhaps you're replace a node or sub-tree somewhere and the reconciliation step is killing your nodes.

I'd be happy to read some sample code that you suspect is causing this.

[aniket-banyal]

Thanks @coolsoftwaretyler
The code was written by another team member, I believe the problem might have something to do with either parent node being removed or reconcilation, but let me explore more.
Will get back to you if I need some help.