@clayroach/effect 3.19.14-source-capture.8 → 3.19.14-source-trace.2

package/src/internal/scopedCache.ts

@@ -0,0 +1,644 @@
+import type * as Cache from "../Cache.js"
+import type * as Clock from "../Clock.js"
+import * as Context from "../Context.js"
+import * as Data from "../Data.js"
+import * as Duration from "../Duration.js"
+import type * as Effect from "../Effect.js"
+import * as Equal from "../Equal.js"
+import * as Exit from "../Exit.js"
+import { pipe } from "../Function.js"
+import * as HashSet from "../HashSet.js"
+import * as MutableHashMap from "../MutableHashMap.js"
+import * as MutableQueue from "../MutableQueue.js"
+import * as MutableRef from "../MutableRef.js"
+import * as Option from "../Option.js"
+import { pipeArguments } from "../Pipeable.js"
+import * as Scope from "../Scope.js"
+import type * as ScopedCache from "../ScopedCache.js"
+import * as cache_ from "./cache.js"
+import * as effect from "./core-effect.js"
+import * as core from "./core.js"
+import * as fiberRuntime from "./fiberRuntime.js"
+
+/**
+ * The `CacheState` represents the mutable state underlying the cache.
+ *
+ * @internal
+ */
+export interface CacheState<in out Key, out Value, out Error = never> {
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
+  keys: cache_.KeySet<Key> // mutable by design
+  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>> // mutable by design
+  updating: MutableRef.MutableRef<boolean> // mutable by design
+  hits: number // mutable by design
+  misses: number // mutable by design
+}
+
+/** @internal */
+export const makeCacheState = <Key, Value, Error = never>(
+  map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
+  keys: cache_.KeySet<Key>,
+  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>>,
+  updating: MutableRef.MutableRef<boolean>,
+  hits: number,
+  misses: number
+): CacheState<Key, Value, Error> => ({
+  map,
+  keys,
+  accesses,
+  updating,
+  hits,
+  misses
+})
+
+/**
+ * Constructs an initial cache state.
+ *
+ * @internal
+ */
+export const initialCacheState = <Key, Value, Error = never>(): CacheState<Key, Value, Error> =>
+  makeCacheState(
+    MutableHashMap.empty(),
+    cache_.makeKeySet(),
+    MutableQueue.unbounded(),
+    MutableRef.make(false),
+    0,
+    0
+  )
+
+/**
+ * A `MapValue` represents a value in the cache. A value may either be
+ * `Pending` with a `Promise` that will contain the result of computing the
+ * lookup function, when it is available, or `Complete` with an `Exit` value
+ * that contains the result of computing the lookup function.
+ *
+ * @internal
+ */
+export type MapValue<Key, Value, Error> =
+  | Complete<Key, Value, Error>
+  | Pending<Key, Value, Error>
+  | Refreshing<Key, Value, Error>
+
+/** @internal */
+export interface Complete<out Key, out Value, out Error> {
+  readonly _tag: "Complete"
+  readonly key: cache_.MapKey<Key>
+  readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
+  readonly ownerCount: MutableRef.MutableRef<number>
+  readonly entryStats: Cache.EntryStats
+  readonly timeToLive: number
+}
+
+/** @internal */
+export interface Pending<out Key, out Value, out Error> {
+  readonly _tag: "Pending"
+  readonly key: cache_.MapKey<Key>
+  readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
+}
+
+/** @internal */
+export interface Refreshing<out Key, out Value, out Error> {
+  readonly _tag: "Refreshing"
+  readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
+  readonly complete: Complete<Key, Value, Error>
+}
+
+/** @internal */
+export const complete = <Key, Value, Error = never>(
+  key: cache_.MapKey<Key>,
+  exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
+  ownerCount: MutableRef.MutableRef<number>,
+  entryStats: Cache.EntryStats,
+  timeToLive: number
+): Complete<Key, Value, Error> =>
+  Data.struct({
+    _tag: "Complete",
+    key,
+    exit,
+    ownerCount,
+    entryStats,
+    timeToLive
+  })
+
+/** @internal */
+export const pending = <Key, Value, Error = never>(
+  key: cache_.MapKey<Key>,
+  scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
+): Pending<Key, Value, Error> =>
+  Data.struct({
+    _tag: "Pending",
+    key,
+    scoped
+  })
+
+/** @internal */
+export const refreshing = <Key, Value, Error = never>(
+  scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>,
+  complete: Complete<Key, Value, Error>
+): Refreshing<Key, Value, Error> =>
+  Data.struct({
+    _tag: "Refreshing",
+    scoped,
+    complete
+  })
+
+/** @internal */
+export const toScoped = <Key, Value, Error = never>(
+  self: Complete<Key, Value, Error>
+): Effect.Effect<Value, Error, Scope.Scope> =>
+  Exit.matchEffect(self.exit, {
+    onFailure: (cause) => core.failCause(cause),
+    onSuccess: ([value]) =>
+      fiberRuntime.acquireRelease(
+        core.as(core.sync(() => MutableRef.incrementAndGet(self.ownerCount)), value),
+        () => releaseOwner(self)
+      )
+  })
+
+/** @internal */
+export const releaseOwner = <Key, Value, Error = never>(
+  self: Complete<Key, Value, Error>
+): Effect.Effect<void> =>
+  Exit.matchEffect(self.exit, {
+    onFailure: () => core.void,
+    onSuccess: ([, finalizer]) =>
+      core.flatMap(
+        core.sync(() => MutableRef.decrementAndGet(self.ownerCount)),
+        (numOwner) => effect.when(finalizer(Exit.void), () => numOwner === 0)
+      )
+  })
+
+/** @internal */
+const ScopedCacheSymbolKey = "effect/ScopedCache"
+
+/** @internal */
+export const ScopedCacheTypeId: ScopedCache.ScopedCacheTypeId = Symbol.for(
+  ScopedCacheSymbolKey
+) as ScopedCache.ScopedCacheTypeId
+
+const scopedCacheVariance = {
+  /* c8 ignore next */
+  _Key: (_: unknown) => _,
+  /* c8 ignore next */
+  _Error: (_: never) => _,
+  /* c8 ignore next */
+  _Value: (_: never) => _
+}
+
+class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value>
+  implements ScopedCache.ScopedCache<Key, Value, Error>
+{
+  readonly [ScopedCacheTypeId] = scopedCacheVariance
+  readonly cacheState: CacheState<Key, Value, Error>
+  constructor(
+    readonly capacity: number,
+    readonly scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
+    readonly clock: Clock.Clock,
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration,
+    readonly context: Context.Context<Environment>
+  ) {
+    this.cacheState = initialCacheState()
+  }
+
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
+
+  get cacheStats(): Effect.Effect<Cache.CacheStats> {
+    return core.sync(() =>
+      cache_.makeCacheStats({
+        hits: this.cacheState.hits,
+        misses: this.cacheState.misses,
+        size: MutableHashMap.size(this.cacheState.map)
+      })
+    )
+  }
+
+  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error, Scope.Scope> {
+    return core.suspend(() =>
+      Option.match(MutableHashMap.get(this.cacheState.map, key), {
+        onNone: () => effect.succeedNone,
+        onSome: (value) => core.flatten(this.resolveMapValue(value))
+      })
+    )
+  }
+
+  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>, never, Scope.Scope> {
+    return core.suspend(() =>
+      Option.match(MutableHashMap.get(this.cacheState.map, key), {
+        onNone: () => effect.succeedNone,
+        onSome: (value) =>
+          core.flatten(this.resolveMapValue(value, true)) as Effect.Effect<Option.Option<Value>, never, Scope.Scope>
+      })
+    )
+  }
+
+  contains(key: Key): Effect.Effect<boolean> {
+    return core.sync(() => MutableHashMap.has(this.cacheState.map, key))
+  }
+
+  entryStats(key: Key): Effect.Effect<Option.Option<Cache.EntryStats>> {
+    return core.sync(() => {
+      const value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+      if (value === undefined) {
+        return Option.none()
+      }
+      switch (value._tag) {
+        case "Complete": {
+          return Option.some(cache_.makeEntryStats(value.entryStats.loadedMillis))
+        }
+        case "Pending": {
+          return Option.none()
+        }
+        case "Refreshing": {
+          return Option.some(cache_.makeEntryStats(value.complete.entryStats.loadedMillis))
+        }
+      }
+    })
+  }
+
+  get(key: Key): Effect.Effect<Value, Error, Scope.Scope> {
+    return pipe(
+      this.lookupValueOf(key),
+      effect.memoize,
+      core.flatMap((lookupValue) =>
+        core.suspend(() => {
+          let k: cache_.MapKey<Key> | undefined = undefined
+          let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+          if (value === undefined) {
+            k = cache_.makeMapKey(key)
+            if (MutableHashMap.has(this.cacheState.map, key)) {
+              value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+            } else {
+              MutableHashMap.set(this.cacheState.map, key, pending(k, lookupValue))
+            }
+          }
+          if (value === undefined) {
+            this.trackMiss()
+            return core.zipRight(
+              this.ensureMapSizeNotExceeded(k!),
+              lookupValue
+            )
+          }
+
+          return core.map(
+            this.resolveMapValue(value),
+            core.flatMap(Option.match({
+              onNone: () => {
+                const val = value as Complete<Key, Value, Error>
+                const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+                if (Equal.equals(current, value)) {
+                  MutableHashMap.remove(this.cacheState.map, key)
+                }
+                return pipe(
+                  this.ensureMapSizeNotExceeded(val.key),
+                  core.zipRight(releaseOwner(val)),
+                  core.zipRight(this.get(key))
+                )
+              },
+              onSome: core.succeed
+            }))
+          )
+        })
+      ),
+      core.flatten
+    )
+  }
+
+  invalidate(key: Key): Effect.Effect<void> {
+    return core.suspend(() => {
+      if (MutableHashMap.has(this.cacheState.map, key)) {
+        const mapValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))!
+        MutableHashMap.remove(this.cacheState.map, key)
+        switch (mapValue._tag) {
+          case "Complete": {
+            return releaseOwner(mapValue)
+          }
+          case "Pending": {
+            return core.void
+          }
+          case "Refreshing": {
+            return releaseOwner(mapValue.complete)
+          }
+        }
+      }
+      return core.void
+    })
+  }
+
+  get invalidateAll(): Effect.Effect<void> {
+    return fiberRuntime.forEachConcurrentDiscard(
+      HashSet.fromIterable(Array.from(this.cacheState.map).map(([key]) => key)),
+      (key) => this.invalidate(key),
+      false,
+      false
+    )
+  }
+
+  refresh(key: Key): Effect.Effect<void, Error> {
+    return pipe(
+      this.lookupValueOf(key),
+      effect.memoize,
+      core.flatMap((scoped) => {
+        let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+        let newKey: cache_.MapKey<Key> | undefined = undefined
+        if (value === undefined) {
+          newKey = cache_.makeMapKey(key)
+          if (MutableHashMap.has(this.cacheState.map, key)) {
+            value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+          } else {
+            MutableHashMap.set(this.cacheState.map, key, pending(newKey, scoped))
+          }
+        }
+        let finalScoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
+        if (value === undefined) {
+          finalScoped = core.zipRight(
+            this.ensureMapSizeNotExceeded(newKey!),
+            scoped
+          )
+        } else {
+          switch (value._tag) {
+            case "Complete": {
+              if (this.hasExpired(value.timeToLive)) {
+                finalScoped = core.succeed(this.get(key))
+              } else {
+                const current = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+                if (Equal.equals(current, value)) {
+                  const mapValue = refreshing(scoped, value)
+                  MutableHashMap.set(this.cacheState.map, key, mapValue)
+                  finalScoped = scoped
+                } else {
+                  finalScoped = core.succeed(this.get(key))
+                }
+              }
+              break
+            }
+            case "Pending": {
+              finalScoped = value.scoped
+              break
+            }
+            case "Refreshing": {
+              finalScoped = value.scoped
+              break
+            }
+          }
+        }
+        return core.flatMap(finalScoped, (s) => fiberRuntime.scopedEffect(core.asVoid(s)))
+      })
+    )
+  }
+
+  get size(): Effect.Effect<number> {
+    return core.sync(() => MutableHashMap.size(this.cacheState.map))
+  }
+
+  resolveMapValue(
+    value: MapValue<Key, Value, Error>,
+    ignorePending = false
+  ): Effect.Effect<Effect.Effect<Option.Option<Value>, Error, Scope.Scope>> {
+    switch (value._tag) {
+      case "Complete": {
+        this.trackHit()
+        if (this.hasExpired(value.timeToLive)) {
+          return core.succeed(effect.succeedNone)
+        }
+        return core.as(
+          this.ensureMapSizeNotExceeded(value.key),
+          effect.asSome(toScoped(value))
+        )
+      }
+      case "Pending": {
+        this.trackHit()
+
+        if (ignorePending) {
+          return core.succeed(effect.succeedNone)
+        }
+
+        return core.zipRight(
+          this.ensureMapSizeNotExceeded(value.key),
+          core.map(value.scoped, effect.asSome)
+        )
+      }
+      case "Refreshing": {
+        this.trackHit()
+        if (this.hasExpired(value.complete.timeToLive)) {
+          if (ignorePending) {
+            return core.succeed(effect.succeedNone)
+          }
+          return core.zipRight(
+            this.ensureMapSizeNotExceeded(value.complete.key),
+            core.map(value.scoped, effect.asSome)
+          )
+        }
+        return core.as(
+          this.ensureMapSizeNotExceeded(value.complete.key),
+          effect.asSome(toScoped(value.complete))
+        )
+      }
+    }
+  }
+
+  lookupValueOf(key: Key): Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>> {
+    return pipe(
+      core.onInterrupt(
+        core.flatMap(Scope.make(), (scope) =>
+          pipe(
+            this.scopedLookup(key),
+            core.provideContext(pipe(this.context, Context.add(Scope.Scope, scope))),
+            core.exit,
+            core.map((exit) => [exit, ((exit) => Scope.close(scope, exit)) as Scope.Scope.Finalizer] as const)
+          )),
+        () => core.sync(() => MutableHashMap.remove(this.cacheState.map, key))
+      ),
+      core.flatMap(([exit, release]) => {
+        const now = this.clock.unsafeCurrentTimeMillis()
+        const expiredAt = now + Duration.toMillis(this.timeToLive(exit))
+        switch (exit._tag) {
+          case "Success": {
+            const exitWithFinalizer: Exit.Exit<[Value, Scope.Scope.Finalizer]> = Exit.succeed([
+              exit.value,
+              release
+            ])
+            const completedResult = complete<Key, Value, Error>(
+              cache_.makeMapKey(key),
+              exitWithFinalizer,
+              MutableRef.make(1),
+              cache_.makeEntryStats(now),
+              expiredAt
+            )
+            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
+            if (MutableHashMap.has(this.cacheState.map, key)) {
+              previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+            }
+            MutableHashMap.set(this.cacheState.map, key, completedResult)
+            return core.sync(() =>
+              core.flatten(
+                core.as(
+                  this.cleanMapValue(previousValue),
+                  toScoped(completedResult)
+                )
+              )
+            )
+          }
+          case "Failure": {
+            const completedResult = complete<Key, Value, Error>(
+              cache_.makeMapKey(key),
+              exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
+              MutableRef.make(0),
+              cache_.makeEntryStats(now),
+              expiredAt
+            )
+            let previousValue: MapValue<Key, Value, Error> | undefined = undefined
+            if (MutableHashMap.has(this.cacheState.map, key)) {
+              previousValue = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
+            }
+            MutableHashMap.set(this.cacheState.map, key, completedResult)
+            return core.zipRight(
+              release(exit),
+              core.sync(() =>
+                core.flatten(
+                  core.as(
+                    this.cleanMapValue(previousValue),
+                    toScoped(completedResult)
+                  )
+                )
+              )
+            )
+          }
+        }
+      }),
+      effect.memoize,
+      core.flatten
+    )
+  }
+
+  hasExpired(timeToLive: number): boolean {
+    return this.clock.unsafeCurrentTimeMillis() > timeToLive
+  }
+
+  trackHit(): void {
+    this.cacheState.hits = this.cacheState.hits + 1
+  }
+
+  trackMiss(): void {
+    this.cacheState.misses = this.cacheState.misses + 1
+  }
+
+  trackAccess(key: cache_.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
+    const cleanedKeys: Array<MapValue<Key, Value, Error>> = []
+    MutableQueue.offer(this.cacheState.accesses, key)
+    if (MutableRef.compareAndSet(this.cacheState.updating, false, true)) {
+      let loop = true
+      while (loop) {
+        const key = MutableQueue.poll(this.cacheState.accesses, MutableQueue.EmptyMutableQueue)
+        if (key === MutableQueue.EmptyMutableQueue) {
+          loop = false
+        } else {
+          this.cacheState.keys.add(key)
+        }
+      }
+      let size = MutableHashMap.size(this.cacheState.map)
+      loop = size > this.capacity
+      while (loop) {
+        const key = this.cacheState.keys.remove()
+        if (key === undefined) {
+          loop = false
+        } else {
+          if (MutableHashMap.has(this.cacheState.map, key.current)) {
+            const removed = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key.current))!
+            MutableHashMap.remove(this.cacheState.map, key.current)
+            size = size - 1
+            cleanedKeys.push(removed)
+            loop = size > this.capacity
+          }
+        }
+      }
+      MutableRef.set(this.cacheState.updating, false)
+    }
+    return cleanedKeys
+  }
+
+  cleanMapValue(mapValue: MapValue<Key, Value, Error> | undefined): Effect.Effect<void> {
+    if (mapValue === undefined) {
+      return core.void
+    }
+    switch (mapValue._tag) {
+      case "Complete": {
+        return releaseOwner(mapValue)
+      }
+      case "Pending": {
+        return core.void
+      }
+      case "Refreshing": {
+        return releaseOwner(mapValue.complete)
+      }
+    }
+  }
+
+  ensureMapSizeNotExceeded(key: cache_.MapKey<Key>): Effect.Effect<void> {
+    return fiberRuntime.forEachConcurrentDiscard(
+      this.trackAccess(key),
+      (cleanedMapValue) => this.cleanMapValue(cleanedMapValue),
+      false,
+      false
+    )
+  }
+}
+
+/** @internal */
+export const make = <Key, Value, Error = never, Environment = never>(
+  options: {
+    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
+    readonly capacity: number
+    readonly timeToLive: Duration.DurationInput
+  }
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> => {
+  const timeToLive = Duration.decode(options.timeToLive)
+  return makeWith({
+    capacity: options.capacity,
+    lookup: options.lookup,
+    timeToLive: () => timeToLive
+  })
+}
+
+/** @internal */
+export const makeWith = <Key, Value, Error = never, Environment = never>(
+  options: {
+    readonly capacity: number
+    readonly lookup: ScopedCache.Lookup<Key, Value, Error, Environment>
+    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
+  }
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
+  core.flatMap(
+    effect.clock,
+    (clock) =>
+      buildWith(
+        options.capacity,
+        options.lookup,
+        clock,
+        (exit) => Duration.decode(options.timeToLive(exit))
+      )
+  )
+
+const buildWith = <Key, Value, Error = never, Environment = never>(
+  capacity: number,
+  scopedLookup: ScopedCache.Lookup<Key, Value, Error, Environment>,
+  clock: Clock.Clock,
+  timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.Duration
+): Effect.Effect<ScopedCache.ScopedCache<Key, Value, Error>, never, Environment | Scope.Scope> =>
+  fiberRuntime.acquireRelease(
+    core.flatMap(
+      core.context<Environment>(),
+      (context) =>
+        core.sync(() =>
+          new ScopedCacheImpl(
+            capacity,
+            scopedLookup,
+            clock,
+            timeToLive,
+            context
+          )
+        )
+    ),
+    (cache) => cache.invalidateAll
+  )