Using bodyUnsafeJson | Effect Http Client

When making POST, PUT, or PATCH requests, you typically need to send data in the request body.

The simplest way to send a JSON body is HttpClientRequest.bodyJsonUnsafe().

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

8
function addProduct(product: {
9
  title: string;
10
  price: number;
11
  category: string;
12
}) {
13
  return Effect.gen(function* () {
14
    const client = yield* HttpClient.HttpClient;
15

16
    const request = HttpClientRequest.post(
17
      "https://dummyjson.com/products/add",
18
    ).pipe(HttpClientRequest.bodyJsonUnsafe(product));
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
  addProduct({
30
    title: "Ergonomic Keyboard",
31
    price: 149,
32
    category: "electronics",
33
  }),
34
).then((data) => {
35
  console.log("Created product:", data);
36
});

Output:

1
Created product: {
2
  id: 195,
3
  title: 'Ergonomic Keyboard',
4
  price: 149,
5
  category: 'electronics'
6
}

bodyJsonUnsafe calls JSON.stringify internally and sets the Content-Type header to application/json for you.

The word “unsafe” here doesn’t mean dangerous. It means the serialization step is not tracked in the type system. If JSON.stringify were to fail at runtime (e.g., due to circular references in the data), the error would be an untracked exception rather than a typed Effect error.

This is the most convenient option when when you know the data is a simple, serializable object, like a hardcoded payload or a plain record you just constructed yourself.

Stay in the loop