getSnapshot() doesn't traverse all nodes in the tree

[bourquep]

I have:

• A conceptual question.
  • I've checked documentation and searched for existing issues
  • I tried the spectrum channel first
• I think something is not working as it should.
  • I've checked documentation and searched for existing issues
  • I've made sure your project is based on the latest MST version
  • Fork this code sandbox or another minimal reproduction.
  • Describe expected behavior
  • Describe observed behavior
• Feature request
  • Describe the feature and why you feel your feature needs to be generically solved inside MST
  • Are you willing to (attempt) a PR?

Not following the above template might result in your issue being closed without further notice

---

It seems like getSnapshot() is broken in v3.0.0.

Running this repro code:

const { types, getSnapshot } = require("mobx-state-tree");

const Nested = types.model("Nested", {
    foo: "bar",
    name: "",
}).postProcessSnapshot(snapshot => ({ ...snapshot, "fooz": "barz" }));

const Root = types.model("Root", {
    foo: "bar",
    name: "",
    nested: types.array(Nested)
});

const nested = Nested.create({});
const root = Root.create({nested: [nested]});

console.log("Snapshot of nested node includes 'fooz' attribute added in post-process:");
const nestedSnap = getSnapshot(nested);
console.dir(nestedSnap);

console.log();

console.log("But snapshot of root node does not include post-processed attribute:");
const rootSnap = getSnapshot(root);
console.dir(rootSnap.nested[0]);

Yields this output:

Snapshot of nested node includes 'fooz' attribute added in post-process:
{ foo: 'bar', name: '', fooz: 'barz' }

But snapshot of root node does not include post-processed attribute:
{ foo: [Getter/Setter], name: [Getter/Setter] }

Running the same code against MST v2.2.0 (after moving postProcessSnapshot() to an action) yields this output:

Snapshot of nested node includes 'fooz' attribute added in post-process:
{ foo: 'bar', name: '', fooz: 'barz' }

But snapshot of root node does not include post-processed attribute:
{ foo: 'bar', name: '', fooz: 'barz' }

As you can see, calling getSnapshot() on a root node does not process the nested node's snapshot.

[bourquep]

Here's a test suite that reproduce the problem:

import { types, getSnapshot } from "../src"

const Nested = types
    .model("Nested", {
        fooz: "",
        name: ""
    })
    .postProcessSnapshot(snapshot => ({ ...snapshot, fooz: "barz" }))

const Root = types.model("Root", {
    nested: types.array(Nested)
})

const nested = Nested.create()
const root = Root.create({ nested: [nested] })

const rootWithSnapshot = Root.create({
    nested: [
        {
            fooz: "",
            name: ""
        }
    ]
})

test("it should include nested snapshot when root created with snapshot", () => {
    expect(getSnapshot(rootWithSnapshot)).toEqual({
        nested: [
            {
                fooz: "barz",
                name: ""
            }
        ]
    })
})

test("it should include nested snapshot when root created with model", () => {
    expect(getSnapshot(root)).toEqual({
        nested: [
            {
                fooz: "barz",
                name: ""
            }
        ]
    })
})

test("it properly snapshots nested model", () => {
    expect(getSnapshot(root.nested[0])).toEqual({ fooz: "barz", name: "" })
    expect(getSnapshot(rootWithSnapshot.nested[0])).toEqual({
        fooz: "barz",
        name: ""
    })
})

[xaviergonz]

If the test is changed to:

import { types, getSnapshot } from "../src"

function createData() {
    const Nested = types
        .model("Nested", {
            fooz: "barz",
            name: ""
        })
        .postProcessSnapshot(snapshot => ({ ...snapshot, fooz: "barz" }))

    const Root = types.model("Root", {
        nestedArray: types.array(Nested),
        nestedMap: types.map(Nested),
        nestedObj: Nested
    })

    const nested1 = Nested.create()
    const nested2 = Nested.create()
    const nested3 = Nested.create()
    const root = Root.create({
        nestedArray: [nested1],
        nestedMap: { k: nested3 },
        nestedObj: nested2
    })

    const nonProcessedNested = {
        fooz: "",
        name: ""
    }

    const processedNested = { fooz: "barz", name: "" }

    const rootWithSnapshot = Root.create({
        nestedArray: [nonProcessedNested],
        nestedMap: {
            k: nonProcessedNested
        },
        nestedObj: nonProcessedNested
    })

    return {
        root,
        rootWithSnapshot,
        validSnapshot: {
            nestedArray: [processedNested],
            nestedMap: {
                k: processedNested
            },
            nestedObj: processedNested
        } as typeof Root.SnapshotType
    }
}

function expectJSONToEqual(a: any, b: any) {
    expect(JSON.stringify(a)).toEqual(JSON.stringify(b))
}

test("it should include nested snapshot when root created with model", () => {
    const { root, validSnapshot } = createData()

    expectJSONToEqual(getSnapshot(root), validSnapshot)
})

test("it should include nested snapshot when root created with snapshot", () => {
    const { rootWithSnapshot, validSnapshot } = createData()

    expectJSONToEqual(getSnapshot(rootWithSnapshot), validSnapshot)
})

test("it properly snapshots nested model when root created with model", () => {
    const { root, validSnapshot } = createData()

    expectJSONToEqual(getSnapshot(root.nestedMap.get("k")!), validSnapshot.nestedMap.k)
    expectJSONToEqual(getSnapshot(root.nestedArray[0]), validSnapshot.nestedArray[0])
    expectJSONToEqual(getSnapshot(root.nestedObj), validSnapshot.nestedObj)
})

test("it properly snapshots nested model when root created with snapshot", () => {
    const { rootWithSnapshot, validSnapshot } = createData()

    expectJSONToEqual(getSnapshot(rootWithSnapshot.nestedMap.get("k")!), validSnapshot.nestedMap.k)
    expectJSONToEqual(getSnapshot(rootWithSnapshot.nestedArray[0]), validSnapshot.nestedArray[0])
    expectJSONToEqual(getSnapshot(rootWithSnapshot.nestedObj), validSnapshot.nestedObj)
})

  √ it should include nested snapshot when root created with model (5ms)
  × it should include nested snapshot when root created with snapshot (36ms)
  √ it properly snapshots nested model (child) when root created with model (2ms)
  √ it properly snapshots nested model (in array) when root created with model (3ms)
  √ it properly snapshots nested model (in map) when root created with model (3ms)
  √ it properly snapshots nested model (child) when root created with snapshot (2ms)
  √ it properly snapshots nested model (in array) when root created with snapshot (2ms)
  √ it properly snapshots nested model (in map) when root created with snapshot (3ms)

  ● it should include nested snapshot when root created with snapshot

    expect(received).toEqual(expected)

    Expected value to equal:
      "{\"nestedArray\":[{\"fooz\":\"barz\",\"name\":\"\"}],\"nestedMap\":{\"k\":{\"fooz\":\"barz\",\"name\":\"\"}},\"nestedObj\":{\"fooz\":\"barz\",\"name\":\"\"}}"
    Received:
      "{\"nestedArray\":[{\"fooz\":\"\",\"name\":\"\"}],\"nestedMap\":{\"k\":{\"fooz\":\"\",\"name\":\"\"}},\"nestedObj\":{\"fooz\":\"barz\",\"name\":\"\"}}"

The problem seems to be about the array and map not applying the children post/pre processors.
A single object seems fine.

[mweststrate]

@k-g-a ideas? Maybe we should start instantiating stuff even when just requesting the snapshot? (Or kill snapshot processors)

[mweststrate]

I'm not entirely sure this is a bug, even though the processors are indeed not run, postProcess should be the covariant of PreProcess. If your app requires your post processes to have run, it means that you are basically relying on side effects of the instantiation of your tree. I don't know where this post processing is needed for, but if it does not have a preProcessor counterpart it sounds that you should be using a view instead.

[bourquep]

I actually do have both pre and post processors. I may have oversimplified the test case a bit.

[mweststrate]

Let me put it differently to understand the problem better: why is it a problem that your postProcessor is not applied, if your preProcessor isn't applied to the snapshot either? What assumptions are made down the line about the snapshots that are broken now? Op do 26 jul. 2018 om 15:21 schreef Pascal Bourque <notifications@github.com

…

: I actually do have both pre and post processors. I may have oversimplified the test case a bit. — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#926 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ABvGhK3Li_QXIfzoNXCROoImB0ORDOAbks5uKcJigaJpZM4VTNLn> .

[bourquep]

The assumption that whenever I call getSnapshot() on a node, it will give me a properly formatted snapshot of that node and its children, that includes any post-processing that I need to do.

[mweststrate]

Yes I get that, but it doesn't answer the "why" questions ;-). What post-process assumptions are you making? Why would a view like get myCoolJSONFormattedData() { ... } not be an option? etc.

[bourquep]

I'm not sure I understand... I use getSnapshot to persist the state of my app, and expect to be able to pass that snapshot to Model.create() to load it back up. Right now, because of this issue, it doesn't work in MST3.

[mweststrate]

Ah, but if it doesn't boot up that means your preProcessor and postProcessor are not each others counterpart? Or that it matters for the preProcessor whether postProcessing is applied or not. What if you made it work for both cases? Could you share the offending preProcessor and postProcessor combination? Op do 26 jul. 2018 om 15:54 schreef Pascal Bourque <notifications@github.com

…

: I'm not sure I understand... I use getSnapshot to persist the state of my app, and expect to be able to pass that snapshot to Model.create() to load it back up. Right now, because of this issue, it doesn't work in MST3. — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#926 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ABvGhHeDbHDNXB-oi8vbdLG3IeDnHIesks5uKcorgaJpZM4VTNLn> .

[bourquep]

They are each other's counterpart. Their job is to adapt the shape of certain entities obtained from my backend API to the MST shape, and vice-versa.

In MST3, the fact that calling getSnapshot() on a root node does not post-process it's child nodes breaks this.

Again, the bug I'm seeing is:

Snapshot of nested node includes 'fooz' attribute added in post-process:
{ foo: 'bar', name: '', fooz: 'barz' }

But snapshot of root node does not include post-processed attribute:
{ foo: [Getter/Setter], name: [Getter/Setter] }

[mweststrate]

I understand the example and see what is potentially wrong with it. But I am trying to understand how this feature is used in real life & what kind of assumptions are build on top of it. So beyond the foo/bar/baz level. Is your real life case also introducing new attributes in postProcess, which are not available in the original snapshot? Are they adding information or where they just optional fields that have a default? Or are they coming from volatile state? What do these additional attributes represent? Op do 26 jul. 2018 om 16:28 schreef Pascal Bourque <notifications@github.com

…

: They are each other's counterpart. Their job is to adapt the shape of certain entities obtained from my backend API to the MST shape, and vice-versa. In MST3, the fact that calling getSnapshot() on a root node does not post-process it's child nodes breaks this. Again, the bug I'm seeing is: Snapshot of nested node includes 'fooz' attribute added in post-process: { foo: 'bar', name: '', fooz: 'barz' } But snapshot of root node does not include post-processed attribute: { foo: [Getter/Setter], name: [Getter/Setter] } — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#926 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/ABvGhIMRlPb3R3gVskM7XaIFDMSHRUZnks5uKdITgaJpZM4VTNLn> .