ComposedStorage = async (storage1, storage2) => {
  /**
   * Puts data to all configured storages.
   * @function
   * @param {string} hash The hash of the data to put.
   * @param {*} data The data to store.
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const put = async (hash, data) => {
    await storage1.put(hash, data)
    await storage2.put(hash, data)
  }

  /**
   * Gets data from the composed storage.
   *
   * Get will fetch the data from storage1 first. If no value is found, an
   * attempt is made to fetch the data from storage2. If data exists in
   * storage2 but not in storage1, the data is added to storage1.
   * @function
   * @param {string} hash The hash of the data to get.
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const get = async (hash) => {
    let value = await storage1.get(hash)
    if (!value) {
      value = await storage2.get(hash)
      if (value) {
        await storage1.put(hash, value)
      }
    }
    return value
  }

  /**
   * Deletes a value from storage.
   * @function
   * @param {string} hash The hash of the value to delete.
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const del = async (hash) => {
    await storage1.del(hash)
    await storage2.del(hash)
  }

  /**
   * Iterates over records stored in both storages.
   * @function
   * @yields [string, string] The next key/value pair from all storages.
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const iterator = async function * ({ amount, reverse } = {}) {
    const keys = []
    const iteratorOptions = { amount: amount || -1, reverse: reverse || false }
    for (const storage of [storage1, storage2]) {
      for await (const [key, value] of storage.iterator(iteratorOptions)) {
        if (!keys[key]) {
          keys[key] = true
          yield [key, value]
        }
      }
    }
  }

  /**
   * Merges data from another source into each of the composed storages.
   * @function
   * @param {module:Storage} other Another storage instance.
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const merge = async (other) => {
    await storage1.merge(other)
    await storage2.merge(other)
    await other.merge(storage1)
    await other.merge(storage2)
  }

  /**
   * Calls clear on each of the composed storages.
   * @function
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const clear = async () => {
    await storage1.clear()
    await storage2.clear()
  }

  const persist = async (hash) => {
    if (storage1.persist) {
      await storage1.persist(hash)
    }

    if (storage2.persist) {
      await storage2.persist(hash)
    }
  }

  /**
   * Calls close on each of the composed storages.
   * @function
   * @memberof module:Storage.Storage-Composed
   * @instance
   */
  const close = async () => {
    await storage1.close()
    await storage2.close()
  }

  return {
    put,
    get,
    del,
    persist,
    iterator,
    merge,
    clear,
    close
  }
}
Creates an instance of ComposedStorage.
@function
@param {module:Storage} storage1 A storage instance.
@param {module:Storage} storage2 A storage instance.
@return {module:Storage.Storage-Composed} An instance of ComposedStorage.
@memberof module:Storage
@instance