Method refresh

packages/effect/src/internal/cache.ts:450–500

(key: Key)

  }

  refresh(key: Key): Effect.Effect<void, Error> {
    return effect.clockWith((clock) =>
      core.suspend(() => {
        const k = key
        const deferred: Deferred.Deferred<Value, Error> = Deferred.unsafeMake(this.fiberId)
        let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
        if (value === undefined) {
          if (MutableHashMap.has(this.cacheState.map, k)) {
            value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
          } else {
            MutableHashMap.set(this.cacheState.map, k, pending(makeMapKey(k), deferred))
          }
        }
        if (value === undefined) {
          return core.asVoid(this.lookupValueOf(key, deferred))
        } else {
          switch (value._tag) {
            case "Complete": {
              if (this.hasExpired(clock, value.timeToLiveMillis)) {
                const found = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                if (Equal.equals(found, value)) {
                  MutableHashMap.remove(this.cacheState.map, k)
                }
                return core.asVoid(this.get(key))
              }
              // Only trigger the lookup if we're still the current value, `completedResult`
              return pipe(
                this.lookupValueOf(key, deferred),
                effect.when(() => {
                  const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k))
                  if (Equal.equals(current, value)) {
                    const mapValue = refreshing(deferred, value as Complete<Key, Value, Error>)
                    MutableHashMap.set(this.cacheState.map, k, mapValue)
                    return true
                  }
                  return false
                }),
                core.asVoid
              )
            }
            case "Pending": {
              return Deferred.await(value.deferred)
            }
            case "Refreshing": {
              return Deferred.await(value.deferred)
            }
          }
        }
      })
    )
  }

  set(key: Key, value: Value): Effect.Effect<void> {
    return effect.clockWith((clock) =>