How should a Cacheable model be handled

[garrettg123]

Question

• I've checked documentation and searched for existing issues
• I tried the spectrum channel

Below is my Cacheable model, which automatically caches other models it is composed into.

Tldr; it updates the cache in onSnapshot and clears the cache in beforeDestroy. Optionally, it loads itself from cache in afterCreate.

import {
  flow,
  types,
  onSnapshot,
  applySnapshot,
  getSnapshot,
} from 'mobx-state-tree'

import cacheUtil from 'utils/cache'

export default function create({ key, isSelfLoadable = false }) {
  console.log(`Setting up cache at ${key}`)

  return types.model({}).actions(self => ({
    afterCreate: flow(function* afterCreate() {
      if (isSelfLoadable) {
        const data = yield cacheUtil.load(key)
        if (data) {
          try {
            applySnapshot(self, data)
          } catch (err) {
            console.warn(`Error applying snapshot for ${key}`, data, err)
            cacheUtil.clear(key)
          }
        }
      } else {
        yield cacheUtil.update(key, getSnapshot(self))
      }

      if (self.isLoading) {
        console.log('Cleared loading status', self)
        self.status = undefined
      }

      onSnapshot(self, data => {
        if (!data) {
          cacheUtil.clear(key)
          return
        }

        cacheUtil.update(key, data)
      })
    }),
    beforeDestroy: flow(function* beforeDestroy() {
      yield cacheUtil.clear(key)
    }),
  }))
}

An example to use it would be:

export default types
  .compose(
    MyModel,
    Cacheable({ key: 'myModel', isSelfLoadable: true })
  )
  .named('MyModel')

The problem is in resetting the data. When I call destroy(self.myModel), for example, it should clear the cache and remove it from state.

However, because beforeDestroy is asynchronous, and the model type is set as myModel: types.optional(MyModel, () => MyModel.create()), before it is removed from cache, it is recreated and loaded from cache, which isn't empty.

I'm wondering how to approach this issue. Should I use types.maybe(MyModel) and have an initialize: () => self.myModel = MyModel.create() or is there another way?

Thanks

[coolsoftwaretyler]

Hey @garrettg123 - I don't have a great answer for you at the moment, but I am going move this over to GitHub discussions and either revisit it myself or have others chime in. Sorry it took so long for anyone to get back to you, and I'd definitely be curious to hear if you came up with a good answer on your own or after consulting elsewhere.

Thanks!