@effect/platform-bun 4.0.3 → 4.0.4

package/AGENTS.md

@@ -370,6 +370,30 @@ Build http clients with the `HttpClient` module.
   Test handlers through an in-memory typed client with `HttpApiTest`, without
   starting an HTTP server or touching a real database.
 
+## Typed GraphQL clients with `effect/graphql`
+
+Use the `effect/graphql` modules to call GraphQL APIs with typed
+operations. Run `graphqlgen` from `@effect/graphql-generator` to generate
+operations from `.graphql` documents, then build a client with
+`GraphQLClient.make` and provide a transport from `GraphQLProtocol`.
+
+- **[Getting started with GraphQL clients](./ai-docs/src/52_graphql/10_basics.ts)**:
+  Define a query, build a typed client service over HTTP with an auth
+  middleware, and page through a cursor connection.
+- **[Testing code that uses a GraphQL client](./ai-docs/src/52_graphql/20_testing.ts)**:
+  Replace a client service with `GraphQLClient.layerTest`, answering each
+  operation from a handler instead of a server.
+- **[Batching lookups with GraphQLResolver](./ai-docs/src/52_graphql/30_batching.ts)**:
+  Collect concurrent lookups by id into one `nodes(ids:)` request with
+  `GraphQLResolver`, instead of one request per id.
+- **[Batching single-item lookups with aliases](./ai-docs/src/52_graphql/40_aliased-batching.ts)**:
+  When an API has no field that takes a list of keys, `GraphQLResolver.aliased`
+  repeats a generated operation under aliases, so concurrent lookups share one
+  request and keep their generated types.
+- **[Handling GraphQL errors, retries and rate limits](./ai-docs/src/52_graphql/50_errors-and-retries.ts)**:
+  Read rate-limit headers in a middleware, tell GraphQL errors apart by their
+  fields, and retry timeouts and rate limits with `Effect.retry`.
+
 ## Working with child processes
 
 Use the `effect/process` modules to define child processes and run them with `ChildProcessSpawner`.

package/CLAUDE.md

@@ -370,6 +370,30 @@ Build http clients with the `HttpClient` module.
   Test handlers through an in-memory typed client with `HttpApiTest`, without
   starting an HTTP server or touching a real database.
 
+## Typed GraphQL clients with `effect/graphql`
+
+Use the `effect/graphql` modules to call GraphQL APIs with typed
+operations. Run `graphqlgen` from `@effect/graphql-generator` to generate
+operations from `.graphql` documents, then build a client with
+`GraphQLClient.make` and provide a transport from `GraphQLProtocol`.
+
+- **[Getting started with GraphQL clients](./ai-docs/src/52_graphql/10_basics.ts)**:
+  Define a query, build a typed client service over HTTP with an auth
+  middleware, and page through a cursor connection.
+- **[Testing code that uses a GraphQL client](./ai-docs/src/52_graphql/20_testing.ts)**:
+  Replace a client service with `GraphQLClient.layerTest`, answering each
+  operation from a handler instead of a server.
+- **[Batching lookups with GraphQLResolver](./ai-docs/src/52_graphql/30_batching.ts)**:
+  Collect concurrent lookups by id into one `nodes(ids:)` request with
+  `GraphQLResolver`, instead of one request per id.
+- **[Batching single-item lookups with aliases](./ai-docs/src/52_graphql/40_aliased-batching.ts)**:
+  When an API has no field that takes a list of keys, `GraphQLResolver.aliased`
+  repeats a generated operation under aliases, so concurrent lookups share one
+  request and keep their generated types.
+- **[Handling GraphQL errors, retries and rate limits](./ai-docs/src/52_graphql/50_errors-and-retries.ts)**:
+  Read rate-limit headers in a middleware, tell GraphQL errors apart by their
+  fields, and retry timeouts and rate limits with `Effect.retry`.
+
 ## Working with child processes
 
 Use the `effect/process` modules to define child processes and run them with `ChildProcessSpawner`.

package/ai-docs/package.json

@@ -27,8 +27,8 @@
     "@effect/sql-sqlite-wasm": "workspace:*",
     "@effect/vitest": "workspace:*",
     "effect": "workspace:*",
-    "hono": "^4.13.12",
-    "nodemailer": "^10.0.14"
+    "hono": "^4.13.13",
+    "nodemailer": "^10.1.0"
   },
   "devDependencies": {
     "@types/nodemailer": "^8.0.2"

package/ai-docs/src/52_graphql/10_basics.ts

@@ -0,0 +1,111 @@
+/**
+ * @title Getting started with GraphQL clients
+ *
+ * Define a query, build a typed client service over HTTP with an auth
+ * middleware, and page through a cursor connection.
+ */
+import { Config, Context, Effect, Layer, Redacted, Schema, Stream } from "effect"
+import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLMiddleware, GraphQLProtocol } from "effect/graphql"
+import { FetchHttpClient } from "effect/http"
+
+// Operations are usually generated: write them in `.graphql` files and run
+// `graphqlgen` from `@effect/graphql-generator`, which writes a `.graphql.ts`
+// module like the one below next to each document.
+//
+//   query RepoIssues($owner: String!, $name: String!, $after: String) {
+//     repository(owner: $owner, name: $name) {
+//       issues(first: 50, after: $after) {
+//         pageInfo { hasNextPage endCursor }
+//         nodes { number title }
+//       }
+//     }
+//   }
+//
+// Each nested selection is its own class, so editor hovers show its name.
+export class PageInfo extends Schema.Opaque<PageInfo>()(
+  Schema.Struct({ hasNextPage: Schema.Boolean, endCursor: Schema.NullOr(Schema.String) })
+) {}
+
+export class Issue extends Schema.Opaque<Issue>()(
+  Schema.Struct({ number: Schema.Int, title: Schema.String })
+) {}
+
+export class IssueConnection extends Schema.Opaque<IssueConnection>()(
+  Schema.Struct({ pageInfo: PageInfo, nodes: Schema.NullOr(Schema.Array(Schema.NullOr(Issue))) })
+) {}
+
+export class Repository extends Schema.Opaque<Repository>()(
+  Schema.Struct({ issues: IssueConnection })
+) {}
+
+export const RepoIssues = GraphQL.query("RepoIssues", {
+  document:
+    "query RepoIssues($owner:String!,$name:String!,$after:String){repository(owner:$owner,name:$name){issues(first:50,after:$after){pageInfo{hasNextPage endCursor}nodes{number title}}}}",
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    after: Schema.optional(Schema.NullOr(Schema.String))
+  },
+  result: Schema.Struct({
+    repository: Schema.NullOr(Repository)
+  })
+})
+
+// A middleware is a service that wraps every operation it is attached to.
+// `mapRequest` builds one from a single request transform.
+export class GitHubAuth extends GraphQLMiddleware.Service<GitHubAuth>()("app/GitHubAuth") {
+  static readonly layer = Layer.effect(
+    GitHubAuth,
+    Effect.gen(function*() {
+      const token = yield* Config.Redacted("GITHUB_TOKEN")
+      return GraphQLMiddleware.mapRequest((request) =>
+        Effect.succeed({
+          ...request,
+          headers: { ...request.headers, authorization: `Bearer ${Redacted.value(token)}` }
+        })
+      )
+    })
+  )
+}
+
+// A group is the set of operations a client exposes; the generator emits one
+// per file. Attaching the middleware makes `GraphQLClient.make` require it.
+export const GitHubGraphQLGroup = GraphQLGroup.make(RepoIssues).middleware(GitHubAuth)
+
+// The client has one method per operation, named after it.
+export class GitHub extends Context.Service<
+  GitHub,
+  GraphQLClient.FromGroup<typeof GitHubGraphQLGroup>
+>()("app/GitHub") {
+  static readonly layerTest = GraphQLClient.layerTest(GitHub, GitHubGraphQLGroup)
+
+  static readonly layer = Layer.effect(GitHub, GraphQLClient.make(GitHubGraphQLGroup)).pipe(
+    Layer.provide(GitHubAuth.layer),
+    // Queries and mutations are sent as `POST`. Subscriptions use graphql-sse
+    // here, or graphql-ws with `GraphQLProtocol.layerWebSocket`.
+    Layer.provide(GraphQLProtocol.layerHttp({ url: "https://api.github.com/graphql" })),
+    Layer.provide(FetchHttpClient.layer)
+  )
+}
+
+export const program = Effect.gen(function*() {
+  const github = yield* GitHub
+
+  // Variables are encoded and the result decoded through the Schemas. Any
+  // `errors` in the response fail with a `GraphQLClientError`; pass
+  // `{ partial: true }` as the second argument to get them with the data.
+  const { repository } = yield* github.RepoIssues({ owner: "Effect-TS", name: "effect" })
+  yield* Effect.log(`First page has ${repository?.issues.nodes?.length ?? 0} issues`)
+
+  // `items` pages through the connection by driving `$after`, one request at
+  // a time and only as the stream is pulled.
+  const titles = yield* GraphQLClient.items(github.RepoIssues, {
+    variables: { owner: "Effect-TS", name: "effect" },
+    connection: (result) => result.repository?.issues
+  }).pipe(
+    Stream.take(120),
+    Stream.map((issue) => issue?.title),
+    Stream.runCollect
+  )
+  yield* Effect.log(`Fetched ${titles.length} issues`)
+}).pipe(Effect.provide(GitHub.layer))

package/ai-docs/src/52_graphql/20_testing.ts

@@ -0,0 +1,45 @@
+/**
+ * @title Testing code that uses a GraphQL client
+ *
+ * Replace a client service with `GraphQLClient.layerTest`, answering each
+ * operation from a handler instead of a server.
+ */
+import { assert, describe, it } from "@effect/vitest"
+import { Effect } from "effect"
+import { GitHub } from "./10_basics.ts"
+
+// Code under test that depends on the `GitHub` client service.
+const issueTitles = (owner: string, name: string) =>
+  GitHub.use((github) => github.RepoIssues({ owner, name })).pipe(
+    Effect.map(({ repository }) => repository?.issues.nodes?.map((issue) => issue?.title) ?? [])
+  )
+
+// The service binds `GraphQLClient.layerTest(GitHub, GitHubGraphQLGroup)` once
+// as a static helper. Handlers are keyed by operation name, receive the
+// caller's variables and options, and return results in their decoded form.
+// Nothing is encoded or decoded and no middleware runs. An operation without
+// a handler dies with an `UnimplementedError` defect.
+const GitHubTest = GitHub.layerTest({
+  RepoIssues: ({ owner, name }) =>
+    Effect.succeed({
+      repository: {
+        issues: {
+          pageInfo: { hasNextPage: false, endCursor: null },
+          nodes: [{ number: 1, title: `Hello from ${owner}/${name}` }]
+        }
+      }
+    })
+})
+
+describe("issueTitles", () => {
+  it.effect("returns the titles of the first page", () =>
+    Effect.gen(function*() {
+      const titles = yield* issueTitles("Effect-TS", "effect")
+      assert.deepStrictEqual(titles, ["Hello from Effect-TS/effect"])
+    }).pipe(Effect.provide(GitHubTest)))
+})
+
+// `layerTest` uses `makeTest`, which skips the protocol and cannot return
+// partial data together with `errors`. To test that, or the encode and decode
+// path, build the real client with `GraphQLClient.make` over a scripted
+// `GraphQLProtocol` layer (see `GraphQLProtocol`).

package/ai-docs/src/52_graphql/30_batching.ts

@@ -0,0 +1,116 @@
+/**
+ * @title Batching lookups with GraphQLResolver
+ *
+ * Collect concurrent lookups by id into one `nodes(ids:)` request with
+ * `GraphQLResolver`, instead of one request per id.
+ */
+import { type Cause, Context, Effect, Layer, RequestResolver, Schema } from "effect"
+import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol, GraphQLResolver } from "effect/graphql"
+import { FetchHttpClient } from "effect/http"
+import { GitHubAuth } from "./10_basics.ts"
+
+// The generator's output for `repo-nodes.graphql`:
+//
+//   query RepoNodes($ids: [ID!]!) {
+//     nodes(ids: $ids) { __typename ... on Repository { nameWithOwner } }
+//   }
+//
+// Generated modules import shared codecs and the possible `__typename`s of
+// each interface from the module the generator writes next to the schema
+// (`import * as Shared from "../schema.graphql.ts"`); here `Shared` is
+// declared inline.
+const Shared = { ID: Schema.String }
+declare namespace Shared {
+  export namespace Typename {
+    export type Node = "Issue" | "PullRequest" | "Repository" | "User"
+  }
+}
+
+export class Repository extends Schema.Opaque<Repository>()(Schema.Struct({
+  __typename: Schema.Literal("Repository"),
+  nameWithOwner: Schema.String
+})) {}
+
+// Unselected node types are represented by `otherTypename`.
+export class NodeOther extends Schema.Opaque<NodeOther>()(Schema.Struct({
+  __typename: GraphQL.otherTypename<Shared.Typename.Node>()(["Repository"])
+})) {}
+
+/** `query RepoNodes` */
+export const RepoNodes = GraphQL.query("RepoNodes", {
+  document: {
+    variables: [
+      { name: "ids", body: "[ID!]!" }
+    ],
+    selections: [
+      { name: "nodes", body: ["(ids:$", "ids", "){__typename...on Repository{nameWithOwner}}"] }
+    ],
+    fragments: []
+  },
+  variables: {
+    ids: Schema.Array(Shared.ID)
+  },
+  result: Schema.Struct({
+    nodes: Schema.Array(Schema.NullOr(Schema.Union([
+      Repository,
+      NodeOther
+    ])))
+  })
+})
+export declare namespace RepoNodes {
+  export type Variables = typeof RepoNodes.variables.Type
+  export type Result = typeof RepoNodes.result.Type
+}
+
+/** Every operation in repo-nodes.graphql. */
+export const RepoNodesGraphQLGroup = GraphQLGroup.make(RepoNodes)
+
+// Your code: attach the middleware to the generated group.
+export const GitHubGraphQLGroup = RepoNodesGraphQLGroup.middleware(GitHubAuth)
+
+export class GitHub extends Context.Service<
+  GitHub,
+  GraphQLClient.FromGroup<typeof GitHubGraphQLGroup> & {
+    getRepo(id: string): Effect.Effect<
+      Repository,
+      GraphQL.Error<typeof RepoNodes> | Cause.NoSuchElementError
+    >
+  }
+>()("app/GitHub") {
+  static readonly layer = Layer.effect(
+    GitHub,
+    Effect.gen(function*() {
+      const client = yield* GraphQLClient.make(GitHubGraphQLGroup)
+
+      // Null entries and non-Repository nodes fail with NoSuchElementError.
+      // GitHub accepts at most 100 ids per request.
+      //
+      // GitHubAuth reads one token from config, so every lookup can share a
+      // batch. If a middleware `requires` a per-request service, such as the
+      // signed-in user, `batchKey` is required and keeps lookups for different
+      // users in separate calls:
+      //
+      //   batchKey: (context) => Context.get(context, CurrentUser).id
+      const RepoById = GraphQLResolver.ordered(client.RepoNodes, {
+        variables: (ids: ReadonlyArray<string>) => ({ ids }),
+        path: ["nodes"],
+        typename: "Repository"
+      }).pipe(RequestResolver.batchN(100))
+      return { ...client, getRepo: GraphQLResolver.request(RepoById) }
+    })
+  ).pipe(
+    Layer.provide(GitHubAuth.layer),
+    Layer.provide(GraphQLProtocol.layerHttp({ url: "https://api.github.com/graphql" })),
+    Layer.provide(FetchHttpClient.layer)
+  )
+}
+
+export const repoNames = Effect.fn("repoNames")(function*(ids: ReadonlyArray<string>) {
+  const github = yield* GitHub
+  const repos = yield* Effect.forEach(ids, github.getRepo, { concurrency: "unbounded" })
+  return repos.map((repo) => repo.nameWithOwner)
+})
+
+export const program = repoNames(["R_1", "R_2"]).pipe(
+  Effect.provide(GitHub.layer)
+)

package/ai-docs/src/52_graphql/40_aliased-batching.ts

@@ -0,0 +1,122 @@
+/**
+ * @title Batching single-item lookups with aliases
+ *
+ * When an API has no field that takes a list of keys, `GraphQLResolver.aliased`
+ * repeats a generated operation under aliases, so concurrent lookups share one
+ * request and keep their generated types.
+ */
+import { Context, Effect, Layer, Schema } from "effect"
+import { GraphQL, GraphQLClient, GraphQLGroup, GraphQLProtocol, GraphQLResolver } from "effect/graphql"
+import { FetchHttpClient } from "effect/http"
+import { GitHubAuth } from "./10_basics.ts"
+
+// The generator's output for `pr.graphql`:
+//
+//   query PullRequest($owner: String!, $name: String!, $number: Int!) {
+//     repository(owner: $owner, name: $name) {
+//       pullRequest(number: $number) { number title }
+//     }
+//   }
+//
+// Generated modules import shared codecs, such as `Int`, from the module the
+// generator writes next to the schema (`import * as Shared from
+// "../schema.graphql.ts"`); here `Shared` is declared inline.
+const Shared = { Int: Schema.Number.check(Schema.isInt32()) }
+
+export class PullRequestPullRequest extends Schema.Opaque<PullRequestPullRequest>()(Schema.Struct({
+  number: Shared.Int,
+  title: Schema.String
+})) {}
+
+export class Repository extends Schema.Opaque<Repository>()(Schema.Struct({
+  pullRequest: Schema.NullOr(PullRequestPullRequest)
+})) {}
+
+// The generator gives queries and mutations their document as a
+// `GraphQL.DocumentTemplate`. The odd entries of each `body` are the names
+// `aliased` renames per slice; joined together they are the printed document.
+/** `query PullRequest` */
+export const PullRequest = GraphQL.query("PullRequest", {
+  document: {
+    variables: [
+      { name: "owner", body: "String!" },
+      { name: "name", body: "String!" },
+      { name: "number", body: "Int!" }
+    ],
+    selections: [
+      {
+        name: "repository",
+        body: ["(owner:$", "owner", " name:$", "name", "){pullRequest(number:$", "number", "){number title}}"]
+      }
+    ],
+    fragments: []
+  },
+  variables: {
+    owner: Schema.String,
+    name: Schema.String,
+    number: Shared.Int
+  },
+  result: Schema.Struct({
+    repository: Schema.NullOr(Repository)
+  })
+})
+export declare namespace PullRequest {
+  export type Variables = typeof PullRequest.variables.Type
+  export type Result = typeof PullRequest.result.Type
+}
+
+/** Every operation in pr.graphql. */
+export const PrGraphQLGroup = GraphQLGroup.make(PullRequest)
+
+// Your code: attach the middleware to the generated group.
+export const GitHubGraphQLGroup = PrGraphQLGroup.middleware(GitHubAuth)
+
+export class GitHub extends Context.Service<
+  GitHub,
+  GraphQLClient.FromGroup<typeof GitHubGraphQLGroup> & {
+    readonly getPullRequest: (
+      variables: GraphQL.Variables<typeof PullRequest>
+    ) => Effect.Effect<GraphQL.Result<typeof PullRequest>, GraphQL.Error<typeof PullRequest>>
+  }
+>()("app/GitHub") {
+  static readonly layer = Layer.effect(
+    GitHub,
+    Effect.gen(function*() {
+      const client = yield* GraphQLClient.make(GitHubGraphQLGroup)
+
+      // Concurrent calls go out as one POST whose root fields are aliased
+      // `_0_repository`, `_1_repository`, and so on. Each slice is decoded
+      // with the generated result Schema, and a GraphQL error under
+      // `_1_repository` fails only that call.
+      //
+      // A batch holds 10 slices by default, because GitHub's query cost and
+      // timeouts grow with the size of the query. Pipe
+      // `RequestResolver.batchN` to change it.
+      const PullRequests = GraphQLResolver.aliased(client.PullRequest)
+
+      // `request` turns the resolver into a lookup by the operation's
+      // variables, as for `ordered` and `findById`.
+      return { ...client, getPullRequest: GraphQLResolver.request(PullRequests) }
+    })
+  ).pipe(
+    Layer.provide(GitHubAuth.layer),
+    Layer.provide(GraphQLProtocol.layerHttp({ url: "https://api.github.com/graphql" })),
+    Layer.provide(FetchHttpClient.layer)
+  )
+}
+
+export const pullRequestTitles = Effect.fn("pullRequestTitles")(function*(numbers: ReadonlyArray<number>) {
+  const github = yield* GitHub
+  const results = yield* Effect.forEach(
+    numbers,
+    (number) => github.getPullRequest({ owner: "Effect-TS", name: "effect", number }),
+    { concurrency: "unbounded" }
+  )
+  // `repository` and `pullRequest` are nullable, so a missing pull request is
+  // `null` rather than an error that would fail every slice.
+  return results.map((result) => result.repository?.pullRequest?.title ?? null)
+})
+
+export const program = pullRequestTitles([1, 2, 3]).pipe(
+  Effect.provide(GitHub.layer)
+)

package/ai-docs/src/52_graphql/50_errors-and-retries.ts

@@ -0,0 +1,74 @@
+/**
+ * @title Handling GraphQL errors, retries and rate limits
+ *
+ * Read rate-limit headers in a middleware, tell GraphQL errors apart by their
+ * fields, and retry timeouts and rate limits with `Effect.retry`.
+ */
+import { Duration, Effect, Layer, Schedule } from "effect"
+import { type GraphQLClientError, GraphQLMiddleware } from "effect/graphql"
+import { GitHub } from "./10_basics.ts"
+
+// Middleware see each response's HTTP `status` and `headers` on the result
+// `next` returns, including responses with GraphQL `errors`. A failed call
+// keeps them, and `GraphQLClientError` exposes them as `headers` and
+// `status`. Attach it with `GraphQLGroup.make(...).middleware(RateLimit)`.
+export class RateLimit extends GraphQLMiddleware.Service<RateLimit>()("app/RateLimit") {
+  static readonly layer = Layer.succeed(RateLimit, {
+    execute: ({ next, request }) =>
+      Effect.tap(next(request), (result) => {
+        const remaining = Number(result.headers?.["x-ratelimit-remaining"])
+        return remaining < 500
+          ? Effect.logWarning(`GitHub rate limit: ${remaining} points left`)
+          : Effect.void
+      }),
+    subscribe: ({ next, request }) => next(request)
+  })
+}
+
+// GraphQL errors keep fields the specification doesn't define as JSON, such
+// as GitHub's top-level `type` (`NOT_FOUND`, `FORBIDDEN`, `RATE_LIMITED`).
+export const hasErrorType = (error: GraphQLClientError.GraphQLClientError, type: string) =>
+  error.reason._tag === "ResponseError" && error.reason.errors.every((entry) => entry.type === type)
+
+// `isRetryable` is true for network failures, for 429 or 5xx responses, and
+// for any error with a `Retry-After` header, whatever its status. That covers
+// GitHub's 502 and 504 query timeouts, even with a GraphQL `errors` body, and
+// its secondary rate limits (403 or 429 with `retry-after`). A primary rate
+// limit can come without `retry-after`, with `x-ratelimit-remaining: 0`, so
+// check that header too.
+const rateLimited = (error: GraphQLClientError.GraphQLClientError) => error.headers?.["x-ratelimit-remaining"] === "0"
+
+// Wait for `retryAfter` when it is set, and until `x-ratelimit-reset` (epoch
+// seconds) on a primary rate limit. GitHub may ban an integration that keeps
+// retrying while rate limited, so don't retry with a plain backoff.
+const gitHubRetry = Schedule.exponential("1 second").pipe(
+  Schedule.setInputType<GraphQLClientError.GraphQLClientError>(),
+  Schedule.modifyDelay(({ duration, input, now }) => {
+    if (input.retryAfter !== undefined) return Effect.succeed(input.retryAfter)
+    if (!rateLimited(input)) return Effect.succeed(duration)
+    const reset = Number(input.headers?.["x-ratelimit-reset"]) * 1000
+    return Effect.succeed(Number.isFinite(reset) ? Duration.millis(Math.max(0, reset - now)) : Duration.minutes(1))
+  })
+)
+
+// The client never retries queries or mutations on its own. Retry only
+// mutations that are safe to send twice, and with `GraphQLClient.pages`,
+// retry inside a middleware, because `Stream.retry` starts again from the
+// first page. Subscriptions reconnect on their own after a retryable failure,
+// on `GraphQLClient.defaultSubscriptionRetry`, which waits for `retryAfter`.
+// A primary rate limit without `retry-after` isn't retryable, so it ends the
+// subscription; wait until `x-ratelimit-reset` before subscribing again.
+export const retryGitHub = <A, R>(effect: Effect.Effect<A, GraphQLClientError.GraphQLClientError, R>) =>
+  Effect.retry(effect, {
+    schedule: gitHubRetry,
+    while: (error) => error.isRetryable || rateLimited(error),
+    times: 5
+  })
+
+export const program = Effect.gen(function*() {
+  const github = yield* GitHub
+  const result = yield* retryGitHub(github.RepoIssues({ owner: "Effect-TS", name: "missing" })).pipe(
+    Effect.catchIf((error) => hasErrorType(error, "NOT_FOUND"), () => Effect.succeed(null))
+  )
+  yield* Effect.log(result === null ? "No such repository" : `${result.repository?.issues.nodes?.length} issues`)
+}).pipe(Effect.provide(GitHub.layer))

package/ai-docs/src/52_graphql/index.md

@@ -0,0 +1,6 @@
+## Typed GraphQL clients with `effect/graphql`
+
+Use the `effect/graphql` modules to call GraphQL APIs with typed
+operations. Run `graphqlgen` from `@effect/graphql-generator` to generate
+operations from `.graphql` documents, then build a client with
+`GraphQLClient.make` and provide a transport from `GraphQLProtocol`.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@effect/platform-bun",
   "type": "module",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "license": "MIT",
   "description": "Platform specific implementations for the Bun runtime",
   "homepage": "https://effect.website",
@@ -49,15 +49,15 @@
     "provenance": true
   },
   "peerDependencies": {
-    "effect": "^4.0.3"
+    "effect": "^4.0.4"
   },
   "dependencies": {
-    "@effect/platform-node-shared": "^4.0.3"
+    "@effect/platform-node-shared": "^4.0.4"
   },
   "devDependencies": {
     "@types/bun": "^1.4.2",
-    "tinybench": "^6.2.0",
-    "effect": "^4.0.3"
+    "tinybench": "^6.2.1",
+    "effect": "^4.0.4"
   },
   "scripts": {
     "codegen": "effect-utils codegen",