RequestResolver.fromEffect — API

RequestResolver.fromEffectconsteffect/RequestResolver.ts:428

<A extends Request.Any>(
  f: (
    entry: Request.Entry<A>
  ) => Effect.Effect<Request.Success<A>, Request.Error<A>>
): RequestResolver<A>

Constructs a request resolver from an effectual function.

Example (Creating a resolver from an effectful function)

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

interface GetUserFromAPIRequest extends Request.Request<string> {
  readonly _tag: "GetUserFromAPIRequest"
  readonly id: number
}
const GetUserFromAPIRequest = Request.tagged<GetUserFromAPIRequest>(
  "GetUserFromAPIRequest"
)

// Create a resolver that uses effects (like HTTP calls)
const UserAPIResolver = RequestResolver.fromEffect<GetUserFromAPIRequest>(
  (entry) =>
    Effect.gen(function*() {
      // Simulate an API call
      yield* Effect.sleep("100 millis")
      // Just return the result without error handling for simplicity
      return `User ${entry.request.id} from API`
    })
)

// Usage
const getUserEffect = Effect.request(
  GetUserFromAPIRequest({ id: 123 }),
  UserAPIResolver
)

constructors

Source effect/RequestResolver.ts:42822 lines

export const fromEffect = <A extends Request.Any>(
  f: (entry: Request.Entry<A>) => Effect.Effect<Request.Success<A>, Request.Error<A>>
): RequestResolver<A> => {
  effect.interruptChildrenPatch() // ensure middleware is registered
  return make((entries) =>
    Effect.callback<void>((resume) => {
      const parent = effect.getCurrentFiber()!
      let done = 0
      for (let i = 0; i < entries.length; i++) {
        const entry = entries[i]
        const fiber = effect.forkUnsafe(parent as any, f(entry), true)
        fiber.addObserver((exit) => {
          entry.completeUnsafe(exit)
          done++
          if (done === entries.length) {
            resume(effect.void)
          }
        })
      }
    })
  )
}