Class ImmortalStorage

src/index.js:72–185

}

class ImmortalStorage {
  constructor (stores = DEFAULT_STORES) {
    this.stores = []

    // Initialize stores asynchronously. Accept both instantiated store
    // objects and uninstantiated store classes. If the latter,
    // implicitly instantiate instances thereof in this constructor.
    //
    // This constructor must accept both instantiated store objects and
    // uninstantiated store classes because it's impossible to export
    // ImmortalStore if it only took store objects initialized
    // asynchronously. Like:
    //
    //   ;(async () => {
    //       const cookieStore = await CookieStore()
    //       const ImmortalDB = new ImmortalStorage([cookieStore])
    //       export { ImmortalDB }  // <----- Doesn't work.
    //   })
    //
    // So to export a synchronous ImmortalStorage class, datastore
    // classes (whose definitions are synchronous) must be accepted in
    // addition to instantiated store objects.
    this.onReady = (async () => {
      this.stores = (await Promise.all(
        stores.map(async StoreClassOrInstance => {
          if (typeof StoreClassOrInstance === 'object') { // Store instance.
            return StoreClassOrInstance
          } else { // Store class.
            try {
              return await new StoreClassOrInstance() // Instantiate instance.
            } catch (err) {
              // TODO(grun): Log (where?) that the <Store> constructor Promise
              // failed.
              return null
            }
          }
        }),
      )).filter(Boolean)
    })()
  }

  async get (key, _default = null) {
    await this.onReady

    const prefixedKey = `${DEFAULT_KEY_PREFIX}${key}`

    const values = await Promise.all(
      this.stores.map(async store => {
        try {
          return await store.get(prefixedKey)
        } catch (err) {
          cl(err)
        }
      }),
    )

    const counted = Array.from(countUniques(values).entries())
    counted.sort((a, b) => a[1] <= b[1])