Lorem Ipsum MCP Server

import type * as Cache from "../Cache.js" import type { Deferred } from "../Deferred.js" import { seconds } from "../Duration.js" import type * as Effect from "../Effect.js" import { dual } from "../Function.js" import { globalValue } from "../GlobalValue.js" import type * as Request from "../Request.js" import type * as RequestResolver from "../RequestResolver.js" import * as BlockedRequests from "./blockedRequests.js" import { unsafeMakeWith } from "./cache.js" import * as core from "./core.js" import { ensuring } from "./fiberRuntime.js" import { Listeners } from "./request.js" type RequestCache = Cache.Cache<Request.Request<any, any>, { listeners: Request.Listeners handle: Deferred<any, any> }> /** @internal */ export const currentCache = globalValue( Symbol.for("effect/FiberRef/currentCache"), () => core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, { listeners: Request.Listeners handle: Deferred<any, any> }>( 65536, () => core.map(core.deferredMake<any, any>(), (handle) => ({ listeners: new Listeners(), handle })), () => seconds(60) )) ) /** @internal */ export const currentCacheEnabled = globalValue( Symbol.for("effect/FiberRef/currentCacheEnabled"), () => core.fiberRefUnsafeMake(false) ) /** @internal */ export const fromRequest = < A extends Request.Request<any, any>, Ds extends | RequestResolver.RequestResolver<A> | Effect.Effect<RequestResolver.RequestResolver<A>, any, any> >( request: A, dataSource: Ds ): Effect.Effect< Request.Request.Success<A>, Request.Request.Error<A>, [Ds] extends [Effect.Effect<any, any, any>] ? Effect.Effect.Context<Ds> : never > => core.flatMap( (core.isEffect(dataSource) ? dataSource : core.succeed(dataSource)) as Effect.Effect< RequestResolver.RequestResolver<A> >, (ds) => core.fiberIdWith((id) => { const proxy = new Proxy(request, {}) return core.fiberRefGetWith(currentCacheEnabled, (cacheEnabled) => { if (cacheEnabled) { const cached: Effect.Effect<any, any> = core.fiberRefGetWith(currentCache, (cache) => core.flatMap(cache.getEither(proxy), (orNew) => { switch (orNew._tag) { case "Left": { if (orNew.left.listeners.interrupted) { return core.flatMap( cache.invalidateWhen(proxy, (entry) => entry.handle === orNew.left.handle), () => cached ) } orNew.left.listeners.increment() return core.uninterruptibleMask((restore) => core.flatMap( core.exit(core.blocked( BlockedRequests.empty, restore(core.deferredAwait(orNew.left.handle)) )), (exit) => { orNew.left.listeners.decrement() return exit } ) ) } case "Right": { orNew.right.listeners.increment() return core.uninterruptibleMask((restore) => core.flatMap( core.exit( core.blocked( BlockedRequests.single( ds as RequestResolver.RequestResolver<A>, BlockedRequests.makeEntry({ request: proxy, result: orNew.right.handle, listeners: orNew.right.listeners, ownerId: id, state: { completed: false } }) ), restore(core.deferredAwait(orNew.right.handle)) ) ), () => { orNew.right.listeners.decrement() return core.deferredAwait(orNew.right.handle) } ) ) } } })) return cached } const listeners = new Listeners() listeners.increment() return core.flatMap( core.deferredMake<Request.Request.Success<A>, Request.Request.Error<A>>(), (ref) => ensuring( core.blocked( BlockedRequests.single( ds as RequestResolver.RequestResolver<A>, BlockedRequests.makeEntry({ request: proxy, result: ref, listeners, ownerId: id, state: { completed: false } }) ), core.deferredAwait(ref) ), core.sync(() => listeners.decrement() ) ) ) }) }) ) /** @internal */ export const cacheRequest = <A extends Request.Request<any, any>>( request: A, result: Request.Request.Result<A> ): Effect.Effect<void> => { return core.fiberRefGetWith(currentCacheEnabled, (cacheEnabled) => { if (cacheEnabled) { return core.fiberRefGetWith(currentCache, (cache) => core.flatMap(cache.getEither(request), (orNew) => { switch (orNew._tag) { case "Left": { return core.void } case "Right": { return core.deferredComplete(orNew.right.handle, result) } } })) } return core.void }) } /** @internal */ export const withRequestCaching: { (strategy: boolean): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> <A, E, R>( self: Effect.Effect<A, E, R>, strategy: boolean ): Effect.Effect<A, E, R> } = dual< ( strategy: boolean ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>, <A, E, R>( self: Effect.Effect<A, E, R>, strategy: boolean ) => Effect.Effect<A, E, R> >(2, (self, strategy) => core.fiberRefLocally(self, currentCacheEnabled, strategy)) /** @internal */ export const withRequestCache: { (cache: Request.Cache): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> <A, E, R>( self: Effect.Effect<A, E, R>, cache: Request.Cache ): Effect.Effect<A, E, R> } = dual< ( cache: Request.Cache ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>, <A, E, R>( self: Effect.Effect<A, E, R>, cache: Request.Cache ) => Effect.Effect<A, E, R> >( 2, // @ts-expect-error (self, cache) => core.fiberRefLocally(self, currentCache, cache) )