<
A extends Request.Any,
ServiceMode extends "lookup" | "construction" = never
>(options: {
readonly capacity: number
readonly timeToLive?:
| ((exit: Request.Result<A>, request: A) => Duration.Input)
| undefined
readonly requireServicesAt?: ServiceMode | undefined
}): (
self: RequestResolver<A>
) => Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode ? never : Request.Services<A>
>,
never,
"construction" extends ServiceMode ? Request.Services<A> : never
>
<
A extends Request.Any,
ServiceMode extends "lookup" | "construction" = never
>(
self: RequestResolver<A>,
options: {
readonly capacity: number
readonly timeToLive?:
| ((exit: Request.Result<A>, request: A) => Duration.Input)
| undefined
readonly requireServicesAt?: ServiceMode | undefined
}
): Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode ? never : Request.Services<A>
>,
never,
"construction" extends ServiceMode ? Request.Services<A> : never
>Wraps a request resolver in a cache, allowing it to cache results up to a specified capacity and optional time-to-live.
When to use
Use to turn a request resolver into a first-class Cache when callers need
cache lookup, refresh, invalidation, or inspection around request results.
Details
The request value is the cache key. Cache misses run the resolver via
Effect.request, timeToLive receives the request Exit and the request,
and requireServicesAt controls whether services are required at lookup time
or construction time.
Gotchas
Cache hits depend on the request value's equality semantics.
Source effect/RequestResolver.ts:99357 lines
export const const asCache: {
<
A extends Request.Any,
ServiceMode extends
| "lookup"
| "construction" = never
>(options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}): (
self: RequestResolver<A>
) => Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode
? never
: Request.Services<A>
>,
never,
"construction" extends ServiceMode
? Request.Services<A>
: never
>
<
A extends Request.Any,
ServiceMode extends
| "lookup"
| "construction" = never
>(
self: RequestResolver<A>,
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
): Effect.Effect<
Cache.Cache<
A,
Request.Success<A>,
Request.Error<A>,
"construction" extends ServiceMode
? never
: Request.Services<A>
>,
never,
"construction" extends ServiceMode
? Request.Services<A>
: never
>
}
Wraps a request resolver in a cache, allowing it to cache results up to a
specified capacity and optional time-to-live.
When to use
Use to turn a request resolver into a first-class Cache when callers need
cache lookup, refresh, invalidation, or inspection around request results.
Details
The request value is the cache key. Cache misses run the resolver via
Effect.request, timeToLive receives the request Exit and the request,
and requireServicesAt controls whether services are required at lookup time
or construction time.
Gotchas
Cache hits depend on the request value's equality semantics.
asCache: {
<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Any = /*unresolved*/ anyAny,
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity: number
readonly timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
exit: Request.Result<A>exit: import RequestRequest.type Request.Result = /*unresolved*/ anyResult<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
request: A extends Request.Anyrequest: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import DurationDuration.type Duration.Input = /*unresolved*/ anyInput) | undefined
readonly requireServicesAt?: ServiceMode | undefinedrequireServicesAt?: function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<
import CacheCache.type Cache.Cache = /*unresolved*/ anyCache<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Success = /*unresolved*/ anySuccess<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Error = /*unresolved*/ anyError<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Services = /*unresolved*/ anyServices<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Services = /*unresolved*/ anyServices<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): (self: RequestResolver<A>) => Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Any = /*unresolved*/ anyAny,
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity: number
readonly timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
exit: Request.Result<A>exit: import RequestRequest.type Request.Result = /*unresolved*/ anyResult<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
request: A extends Request.Anyrequest: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import DurationDuration.type Duration.Input = /*unresolved*/ anyInput) | undefined
readonly requireServicesAt?: ServiceMode | undefinedrequireServicesAt?: function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<
import CacheCache.type Cache.Cache = /*unresolved*/ anyCache<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Success = /*unresolved*/ anySuccess<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Error = /*unresolved*/ anyError<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Services = /*unresolved*/ anyServices<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Services = /*unresolved*/ anyServices<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import dualdual(2, <
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Any = /*unresolved*/ anyAny,
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
interface RequestResolver<in A extends Request.Any>A resolver that executes and completes batched Request entries.
Details
A resolver controls how requests are grouped, delayed, optionally
pre-checked, and finally run. Its runAll method receives a non-empty batch
of Request.Entry values for a single batch key and must complete every
received entry, usually by calling completeUnsafe or one of the Request
completion helpers.
Gotchas
If a resolver finishes without completing an entry, the waiting request fails
because the resolver did not supply a result.
Example (Defining a request resolver)
import { Effect, Exit, RequestResolver } from "effect"
import type { Request } from "effect"
interface GetUserRequest extends Request.Request<string, Error> {
readonly _tag: "GetUserRequest"
readonly id: number
}
// In practice, you would typically use RequestResolver.make() instead
const resolver = RequestResolver.make<GetUserRequest>((entries) =>
Effect.sync(() => {
for (const entry of entries) {
entry.completeUnsafe(Exit.succeed(`User ${entry.request.id}`))
}
})
)
Namespace containing type-level helpers associated with RequestResolver.
RequestResolver<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity: number
readonly timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
exit: Request.Result<A>exit: import RequestRequest.type Request.Result = /*unresolved*/ anyResult<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
request: A extends Request.Anyrequest: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import DurationDuration.type Duration.Input = /*unresolved*/ anyInput) | undefined
readonly requireServicesAt?: ServiceMode | undefinedrequireServicesAt?: function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import EffectEffect.type Effect.Effect = /*unresolved*/ anyEffect<
import CacheCache.type Cache.Cache = /*unresolved*/ anyCache<
function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Success = /*unresolved*/ anySuccess<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Error = /*unresolved*/ anyError<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Services = /*unresolved*/ anyServices<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import RequestRequest.type Request.Services = /*unresolved*/ anyServices<function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import CacheCache.makeWith((req: A extends Request.Anyreq: function (type parameter) A in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>
import internalinternal.const request: {
<A extends Request.Any, EX = never, RX = never>(
resolver:
| RequestResolver<A>
| Effect<RequestResolver<A>, EX, RX>
): (
self: A
) => Effect<
Request.Success<A>,
Request.Error<A> | EX,
Request.Services<A> | RX
>
<A extends Request.Any, EX = never, RX = never>(
self: A,
resolver:
| RequestResolver<A>
| Effect<RequestResolver<A>, EX, RX>
): Effect<
Request.Success<A>,
Request.Error<A> | EX,
Request.Services<A> | RX
>
}
req: A extends Request.Anyreq, self: RequestResolver<A>(parameter) self: {
delay: Effect.Effect<void>;
batchKey: (entry: Request.Entry<A>) => unknown;
preCheck: ((entry: Request.Entry<A>) => boolean) | undefined;
collectWhile: (entries: ReadonlySet<Request.Entry<A>>) => boolean;
runAll: (entries: [Request.Entry<A>, ...Request.Entry<A>[]], key: unknown) => Effect.Effect<void, Request.Error<A>, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
capacity: numbercapacity: options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
capacity: numbercapacity,
timeToLive: anytimeToLive: options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
timeToLive?: | ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
requireServicesAt: ServiceMode extends "lookup" | "construction" = neverrequireServicesAt: options: {
readonly capacity: number
readonly timeToLive?:
| ((
exit: Request.Result<A>,
request: A
) => Duration.Input)
| undefined
readonly requireServicesAt?:
| ServiceMode
| undefined
}
requireServicesAt?: ServiceMode | undefinedrequireServicesAt ?? "lookup" as function (type parameter) ServiceMode in <A extends Request.Any, ServiceMode extends "lookup" | "construction" = never>(self: RequestResolver<A>, options: {
readonly capacity: number;
readonly timeToLive?: ((exit: Request.Result<A>, request: A) => Duration.Input) | undefined;
readonly requireServicesAt?: ServiceMode | undefined;
}): Effect.Effect<Cache.Cache<A, Request.Success<A>, Request.Error<A>, "construction" extends ServiceMode ? never : Request.Services<A>>, never, "construction" extends ServiceMode ? Request.Services<A> : never>