@effect-app/infra 0.7.0 → 0.8.1

package/_src/vendor/Cache/Cache/_internal/CacheInternal.ts

@@ -1,293 +0,0 @@
-import type { Clock } from "@effect/io/Clock"
-import { Deferred, done as doneDeferred } from "@effect/io/Deferred"
-import type { FiberId } from "@effect/io/Fiber/Id"
-import { EmptyMutableQueue } from "@fp-ts/data/MutableQueue"
-import { CacheStats } from "../../CacheStats.js"
-import { EntryStats } from "../../EntryStats.js"
-import type { Lookup } from "../../Lookup.js"
-import type { Cache } from "../definition.js"
-import { CacheURI } from "../definition.js"
-import { CacheState } from "./CacheState.js"
-import { MapKey } from "./MapKey.js"
-import type { MapValue } from "./MapValue.js"
-import { Complete, Pending, Refreshing } from "./MapValue.js"
-
-export class CacheInternal<Key, Environment, Error, Value> implements Cache<Key, Error, Value> {
-  readonly [CacheURI] = {
-    _Key: (_: Key) => void 0,
-    _Error: (_: never) => _,
-    _Value: (_: never) => _
-  }
-
-  private cacheState: CacheState<Key, Error, Value>
-
-  constructor(
-    readonly capacity: number,
-    readonly lookup: Lookup<Key, Environment, Error, Value>,
-    readonly timeToLive: (exit: Exit<Error, Value>) => DUR,
-    readonly clock: Clock,
-    readonly environment: Context<Environment>,
-    readonly fiberId: FiberId
-  ) {
-    this.cacheState = CacheState.initial<Key, Error, Value>()
-  }
-
-  get size(): Effect<never, never, number> {
-    return Effect(() => this.cacheState.map.size)
-  }
-
-  get entries(): Effect<never, never, Chunk<readonly [Key, Value]>> {
-    return Effect(() => {
-      const entries: Array<readonly [Key, Value]> = []
-      for (const [key, value] of this.cacheState.map) {
-        if (value._tag === "Complete" && value.exit.isSuccess()) {
-          entries.push([key, value.exit.value] as const)
-        }
-      }
-      return Chunk.fromIterable(entries)
-    })
-  }
-
-  get values(): Effect<never, never, Chunk<Value>> {
-    return Effect(() => {
-      const values: Array<Value> = []
-      for (const [_, value] of this.cacheState.map) {
-        if (value._tag === "Complete" && value.exit.isSuccess()) {
-          values.push(value.exit.value)
-        }
-      }
-      return Chunk.fromIterable(values)
-    })
-  }
-
-  get cacheStats(): Effect<never, never, CacheStats> {
-    return Effect(CacheStats(
-      this.cacheState.hits,
-      this.cacheState.misses,
-      this.cacheState.map.size
-    ))
-  }
-
-  entryStats(k: Key): Effect<never, never, Opt<EntryStats>> {
-    return Effect(() => {
-      const value = this.cacheState.map.get(k).value
-      if (value == null) {
-        return Opt.none
-      }
-      switch (value._tag) {
-        case "Pending": {
-          return Opt.none
-        }
-        case "Complete": {
-          return Opt(EntryStats(value.entryStats.loadedMillis))
-        }
-        case "Refreshing": {
-          return Opt(EntryStats(value.complete.entryStats.loadedMillis))
-        }
-      }
-    })
-  }
-
-  get(k: Key): Effect<never, Error, Value> {
-    return Effect.suspendSucceed(() => {
-      let key: MapKey<Key> | undefined = undefined
-      let deferred: Deferred<Error, Value> | undefined = undefined
-      let value = this.cacheState.map.get(k).value
-      if (value == null) {
-        deferred = Deferred.unsafeMake<Error, Value>(this.fiberId)
-        key = new MapKey(k)
-        if (this.cacheState.map.has(k)) {
-          value = this.cacheState.map.get(k).value!
-        } else {
-          this.cacheState.map.set(k, new Pending(key, deferred))
-        }
-      }
-      if (value == null) {
-        this.trackAccess(key!)
-        this.trackMiss()
-        return this.lookupValueOf(k, deferred!)
-      }
-      switch (value._tag) {
-        case "Pending": {
-          this.trackAccess(value.key)
-          this.trackHit()
-          return value.deferred.await
-        }
-        case "Complete": {
-          this.trackAccess(value.key)
-          this.trackHit()
-          if (this.hasExpired(value.timeToLiveMillis)) {
-            const found = this.cacheState.map.get(k).value
-            if (Equals.equals(found, value)) {
-              this.cacheState.map.remove(k)
-            }
-            return this.get(k)
-          }
-          return value.exit.done
-        }
-        case "Refreshing": {
-          this.trackAccess(value.complete.key)
-          this.trackHit()
-          if (this.hasExpired(value.complete.timeToLiveMillis)) {
-            return value.deferred.await
-          }
-          return value.complete.exit.done
-        }
-      }
-    })
-  }
-
-  set(key: Key, value: Value): Effect<never, never, void> {
-    return Effect(() => {
-      const now = this.clock.currentTimeMillis().unsafeRunSync
-      const lookupResult = Exit.succeed(value)
-      this.cacheState.map.set(
-        key,
-        new Complete(
-          new MapKey(key),
-          lookupResult,
-          EntryStats(now),
-          now + this.timeToLive(lookupResult).millis
-        )
-      )
-    })
-  }
-
-  contains(key: Key): Effect<never, never, boolean> {
-    return Effect(() => this.cacheState.map.has(key))
-  }
-
-  refresh(k: Key): Effect<never, Error, void> {
-    return Effect.suspendSucceed(() => {
-      const deferred = Deferred.unsafeMake<Error, Value>(this.fiberId)
-      let value = this.cacheState.map.get(k).value
-      if (value == null) {
-        if (this.cacheState.map.has(k)) {
-          value = this.cacheState.map.get(k).value!
-        } else {
-          this.cacheState.map.set(k, new Pending(new MapKey(k), deferred))
-        }
-      }
-      if (value == null) {
-        return this.lookupValueOf(k, deferred).asUnit
-      }
-      switch (value._tag) {
-        case "Pending": {
-          return value.deferred.await.asUnit
-        }
-        case "Complete": {
-          if (this.hasExpired(value.timeToLiveMillis)) {
-            const found = this.cacheState.map.get(k).value!
-            if (Equals.equals(found, value)) {
-              this.cacheState.map.remove(k)
-            }
-            return this.get(k).asUnit
-          }
-          // Only trigger the lookup if we're still the current value
-          return this.lookupValueOf(value.key.value, deferred)
-            .when(() => {
-              const current = this.cacheState.map.get(k).value
-              if (Equals.equals(current, value)) {
-                this.cacheState.map.set(
-                  k,
-                  new Refreshing(deferred, value as Complete<Key, Error, Value>)
-                )
-                return true
-              }
-              return false
-            })
-            .asUnit
-        }
-        case "Refreshing": {
-          return value.deferred.await.asUnit
-        }
-      }
-    })
-  }
-
-  invalidate(key: Key): Effect<never, never, void> {
-    return Effect(() => {
-      this.cacheState.map.remove(key)
-    })
-  }
-
-  invalidateAll: Effect<never, never, void> = Effect(() => {
-    this.cacheState.map = MutableHashMap.empty<Key, MapValue<Key, Error, Value>>()
-  })
-
-  private trackHit(): void {
-    this.cacheState.hits = this.cacheState.hits + 1
-  }
-
-  private trackMiss(): void {
-    this.cacheState.misses = this.cacheState.misses + 1
-  }
-
-  private trackAccess(key: MapKey<Key>): void {
-    this.cacheState.accesses.offer(key)
-    if (this.cacheState.updating.compareAndSet(false, true)) {
-      let loop = true
-      while (loop) {
-        const key = this.cacheState.accesses.poll(EmptyMutableQueue)
-        if (key === EmptyMutableQueue) {
-          loop = false
-        } else {
-          this.cacheState.keys.add(key)
-        }
-      }
-      let size = this.cacheState.map.size
-      loop = size > this.capacity
-      while (loop) {
-        const key = this.cacheState.keys.remove()
-        if (key != null) {
-          if (this.cacheState.map.remove(key.value) != null) {
-            size = size - 1
-            loop = size > this.capacity
-          }
-        } else {
-          loop = false
-        }
-      }
-      this.cacheState.updating.set(false)
-    }
-  }
-
-  private lookupValueOf(key: Key, deferred: Deferred<Error, Value>): Effect<never, Error, Value> {
-    return this.lookup(key)
-      .provideEnvironment(this.environment)
-      .exit
-      .flatMap(exit => {
-        const now = this.clock.currentTimeMillis().unsafeRunSync
-        const entryStats = EntryStats(now)
-        this.cacheState.map.set(
-          key,
-          new Complete(
-            new MapKey(key),
-            exit,
-            entryStats,
-            now + this.timeToLive(exit).millis
-          )
-        )
-        // TODO: later for updated Deferred handling
-        return doneDeferred(deferred)(exit).zipRight(exit.done)
-      })
-      .onInterrupt(() =>
-        deferred.interrupt.zipRight(Effect(() => {
-          this.cacheState.map.remove(key)
-        }))
-      )
-  }
-
-  private hasExpired(timeToLiveMillis: number): boolean {
-    return this.clock.currentTimeMillis().unsafeRunSync > timeToLiveMillis
-  }
-}
-
-/**
- * @tsplus macro remove
- */
-export function concreteCache<Key, Error, Value>(
-  _: Cache<Key, Error, Value>
-): asserts _ is CacheInternal<Key, unknown, Error, Value> {
-  //
-}

package/_src/vendor/Cache/Cache/_internal/CacheState.ts

@@ -1,56 +0,0 @@
-import { AtomicBoolean } from "./AtomicBoolean.js"
-import { KeySet } from "./KeySet.js"
-import type { MapKey } from "./MapKey.js"
-import type { MapValue } from "./MapValue.js"
-
-/**
- * The `CacheState` represents the mutable state underlying the cache.
- *
- * @tsplus type effect/cache/Cache/CacheState
- */
-export interface CacheState<Key, Error, Value> {
-  map: MutableHashMap<Key, MapValue<Key, Error, Value>>
-  keys: KeySet<Key>
-  accesses: MutableQueue<MapKey<Key>>
-  updating: AtomicBoolean
-  hits: number
-  misses: number
-}
-
-/**
- * @tsplus type effect/cache/Cache/CacheState.Ops
- */
-export interface CacheStateOps {
-  <Key, Error, Value>(
-    map: MutableHashMap<Key, MapValue<Key, Error, Value>>,
-    keys: KeySet<Key>,
-    accesses: MutableQueue<MapKey<Key>>,
-    updating: AtomicBoolean,
-    hits: number,
-    misses: number
-  ): CacheState<Key, Error, Value>
-}
-export const CacheState: CacheStateOps = (map, keys, accesses, updating, hits, misses) => ({
-  map,
-  keys,
-  accesses,
-  updating,
-  hits,
-  misses
-})
-
-/**
- * Constructs an initial cache state.
- *
- * @tsplus static effect/cache/Cache/CacheState.Ops initial
- */
-export function initial<Key, Error, Value>(): CacheState<Key, Error, Value> {
-  return CacheState(
-    MutableHashMap.empty(),
-    new KeySet(),
-    MutableQueue.unbounded(),
-    new AtomicBoolean(false),
-    0,
-    0
-  )
-}

package/_src/vendor/Cache/Cache/_internal/KeySet.ts

@@ -1,58 +0,0 @@
-import type { MapKey } from "./MapKey.js"
-
-/**
- * A `KeySet` is a sorted set of keys in the cache ordered by last access.
- * For efficiency, the set is implemented in terms of a doubly linked list
- * and is not safe for concurrent access.
- */
-export class KeySet<Key> {
-  head: MapKey<Key> | undefined = undefined
-  tail: MapKey<Key> | undefined = undefined
-
-  /**
-   * Adds the specified key to the set.
-   */
-  add(key: MapKey<Key>): void {
-    if (!Equals.equals(key, this.tail)) {
-      if (this.tail != null) {
-        const previous = key.previous
-        const next = key.next
-        if (next != null) {
-          key.next = undefined
-          if (previous != null) {
-            previous.next = next
-            next.previous = previous
-          } else {
-            this.head = next
-            this.head.previous = undefined
-          }
-        }
-        this.tail.next = key
-        key.previous = this.tail
-        this.tail = key
-      } else {
-        this.head = key
-        this.tail = key
-      }
-    }
-  }
-
-  /**
-   * Removes the lowest priority key from the set.
-   */
-  remove(): MapKey<Key> | undefined {
-    const key = this.head
-    if (key != null) {
-      const next = key.next
-      if (next) {
-        key.next = undefined
-        this.head = next
-        this.head.previous = undefined
-      } else {
-        this.head = undefined
-        this.tail = undefined
-      }
-    }
-    return key
-  }
-}

package/_src/vendor/Cache/Cache/_internal/MapKey.ts

@@ -1,43 +0,0 @@
-import { symbolEqual, symbolHash } from "@fp-ts/data/Equal"
-
-export const MapKeyURI = Symbol.for("@effect/cache/Cache/MapKey")
-export type MapKeyURI = typeof MapKeyURI
-
-/**
- * A `MapKey` represents a key in the cache. It contains mutable references
- * to the previous key and next key in the `KeySet` to support an efficient
- * implementation of a sorted set of keys.
- */
-export class MapKey<Key> implements Equals {
-  readonly [MapKeyURI]: MapKeyURI = MapKeyURI
-
-  previous: MapKey<Key> | undefined = undefined
-  next: MapKey<Key> | undefined = undefined
-
-  constructor(readonly value: Key) {}
-
-  [symbolHash](): number {
-    return Equals.hashCombine(
-      Equals.hashCombine(
-        Equals.hash(this.next)
-      )(Equals.hash(this.previous))
-    )(Equals.hash(this.value))
-  }
-
-  [symbolEqual](that: unknown): boolean {
-    if (this === that) {
-      return true
-    }
-    return isMapKey(that) &&
-      Equals.equals(this.value, that.value) &&
-      Equals.equals(this.previous, that.previous) &&
-      Equals.equals(this.next, that.next)
-  }
-}
-
-/**
- * @tsplus static effect/cache/Cache/MapKey.Ops is
- */
-export function isMapKey(u: unknown): u is MapKey<unknown> {
-  return typeof u === "object" && u != null && MapKeyURI in u
-}

package/_src/vendor/Cache/Cache/_internal/MapValue.ts

@@ -1,39 +0,0 @@
-import type { EntryStats } from "../../EntryStats/definition.js"
-import type { MapKey } from "./MapKey.js"
-
-/**
- * A `MapValue` represents a value in the cache. A value may either be
- * `Pending` with a `Deferred` 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.
- */
-export type MapValue<Key, Error, Value> =
-  | Pending<Key, Error, Value>
-  | Complete<Key, Error, Value>
-  | Refreshing<Key, Error, Value>
-
-export class Pending<Key, Error, Value> {
-  readonly _tag = "Pending"
-  constructor(
-    readonly key: MapKey<Key>,
-    readonly deferred: Deferred<Error, Value>
-  ) {}
-}
-
-export class Complete<Key, Error, Value> {
-  readonly _tag = "Complete"
-  constructor(
-    readonly key: MapKey<Key>,
-    readonly exit: Exit<Error, Value>,
-    readonly entryStats: EntryStats,
-    readonly timeToLiveMillis: number
-  ) {}
-}
-
-export class Refreshing<Key, Error, Value> {
-  readonly _tag = "Refreshing"
-  constructor(
-    readonly deferred: Deferred<Error, Value>,
-    readonly complete: Complete<Key, Error, Value>
-  ) {}
-}

package/_src/vendor/Cache/Cache/definition.ts

@@ -1,112 +0,0 @@
-import type { CacheStats } from "../CacheStats.js"
-import type { EntryStats } from "../EntryStats.js"
-
-export const CacheURI = Symbol.for("@effect/cache/Cache")
-export type CacheURI = typeof CacheURI
-
-/**
- * A `Cache` is defined in terms of a lookup function that, given a key of
- * type `Key`, can either fail with an error of type `Error` or succeed with a
- * value of type `Value`. Getting a value from the cache will either return
- * the previous result of the lookup function if it is available or else
- * compute a new result with the lookup function, put it in the cache, and
- * return it.
- *
- * A cache also has a specified capacity and time to live. When the cache is
- * at capacity the least recently accessed values in the cache will be
- * removed to make room for new values. Getting a value with a life older than
- * the specified time to live will result in a new value being computed with
- * the lookup function and returned when available.
- *
- * The cache is safe for concurrent access. If multiple fibers attempt to get
- * the same key the lookup function will only be computed once and the result
- * will be returned to all fibers.
- *
- * @tsplus type effect/cache/Cache
- */
-export interface Cache<Key, Error, Value> {
-  readonly [CacheURI]: {
-    readonly _Key: (_: Key) => void
-    readonly _Error: (_: never) => Error
-    readonly _Value: (_: never) => Value
-  }
-
-  /**
-   * Returns the approximate number of values in the cache.
-   */
-  readonly size: Effect<never, never, number>
-
-  /**
-   * Returns an approximation of the entries in the cache.
-   */
-  readonly entries: Effect<never, never, Chunk<readonly [Key, Value]>>
-
-  /**
-   * Returns an approximation of the values in the cache.
-   */
-  readonly values: Effect<never, never, Chunk<Value>>
-
-  /**
-   * Returns statistics for this cache.
-   */
-  readonly cacheStats: Effect<never, never, CacheStats>
-
-  /**
-   * Returns statistics for the specified entry, if it exists.
-   */
-  readonly entryStats: (key: Key) => Effect<never, never, Opt<EntryStats>>
-
-  /**
-   * Retrieves the value associated with the specified key if it exists.
-   * Otherwise computes the value with the lookup function, puts it in the
-   * cache, and returns it.
-   */
-  readonly get: (key: Key) => Effect<never, Error, Value>
-
-  /**
-   * Associates the specified value to the specified key in the cache.
-   */
-  readonly set: (key: Key, value: Value) => Effect<never, never, void>
-
-  /**
-   * Returns whether a value associated with the specified key exists in the
-   * cache.
-   */
-  readonly contains: (key: Key) => Effect<never, never, boolean>
-
-  /**
-   * Computes the value associated with the specified key, with the lookup
-   * function, and puts it in the cache. The difference between this and
-   * `get` method is that `refresh` triggers (re)computation of the value
-   * without invalidating it in the cache, so any request to the associated
-   * key can still be served while the value is being re-computed/retrieved
-   * by the lookup function. Additionally, `refresh` always triggers the
-   * lookup function, disregarding the last `Error`.
-   */
-  readonly refresh: (key: Key) => Effect<never, Error, void>
-
-  /**
-   * Invalidates the value associated with the specified key.
-   */
-  readonly invalidate: (key: Key) => Effect<never, never, void>
-
-  /**
-   * Invalidates all values in the cache.
-   */
-  readonly invalidateAll: Effect<never, never, void>
-}
-
-/**
- * @tsplus type effect/cache/Cache.Ops
- */
-export interface CacheOps {
-  readonly $: CacheAspects
-}
-export const Cache: CacheOps = {
-  $: {}
-}
-
-/**
- * @tsplus type effect/cache/Cache.Aspects
- */
-export interface CacheAspects {}

package/_src/vendor/Cache/Cache/operations/make.ts

@@ -1,17 +0,0 @@
-import type { Lookup } from "../../Lookup/definition.js"
-import { Cache } from "../definition.js"
-
-/**
- * Constructs a new cache with the specified capacity, time to live, and
- * lookup function.
- *
- * @tsplus static effect/cache/Cache.Ops make
- */
-export function make<Key, Environment, Error, Value>(
-  capacity: number,
-  timeToLive: DUR,
-  lookup: Lookup<Key, Environment, Error, Value>,
-  __tsplusTrace?: string
-): Effect<Environment, never, Cache<Key, Error, Value>> {
-  return Cache.makeWith(capacity, lookup, () => timeToLive)
-}

package/_src/vendor/Cache/Cache/operations/makeWith.ts

@@ -1,32 +0,0 @@
-import type { Lookup } from "../../Lookup/definition.js"
-import { CacheInternal } from "../_internal/CacheInternal.js"
-import type { Cache } from "../definition.js"
-
-/**
- * Constructs a new cache with the specified capacity, time to live, and
- * lookup function, where the time to live can depend on the `Exit` value
- * returned by the lookup function.
- *
- * @tsplus static effect/cache/Cache.Ops makeWith
- */
-export function makeWith<Key, Environment, Error, Value>(
-  capacity: number,
-  lookup: Lookup<Key, Environment, Error, Value>,
-  timeToLive: (exit: Exit<Error, Value>) => DUR,
-  __tsplusTrace?: string
-): Effect<Environment, never, Cache<Key, Error, Value>> {
-  return Effect.clockWith(clock =>
-    Effect.environment<Environment>().flatMap(environment =>
-      Effect.fiberId().map(fiberId =>
-        new CacheInternal(
-          capacity,
-          lookup,
-          timeToLive,
-          clock,
-          environment,
-          fiberId
-        )
-      )
-    )
-  )
-}

package/_src/vendor/Cache/Cache/operations.ts

@@ -1,4 +0,0 @@
-// codegen:start {preset: barrel, include: ./operations/*.ts, prefix: "@effect/cache/Cache"}
-export * from "./operations/make.js"
-export * from "./operations/makeWith.js"
-// codegen:end

package/_src/vendor/Cache/Cache.ts

@@ -1,4 +0,0 @@
-// codegen:start {preset: barrel, include: ./Cache/*.ts, prefix: "@effect/cache"}
-export * from "./Cache/definition.js"
-export * from "./Cache/operations.js"
-// codegen:end

package/_src/vendor/Cache/CacheStats/definition.ts

@@ -1,23 +0,0 @@
-/**
- * A `CacheStats` represents a snapshot of statistics for the cache as of a
- * point in time.
- *
- * @tsplus type effect/cache/CacheStats
- */
-export interface CacheStats {
-  readonly hits: number
-  readonly misses: number
-  readonly size: number
-}
-
-/**
- * @tsplus type effect/cache/CacheStats.Ops
- */
-export interface CacheStatsOps {
-  (hits: number, misses: number, size: number): CacheStats
-}
-export const CacheStats: CacheStatsOps = (hits, misses, size) => ({
-  hits,
-  misses,
-  size
-})

package/_src/vendor/Cache/CacheStats.ts

@@ -1,3 +0,0 @@
-// codegen:start {preset: barrel, include: ./CacheStats/*.ts, prefix: "@effect/cache"}
-export * from "./CacheStats/definition.js"
-// codegen:end