Using the Options Object | Effect Http Client

You can also pass parameters to a request directly when creating the request, using the Options object:

1
import {
2
  FetchHttpClient,
3
  HttpClient,
4
  HttpClientRequest,
5
} from "effect/unstable/http";
6
import { Effect } from "effect";
7

8
function fetchUsersPaginated(options: { limit: number; sortBy: string }) {
9
  return Effect.gen(function* () {
10
    const client = yield* HttpClient.HttpClient;
11

12
    // Pass urlParams directly in the options object
13
    const request = HttpClientRequest.get("https://dummyjson.com/users", {
14
      urlParams: {
15
        limit: options.limit.toString(),
16
        sortBy: options.sortBy,
17
      },
18
    });
19

20
    const response = yield* client.execute(request);
21
    const data = yield* response.json;
22

23
    return data;
24
  }).pipe(Effect.provide(FetchHttpClient.layer));
25
}
26

27
// Test it
28
Effect.runPromise(
29
  fetchUsersPaginated({
30
    limit: 5,
31
    sortBy: "firstName",
32
  }),
33
).then((data) => {
34
  data.users.map((user: any) => {
35
    console.log(`  ${user.firstName} ${user.lastName}`);
36
  });
37
});

Output:

1
Aaliyah Hanson
2
Aaliyah Martinez
3
Aaron Cook
4
Abigail Rivera
5
Addison Wright

The Options object isn’t limited to urlParams. You can set headers, accept types, and more, all in one place:

1
const request = HttpClientRequest.get("https://dummyjson.com/users", {
2
  urlParams: {
3
    limit: "5",
4
    sortBy: "firstName",
5
  },
6
  headers: {
7
    "X-Request-Source": "effect-course",
8
  },
9
  acceptJson: true,
10
});

This is equivalent to chaining setUrlParams, setHeaders, and acceptJson through .pipe(). The result is the same, use whichever style you prefer.

Here’s the full list of properties you can pass in the options object:

Property	Type	Description
`urlParams`	`UrlParams.Input`	Query string parameters to append to the URL endpoint.
`headers`	`Headers.Input`	Custom HTTP headers to include in the request.
`body`	`HttpBody.HttpBody`	The payload of the request (e.g., JSON, FormData, Stream).
`accept`	`string`	Explicitly sets the `Accept` header to a specific media type.
`acceptJson`	`boolean`	A convenient shorthand to automatically set the `Accept` header to `application/json`.
`hash`	`string`	The URL fragment identifier (the part of the URL after the `#`).
`url`	`string \| URL`	The endpoint URL.
`method`	`HttpMethod`	The specific HTTP method (e.g., `"GET"`, `"POST"`).

Note that while the base Options object contains all the properties above, Effect TS uses TypeScript utility types to restrict certain fields depending on how the request is constructed.

Options.NoBody: When using HttpClientRequest.get() or HttpClientRequest.head(), the options object omits method, url, and body. You cannot pass a body to a GET request this way.
Options.NoUrl: When using HttpClientRequest.post(), HttpClientRequest.put(), HttpClientRequest.patch(), or HttpClientRequest.del(), the options object omits method and url (because they are already defined by the constructor and the first argument), but it does allow body.

These same option variants apply to the client’s shorthand methods as well:

1
const client = yield* HttpClient.HttpClient;
2

3
// Options passed directly to client.get
4
const response =
5
  yield*
6
  client.get("https://dummyjson.com/users", {
7
    urlParams: { limit: "3" },
8
    acceptJson: true,
9
  });

The .pipe() pattern and the options object are interchangeable. The .pipe() approach is better when you’re building requests incrementally or conditionally. The options object is better when you know everything upfront and want it in one place.

Stay in the loop