@effect-app/infra 0.7.0

package/_src/test.arbs.ts

@@ -0,0 +1,27 @@
+// Do not import to frontend
+
+import { setFaker } from "@effect-app/prelude/faker"
+import type { Arbitrary } from "@effect-app/prelude/schema"
+import faker from "faker"
+import { Random } from "fast-check"
+import * as fc from "fast-check"
+import * as rand from "pure-rand"
+
+const rnd = new Random(rand.congruential32(5))
+
+setFaker(faker)
+
+/**
+ * @tsplus getter FastCheck generate
+ */
+export function generate<T>(arb: fc.Arbitrary<T>) {
+  return arb.generate(rnd, undefined)
+}
+
+/**
+ * @tsplus getter ets/Schema/Arbitrary/Gen generate
+ */
+
+export function generateFromArbitrary<T>(arb: Arbitrary.Gen<T>) {
+  return generate(arb(fc))
+}

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

@@ -0,0 +1,7 @@
+import { AtomicReference } from "./AtomicReference.js"
+
+export class AtomicBoolean extends AtomicReference<boolean> {
+  constructor(b: boolean) {
+    super(b)
+  }
+}

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

@@ -0,0 +1,28 @@
+import { AtomicReference } from "./AtomicReference.js"
+
+export class AtomicNumber extends AtomicReference<number> {
+  constructor(n: number) {
+    super(n)
+
+    this.incrementAndGet = this.incrementAndGet.bind(this)
+    this.decrementAndGet = this.decrementAndGet.bind(this)
+  }
+
+  incrementAndGet() {
+    this.set(this.get + 1)
+    return this.get
+  }
+
+  decrementAndGet() {
+    this.set(this.get - 1)
+    return this.get
+  }
+
+  getAndIncrement(): number {
+    const ret = this.get
+
+    this.set(this.get + 1)
+
+    return ret
+  }
+}

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

@@ -0,0 +1,30 @@
+export class AtomicReference<A> {
+  private current: A
+
+  constructor(readonly initial: A) {
+    this.current = initial
+  }
+
+  get get() {
+    return this.current
+  }
+
+  getAndSet(value: A) {
+    const old = this.current
+
+    this.set(value)
+    return old
+  }
+
+  set(value: A) {
+    this.current = value
+  }
+
+  compareAndSet(old: A, value: A) {
+    if (this.get === old) {
+      this.set(value)
+      return true
+    }
+    return false
+  }
+}

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

@@ -0,0 +1,293 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,112 @@
+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 {}