Skip to main content Link Search Menu Expand Document (external link)
effect

RequestResolver overview

Added in v2.0.0

Table of contents

combinators

around

A data source aspect that executes requests between two effects, before and after, where the result of before can be used by after.

Signature

export declare const around: {
  <A2, R2, X, R3>(
    before: Effect.Effect<A2, never, R2>,
    after: (a: A2) => Effect.Effect<X, never, R3>
  ): <A, R>(self: RequestResolver<A, R>) => RequestResolver<A, R2 | R3 | R>
  <A, R, A2, R2, X, R3>(
    self: RequestResolver<A, R>,
    before: Effect.Effect<A2, never, R2>,
    after: (a: A2) => Effect.Effect<X, never, R3>
  ): RequestResolver<A, R | R2 | R3>
}

Added in v2.0.0

aroundRequests

A data source aspect that executes requests between two effects, before and after, where the result of before can be used by after.

The before and after effects are provided with the requests being executed.

Signature

export declare const aroundRequests: {
  <A, A2, R2, X, R3>(
    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
  ): <R>(self: RequestResolver<A, R>) => RequestResolver<A, R2 | R3 | R>
  <A, R, A2, R2, X, R3>(
    self: RequestResolver<A, R>,
    before: (requests: ReadonlyArray<Types.NoInfer<A>>) => Effect.Effect<A2, never, R2>,
    after: (requests: ReadonlyArray<Types.NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
  ): RequestResolver<A, R | R2 | R3>
}

Example

import { Effect, Request, RequestResolver } from "effect"

interface GetUserById extends Request.Request<unknown> {
  readonly id: number
}

const resolver = RequestResolver.fromFunction((request: GetUserById) => ({ id: request.id, name: "John" }))

RequestResolver.aroundRequests(
  resolver,
  (requests) => Effect.log(`got ${requests.length} requests`),
  (requests, _) => Effect.log(`finised running ${requests.length} requests`)
)

Added in v2.0.0

batchN

Returns a data source that executes at most n requests in parallel.

Signature

export declare const batchN: {
  (n: number): <A, R>(self: RequestResolver<A, R>) => RequestResolver<A, R>
  <A, R>(self: RequestResolver<A, R>, n: number): RequestResolver<A, R>
}

Added in v2.0.0

eitherWith

Returns a new data source that executes requests of type C using the specified function to transform C requests into requests that either this data source or that data source can execute.

Signature

export declare const eitherWith: {
  <A extends Request.Request<any, any>, R2, B extends Request.Request<any, any>, C extends Request.Request<any, any>>(
    that: RequestResolver<B, R2>,
    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
  ): <R>(self: RequestResolver<A, R>) => RequestResolver<C, R2 | R>
  <
    R,
    A extends Request.Request<any, any>,
    R2,
    B extends Request.Request<any, any>,
    C extends Request.Request<any, any>
  >(
    self: RequestResolver<A, R>,
    that: RequestResolver<B, R2>,
    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
  ): RequestResolver<C, R | R2>
}

Added in v2.0.0

locally

Returns a new data source with a localized FiberRef

Signature

export declare const locally: {
  <A>(
    self: FiberRef<A>,
    value: A
  ): <R, B extends Request.Request<any, any>>(use: RequestResolver<B, R>) => RequestResolver<B, R>
  <R, B extends Request.Request<any, any>, A>(
    use: RequestResolver<B, R>,
    self: FiberRef<A>,
    value: A
  ): RequestResolver<B, R>
}

Added in v2.0.0

race

Returns a new data source that executes requests by sending them to this data source and that data source, returning the results from the first data source to complete and safely interrupting the loser.

Signature

export declare const race: {
  <A2 extends Request.Request<any, any>, R2>(
    that: RequestResolver<A2, R2>
  ): <A extends Request.Request<any, any>, R>(self: RequestResolver<A, R>) => RequestResolver<A2 | A, R2 | R>
  <A extends Request.Request<any, any>, R, A2 extends Request.Request<any, any>, R2>(
    self: RequestResolver<A, R>,
    that: RequestResolver<A2, R2>
  ): RequestResolver<A | A2, R | R2>
}

Added in v2.0.0

constructors

fromEffect

Constructs a data source from an effectual function.

Signature

export declare const fromEffect: <R, A extends Request.Request<any, any>>(
  f: (a: A) => Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
) => RequestResolver<A, R>

Added in v2.0.0

fromEffectTagged

Constructs a data source from a list of tags paired to functions, that takes a list of requests and returns a list of results of the same size. Each item in the result list must correspond to the item at the same index in the request list.

Signature

export declare const fromEffectTagged: <A extends Request.Request<any, any> & { readonly _tag: string }>() => <
  Fns extends {
    readonly [Tag in A["_tag"]]: [Extract<A, { readonly _tag: Tag }>] extends [infer Req]
      ? Req extends Request.Request<infer ReqA, infer ReqE>
        ? (requests: Array<Req>) => Effect.Effect<Iterable<ReqA>, ReqE, any>
        : never
      : never
  }
>(
  fns: Fns
) => RequestResolver<A, ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer _A, infer _E, infer R> ? R : never>

Added in v2.0.0

fromFunction

Constructs a data source from a pure function.

Signature

export declare const fromFunction: <A extends Request.Request<any>>(
  f: (request: A) => Request.Request.Success<A>
) => RequestResolver<A>

Added in v2.0.0

fromFunctionBatched

Constructs a data source from a pure function that takes a list of requests and returns a list of results of the same size. Each item in the result list must correspond to the item at the same index in the request list.

Signature

export declare const fromFunctionBatched: <A extends Request.Request<any>>(
  f: (chunk: NonEmptyArray<A>) => Iterable<Request.Request.Success<A>>
) => RequestResolver<A>

Added in v2.0.0

make

Constructs a data source with the specified identifier and method to run requests.

Signature

export declare const make: <A, R>(
  runAll: (requests: Array<Array<A>>) => Effect.Effect<void, never, R>
) => RequestResolver<A, R>

Added in v2.0.0

makeBatched

Constructs a data source from a function taking a collection of requests.

Signature

export declare const makeBatched: <A extends Request.Request<any, any>, R>(
  run: (requests: NonEmptyArray<A>) => Effect.Effect<void, never, R>
) => RequestResolver<A, R>

Added in v2.0.0

makeWithEntry

Constructs a data source with the specified identifier and method to run requests.

Signature

export declare const makeWithEntry: <A, R>(
  runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<void, never, R>
) => RequestResolver<A, R>

Added in v2.0.0

never

A data source that never executes requests.

Signature

export declare const never: RequestResolver<never, never>

Added in v2.0.0

context

mapInputContext

Provides this data source with part of its required context.

Signature

export declare const mapInputContext: {
  <R0, R>(
    f: (context: Context.Context<R0>) => Context.Context<R>
  ): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A, R0>
  <R, A extends Request.Request<any, any>, R0>(
    self: RequestResolver<A, R>,
    f: (context: Context.Context<R0>) => Context.Context<R>
  ): RequestResolver<A, R0>
}

Added in v2.0.0

provideContext

Provides this data source with its required context.

Signature

export declare const provideContext: {
  <R>(
    context: Context.Context<R>
  ): <A extends Request.Request<any, any>>(self: RequestResolver<A, R>) => RequestResolver<A>
  <R, A extends Request.Request<any, any>>(self: RequestResolver<A, R>, context: Context.Context<R>): RequestResolver<A>
}

Added in v2.0.0

models

RequestResolver (interface)

The RequestResolver<A, R> interface requires an environment R and handles the execution of requests of type A.

Implementations must provide a runAll method, which processes a collection of requests and produces an effect that fulfills these requests. Requests are organized into a Array<Array<A>>, where the outer Array groups requests into batches that are executed sequentially, and each inner Array contains requests that can be executed in parallel. This structure allows implementations to analyze all incoming requests collectively and optimize query execution accordingly.

Implementations are typically specialized for a subtype of Request<A, E>. However, they are not strictly limited to these subtypes as long as they can map any given request type to Request<A, E>. Implementations should inspect the collection of requests to identify the needed information and execute the corresponding queries. It is imperative that implementations resolve all the requests they receive. Failing to do so will lead to a QueryFailure error during query execution.

Signature

export interface RequestResolver<in A, out R = never> extends RequestResolver.Variance<A, R>, Equal.Equal, Pipeable {
  /**
   * Execute a collection of requests. The outer `Array` represents batches
   * of requests that must be performed sequentially. The inner `Array`
   * represents a batch of requests that can be performed in parallel.
   */
  runAll(requests: Array<Array<Request.Entry<A>>>): Effect.Effect<void, never, R>

  /**
   * Identify the data source using the specific identifier
   */
  identified(...identifiers: Array<unknown>): RequestResolver<A, R>
}

Added in v2.0.0

refinements

isRequestResolver

Returns true if the specified value is a RequestResolver, false otherwise.

Signature

export declare const isRequestResolver: (u: unknown) => u is RequestResolver<unknown, unknown>

Added in v2.0.0

symbols

RequestResolverTypeId

Signature

export declare const RequestResolverTypeId: typeof RequestResolverTypeId

Added in v2.0.0

RequestResolverTypeId (type alias)

Signature

export type RequestResolverTypeId = typeof RequestResolverTypeId

Added in v2.0.0

utils

RequestResolver (namespace)

Added in v2.0.0

Variance (interface)

Signature

export interface Variance<in A, out R> {
  readonly [RequestResolverTypeId]: {
    readonly _A: Types.Contravariant<A>
    readonly _R: Types.Covariant<R>
  }
}

Added in v2.0.0

contextFromEffect

Signature

export declare const contextFromEffect: <R, A extends Request.Request<any, any>>(
  self: RequestResolver<A, R>
) => Effect.Effect<RequestResolver<A, never>, never, R>

Added in v2.0.0

contextFromServices

Signature

export declare const contextFromServices: <Services extends Array<Context.Tag<any, any>>>(
  ...services: Services
) => <R, A extends Request.Request<any, any>>(
  self: RequestResolver<A, R>
) => Effect.Effect<
  RequestResolver<A, Exclude<R, { [k in keyof Services]: Effect.Effect.Context<Services[k]> }[number]>>,
  never,
  { [k in keyof Services]: Effect.Effect.Context<Services[k]> }[number]
>

Added in v2.0.0