Lorem Ipsum MCP Server

import type * as Cache from "../Cache.js" import type * as Clock from "../Clock.js" import * as Context from "../Context.js" import * as Deferred from "../Deferred.js" import * as Duration from "../Duration.js" import type * as Effect from "../Effect.js" import * as Either from "../Either.js" import * as Equal from "../Equal.js" import * as Exit from "../Exit.js" import type * as FiberId from "../FiberId.js" import { pipe } from "../Function.js" import * as Hash from "../Hash.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 { hasProperty } from "../Predicate.js" import * as effect from "./core-effect.js" import * as core from "./core.js" import * as Data from "./data.js" import { none } from "./fiberId.js" import * as fiberRuntime from "./fiberRuntime.js" /** * 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: MapKey<Key> readonly exit: Exit.Exit<Value, Error> readonly entryStats: Cache.EntryStats readonly timeToLiveMillis: number } /** @internal */ export interface Pending<out Key, in out Value, in out Error> { readonly _tag: "Pending" readonly key: MapKey<Key> readonly deferred: Deferred.Deferred<Value, Error> } /** @internal */ export interface Refreshing<out Key, in out Value, in out Error> { readonly _tag: "Refreshing" readonly deferred: Deferred.Deferred<Value, Error> readonly complete: Complete<Key, Value, Error> } /** @internal */ export const complete = <Key, Value, Error>( key: MapKey<Key>, exit: Exit.Exit<Value, Error>, entryStats: Cache.EntryStats, timeToLiveMillis: number ): MapValue<Key, Value, Error> => Data.struct({ _tag: "Complete" as const, key, exit, entryStats, timeToLiveMillis }) /** @internal */ export const pending = <Key, Value, Error>( key: MapKey<Key>, deferred: Deferred.Deferred<Value, Error> ): MapValue<Key, Value, Error> => Data.struct({ _tag: "Pending" as const, key, deferred }) /** @internal */ export const refreshing = <Key, Value, Error>( deferred: Deferred.Deferred<Value, Error>, complete: Complete<Key, Value, Error> ): MapValue<Key, Value, Error> => Data.struct({ _tag: "Refreshing" as const, deferred, complete }) /** @internal */ export const MapKeyTypeId = Symbol.for("effect/Cache/MapKey") /** @internal */ export type MapKeyTypeId = typeof MapKeyTypeId /** * 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. * * @internal */ export interface MapKey<out K> extends Equal.Equal { readonly [MapKeyTypeId]: MapKeyTypeId readonly current: K previous: MapKey<K> | undefined // mutable by design next: MapKey<K> | undefined // mutable by design } class MapKeyImpl<out K> implements MapKey<K> { readonly [MapKeyTypeId]: MapKeyTypeId = MapKeyTypeId previous: MapKey<K> | undefined = undefined next: MapKey<K> | undefined = undefined constructor(readonly current: K) {} [Hash.symbol](): number { return pipe( Hash.hash(this.current), Hash.combine(Hash.hash(this.previous)), Hash.combine(Hash.hash(this.next)), Hash.cached(this) ) } [Equal.symbol](that: unknown): boolean { if (this === that) { return true } return isMapKey(that) && Equal.equals(this.current, that.current) && Equal.equals(this.previous, that.previous) && Equal.equals(this.next, that.next) } } /** @internal */ export const makeMapKey = <K>(current: K): MapKey<K> => new MapKeyImpl(current) /** @internal */ export const isMapKey = (u: unknown): u is MapKey<unknown> => hasProperty(u, MapKeyTypeId) /** * 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. * * @internal */ export interface KeySet<in out K> { head: MapKey<K> | undefined // mutable by design tail: MapKey<K> | undefined // mutable by design /** * Adds the specified key to the set. */ add(key: MapKey<K>): void /** * Removes the lowest priority key from the set. */ remove(): MapKey<K> | undefined } class KeySetImpl<in out K> implements KeySet<K> { head: MapKey<K> | undefined = undefined tail: MapKey<K> | undefined = undefined add(key: MapKey<K>): void { if (key !== this.tail) { if (this.tail === undefined) { this.head = key this.tail = key } else { const previous = key.previous const next = key.next if (next !== undefined) { key.next = undefined if (previous !== undefined) { 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 } } } remove(): MapKey<K> | undefined { const key = this.head if (key !== undefined) { const next = key.next if (next !== undefined) { key.next = undefined this.head = next this.head.previous = undefined } else { this.head = undefined this.tail = undefined } } return key } } /** @internal */ export const makeKeySet = <K>(): KeySet<K> => new KeySetImpl<K>() /** * The `CacheState` represents the mutable state underlying the cache. * * @internal */ export interface CacheState<in out Key, in out Value, in out Error> { map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design keys: KeySet<Key> // mutable by design accesses: MutableQueue.MutableQueue<MapKey<Key>> // mutable by design updating: MutableRef.MutableRef<boolean> // mutable by design hits: number // mutable by design misses: number // mutable by design } /** * Constructs a new `CacheState` from the specified values. * * @internal */ export const makeCacheState = <Key, Value, Error>( map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>, keys: KeySet<Key>, accesses: MutableQueue.MutableQueue<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>(): CacheState<Key, Value, Error> => makeCacheState( MutableHashMap.empty(), makeKeySet(), MutableQueue.unbounded(), MutableRef.make(false), 0, 0 ) /** @internal */ const CacheSymbolKey = "effect/Cache" /** @internal */ export const CacheTypeId: Cache.CacheTypeId = Symbol.for( CacheSymbolKey ) as Cache.CacheTypeId const cacheVariance = { /* c8 ignore next */ _Key: (_: any) => _, /* c8 ignore next */ _Error: (_: never) => _, /* c8 ignore next */ _Value: (_: any) => _ } /** @internal */ const ConsumerCacheSymbolKey = "effect/ConsumerCache" /** @internal */ export const ConsumerCacheTypeId: Cache.ConsumerCacheTypeId = Symbol.for( ConsumerCacheSymbolKey ) as Cache.ConsumerCacheTypeId const consumerCacheVariance = { /* c8 ignore next */ _Key: (_: any) => _, /* c8 ignore next */ _Error: (_: never) => _, /* c8 ignore next */ _Value: (_: never) => _ } /** @internal */ export const makeCacheStats = ( options: { readonly hits: number readonly misses: number readonly size: number } ): Cache.CacheStats => options /** @internal */ export const makeEntryStats = (loadedMillis: number): Cache.EntryStats => ({ loadedMillis }) class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> { readonly [CacheTypeId] = cacheVariance readonly [ConsumerCacheTypeId] = consumerCacheVariance readonly cacheState: CacheState<Key, Value, Error> constructor( readonly capacity: number, readonly context: Context.Context<any>, readonly fiberId: FiberId.FiberId, readonly lookup: Cache.Lookup<Key, Value, Error, any>, readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput ) { this.cacheState = initialCacheState() } get(key: Key): Effect.Effect<Value, Error> { return core.map(this.getEither(key), Either.merge) } get cacheStats(): Effect.Effect<Cache.CacheStats> { return core.sync(() => makeCacheStats({ hits: this.cacheState.hits, misses: this.cacheState.misses, size: MutableHashMap.size(this.cacheState.map) }) ) } getOption(key: Key): Effect.Effect<Option.Option<Value>, Error> { return core.suspend(() => Option.match(MutableHashMap.get(this.cacheState.map, key), { onNone: () => { const mapKey = makeMapKey(key) this.trackAccess(mapKey) this.trackMiss() return core.succeed(Option.none<Value>()) }, onSome: (value) => this.resolveMapValue(value) }) ) } getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>> { return core.suspend(() => Option.match(MutableHashMap.get(this.cacheState.map, key), { onNone: () => { const mapKey = makeMapKey(key) this.trackAccess(mapKey) this.trackMiss() return core.succeed(Option.none<Value>()) }, onSome: (value) => this.resolveMapValue(value, true) as Effect.Effect<Option.Option<Value>> }) ) } 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 option = MutableHashMap.get(this.cacheState.map, key) if (Option.isSome(option)) { switch (option.value._tag) { case "Complete": { const loaded = option.value.entryStats.loadedMillis return Option.some(makeEntryStats(loaded)) } case "Pending": { return Option.none() } case "Refreshing": { const loaded = option.value.complete.entryStats.loadedMillis return Option.some(makeEntryStats(loaded)) } } } return Option.none() }) } getEither(key: Key): Effect.Effect<Either.Either<Value, Value>, Error> { return core.suspend((): Effect.Effect<Either.Either<Value, Value>, Error> => { const k = key let mapKey: MapKey<Key> | undefined = undefined let deferred: Deferred.Deferred<Value, Error> | undefined = undefined let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k)) if (value === undefined) { deferred = Deferred.unsafeMake<Value, Error>(this.fiberId) mapKey = makeMapKey(k) if (MutableHashMap.has(this.cacheState.map, k)) { value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, k)) } else { MutableHashMap.set(this.cacheState.map, k, pending(mapKey, deferred)) } } if (value === undefined) { this.trackAccess(mapKey!) this.trackMiss() return core.map(this.lookupValueOf(key, deferred!), Either.right) } else { return core.flatMap( this.resolveMapValue(value), Option.match({ onNone: () => this.getEither(key), onSome: (value) => core.succeed(Either.left(value)) }) ) } }) } invalidate(key: Key): Effect.Effect<void> { return core.sync(() => { MutableHashMap.remove(this.cacheState.map, key) }) } invalidateWhen(key: Key, when: (value: Value) => boolean): Effect.Effect<void> { return core.sync(() => { const value = MutableHashMap.get(this.cacheState.map, key) if (Option.isSome(value) && value.value._tag === "Complete") { if (value.value.exit._tag === "Success") { if (when(value.value.exit.value)) { MutableHashMap.remove(this.cacheState.map, key) } } } }) } get invalidateAll(): Effect.Effect<void> { return core.sync(() => { this.cacheState.map = MutableHashMap.empty() }) } 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) => core.sync(() => { const now = clock.unsafeCurrentTimeMillis() const k = key const lookupResult = Exit.succeed(value) const mapValue = complete( makeMapKey(k), lookupResult, makeEntryStats(now), now + Duration.toMillis(Duration.decode(this.timeToLive(lookupResult))) ) MutableHashMap.set( this.cacheState.map, k, mapValue as Complete<Key, Value, Error> ) }) ) } get size(): Effect.Effect<number> { return core.sync(() => { return MutableHashMap.size(this.cacheState.map) }) } get values(): Effect.Effect<Array<Value>> { return core.sync(() => { const values: Array<Value> = [] for (const entry of this.cacheState.map) { if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") { values.push(entry[1].exit.value) } } return values }) } get entries(): Effect.Effect<Array<[Key, Value]>> { return core.sync(() => { const values: Array<[Key, Value]> = [] for (const entry of this.cacheState.map) { if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") { values.push([entry[0], entry[1].exit.value]) } } return values }) } get keys(): Effect.Effect<Array<Key>> { return core.sync(() => { const keys: Array<Key> = [] for (const entry of this.cacheState.map) { if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") { keys.push(entry[0]) } } return keys }) } resolveMapValue( value: MapValue<Key, Value, Error>, ignorePending = false ): Effect.Effect<Option.Option<Value>, Error> { return effect.clockWith((clock) => { switch (value._tag) { case "Complete": { this.trackAccess(value.key) if (this.hasExpired(clock, value.timeToLiveMillis)) { MutableHashMap.remove(this.cacheState.map, value.key.current) return core.succeed(Option.none<Value>()) } this.trackHit() return core.map(value.exit, Option.some) } case "Pending": { this.trackAccess(value.key) this.trackHit() if (ignorePending) { return core.succeed(Option.none<Value>()) } return core.map(Deferred.await(value.deferred), Option.some) } case "Refreshing": { this.trackAccess(value.complete.key) this.trackHit() if (this.hasExpired(clock, value.complete.timeToLiveMillis)) { if (ignorePending) { return core.succeed(Option.none<Value>()) } return core.map(Deferred.await(value.deferred), Option.some) } return core.map(value.complete.exit, Option.some) } } }) } trackHit(): void { this.cacheState.hits = this.cacheState.hits + 1 } trackMiss(): void { this.cacheState.misses = this.cacheState.misses + 1 } trackAccess(key: MapKey<Key>): void { 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) { if (MutableHashMap.has(this.cacheState.map, key.current)) { MutableHashMap.remove(this.cacheState.map, key.current) size = size - 1 loop = size > this.capacity } } else { loop = false } } MutableRef.set(this.cacheState.updating, false) } } hasExpired(clock: Clock.Clock, timeToLiveMillis: number): boolean { return clock.unsafeCurrentTimeMillis() > timeToLiveMillis } lookupValueOf( input: Key, deferred: Deferred.Deferred<Value, Error> ): Effect.Effect<Value, Error> { return effect.clockWith((clock) => core.suspend(() => { const key = input return pipe( this.lookup(input), core.provideContext(this.context), core.exit, core.flatMap((exit) => { const now = clock.unsafeCurrentTimeMillis() const stats = makeEntryStats(now) const value = complete( makeMapKey(key), exit, stats, now + Duration.toMillis(Duration.decode(this.timeToLive(exit))) ) MutableHashMap.set(this.cacheState.map, key, value) return core.zipRight( Deferred.done(deferred, exit), exit ) }), core.onInterrupt(() => core.zipRight( Deferred.interrupt(deferred), core.sync(() => { MutableHashMap.remove(this.cacheState.map, key) }) ) ) ) }) ) } } /** @internal */ export const make = <Key, Value, Error = never, Environment = never>( options: { readonly capacity: number readonly timeToLive: Duration.DurationInput readonly lookup: Cache.Lookup<Key, Value, Error, Environment> } ): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> => { 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: Cache.Lookup<Key, Value, Error, Environment> readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput } ): Effect.Effect<Cache.Cache<Key, Value, Error>, never, Environment> => core.map( fiberRuntime.all([core.context<Environment>(), core.fiberId]), ([context, fiberId]) => new CacheImpl( options.capacity, context, fiberId, options.lookup, (exit) => Duration.decode(options.timeToLive(exit)) ) ) /** @internal */ export const unsafeMakeWith = <Key, Value, Error = never>( capacity: number, lookup: Cache.Lookup<Key, Value, Error>, timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput ): Cache.Cache<Key, Value, Error> => new CacheImpl<Key, Value, Error>( capacity, Context.empty() as Context.Context<any>, none, lookup, (exit) => Duration.decode(timeToLive(exit)) )