Best way to implement inheritance for mst-gql-like payload normalizer (merge function)

[techknowfile]

I'm moving away from mst and mst-gql due to memory issues. However, I am very fond of the normalized RootStore data structure, and the automatic "merge" function that can populate the data structure with API data.

As such, I've replicated the functionality of this function in my own RootStore implementation, which I've included at the bottom of this post for completeness.

The issue I'm facing is that in order to get all of my "MobX items" to function properly with this merge function, I have them all extend a SuperClass called MobXObject. As you can see from the constructor below, this is what enables the creation of arbitrary attributes on a javascript object given some JSON:

export default class MobXObject{
  store;

  constructor(props) {
    for (const prop in props){
      this[prop]  = props[prop]
    }
  }
  __setStore(store){
    this.store = store
  }
  getStore(){
    return this.store
  }
}

But by using this approach, I'm not able to use the makeAutoObservable function, because that can't be used on classes with superclasses. It seems mobx-state-tree uses a builder-pattern approach (please let me know if there is a more accurate name for this pattern) that allows javascript prototypes to inherit functions without having to worry about class-based inheritance.

Merge function:

merge(data){
    if (!data || typeof data !== "object") return data
    if (Array.isArray(data)) return data.map(d => this.merge(d))

    const { __typename, id } = data

    //convert values deeply first to MobX objects as much as possible
    const snapshot = {}
    for (const key in data){
      snapshot[key] = this.merge(data[key])
    }

    if (__typename && this.typenameToModelMap.get(__typename)){
      // Known MobX model type, instantiate or recycle MobX model
      let AModel = this.typenameToModelMap.get(__typename)

      // Check if instance already exists in root map
      let instance = id !== undefined && this[this.modelToKeyMap.get(AModel)].get(id)
      if (instance){
        // update existing object
        Object.assign(instance, snapshot)
      } else {
        // create new object
        instance = new AModel(snapshot)
        // register in store
        this[this.modelToKeyMap.get(AModel)].set(id, instance)
        instance.__setStore(this)
      }
      return instance
    } else {
      return snapshot
    }
  }

This allows me to instantiate a RootStore with the following, where the constructor of the RootStore uses the passed object basically in place of the configureStoreMixin from mst-gql

new RootStore({
        'metricSets': MetricSet,
        'metrics': Metric,
        'metricItems':MetricItem,
        'metricItemEntries': MetricItemEntry
      })

[urugator]

There was recently a similar (?) issue, which you might want to check out #2951

Not sure why the superclass is needed? Why that logic must be part of a constructor or why __setStore/getStore must be exposed as methods on each model... ? Is user allowed to call constructor directly?