@effect-app/infra 0.7.0 → 0.8.0

package/_src/services/ServiceBus.ts

@@ -1,111 +0,0 @@
-import type {
-  OperationOptionsBase,
-  ProcessErrorArgs,
-  ServiceBusMessage,
-  ServiceBusMessageBatch,
-  ServiceBusReceivedMessage,
-  ServiceBusReceiver,
-  ServiceBusSender
-} from "@azure/service-bus"
-import { ServiceBusClient } from "@azure/service-bus"
-
-function makeClient(url: string) {
-  return Effect(() => new ServiceBusClient(url)).acquireRelease(
-    client => Effect.promise(() => client.close())
-  )
-}
-
-const Client = Tag<ServiceBusClient>()
-export const LiveServiceBusClient = (url: string) => makeClient(url).toScopedLayer(Client)
-
-function makeSender(queueName: string) {
-  return Effect.gen(function*($) {
-    const serviceBusClient = yield* $(Client.access)
-
-    return yield* $(
-      Effect(() => serviceBusClient.createSender(queueName)).acquireRelease(
-        subscription => Effect.promise(() => subscription.close())
-      )
-    )
-  })
-}
-export const Sender = Tag<ServiceBusSender>()
-
-export function LiveSender(queueName: string) {
-  return makeSender(queueName).toScopedLayer(Sender)
-}
-
-function makeReceiver(queueName: string) {
-  return Effect.gen(function*($) {
-    const serviceBusClient = yield* $(Client.access)
-
-    return yield* $(
-      Effect(() => serviceBusClient.createReceiver(queueName)).acquireRelease(
-        r => Effect.promise(() => r.close())
-      )
-    )
-  })
-}
-
-export const Receiver = Tag<ServiceBusReceiver>()
-export function LiveReceiver(queueName: string) {
-  return makeReceiver(queueName).toScopedLayer(Receiver)
-}
-
-export function sendMessages(
-  messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-  options?: OperationOptionsBase
-) {
-  return Effect.gen(function*($) {
-    const s = yield* $(Sender.access)
-    return yield* $(Effect.promise(() => s.sendMessages(messages, options)))
-  })
-}
-
-export function subscribe<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>) {
-  return Effect.gen(function*($) {
-    const r = yield* $(Receiver.access)
-
-    const env = yield* $(Effect.environment<RMsg | RErr>())
-
-    yield* $(
-      Effect(() =>
-        r.subscribe({
-          processError: err =>
-            hndlr.processError(err)
-              .provideEnvironment(env)
-              .unsafeRunPromise
-              .catch(console.error),
-          processMessage: msg =>
-            hndlr.processMessage(msg)
-              .provideEnvironment(env)
-              .unsafeRunPromise
-          // DO NOT CATCH ERRORS here as they should return to the queue!
-        })
-      ).acquireRelease(
-        subscription => Effect.promise(() => subscription.close())
-      )
-    )
-  })
-}
-
-const SubscribeTag = Tag<Effect.Success<ReturnType<typeof subscribe>>>()
-
-export function Subscription<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>) {
-  return subscribe(hndlr).toScopedLayer(SubscribeTag)
-}
-
-export interface MessageHandlers<RMsg, RErr> {
-  /**
-   * Handler that processes messages from service bus.
-   *
-   * @param message - A message received from Service Bus.
-   */
-  processMessage(message: ServiceBusReceivedMessage): Effect<RMsg, never, void>
-  /**
-   * Handler that processes errors that occur during receiving.
-   * @param args - The error and additional context to indicate where
-   * the error originated.
-   */
-  processError(args: ProcessErrorArgs): Effect<RErr, never, void>
-}

package/_src/services/memQueue.ts

@@ -1,30 +0,0 @@
-import { Queue as Q } from "@effect/io/Queue"
-
-export interface MemQueue {
-  getOrCreateQueue: (k: string) => Effect<never, never, Queue<string>>
-}
-
-/**
- * @tsplus type MemQueue.Ops
- */
-
-export interface MemQueueOps extends Tag<MemQueue> {}
-export const MemQueue: MemQueueOps = Tag<MemQueue>()
-
-/**
- * @tsplus static MemQueue.Ops Live
- */
-export const LiveMemQueue = Effect.gen(function*($) {
-  const store = yield* $(Effect(new Map<string, Queue<string>>()))
-
-  return {
-    getOrCreateQueue: (k: string) =>
-      Effect.gen(function*($) {
-        const q = store.get(k)
-        if (q) return q
-        const newQ = yield* $(Q.unbounded<string>())
-        store.set(k, newQ)
-        return newQ
-      })
-  }
-}).toLayer(MemQueue)

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

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

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

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

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

@@ -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>
-  ) {}
-}