@effect/platform-cloudflare 0.0.0 → 4.1.3

package/ai-docs/src/51_http-server/fixtures/api/Api.ts

@@ -0,0 +1,14 @@
+import { HttpApi, OpenApi } from "effect/http-api"
+import { SystemApi } from "./System.ts"
+import { UsersApiGroup } from "./Users.ts"
+
+// Defined the root API, which combines all of the groups together. This is the
+// API that you will serve and generate clients for. You can also annotate the
+// API with OpenAPI metadata.
+export class Api extends HttpApi.make("user-api")
+  .add(UsersApiGroup)
+  .add(SystemApi)
+  .annotateMerge(OpenApi.annotations({
+    title: "Acme User API"
+  }))
+{}

package/ai-docs/src/51_http-server/fixtures/api/Authorization.ts

@@ -0,0 +1,36 @@
+import { Context, Schema } from "effect"
+import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api"
+import type { User } from "../domain/User.ts"
+
+export class CurrentUser extends Context.Service<CurrentUser, User>()("acme/HttpApi/Authorization/CurrentUser") {}
+
+export class Unauthorized extends Schema.TaggedError<Unauthorized>()(
+  "Unauthorized",
+  {
+    message: Schema.String
+  },
+  // You can define error status codes directly on the error class
+  { httpApiStatus: 401 }
+) {}
+
+export class Authorization extends HttpApiMiddleware.Service<Authorization, {
+  // Middleware can provide services to other middleware and endpoints, which is
+  // useful for things like authentication, where you want to inject the current
+  // user into the context for other endpoints to consume.
+  provides: CurrentUser
+  // If your middleware requires dependencies from other middleware, you can
+  // specify those as well.
+  requires: never
+}>()("acme/HttpApi/Authorization", {
+  // This middleware requires clients to also provide an implementation, to
+  // inject a api key
+  requiredForClient: true,
+  // Middleware can optionally define security schemes, which are used to
+  // generate OpenAPI docs and decode credientials from incoming requests for
+  // you.
+  security: {
+    bearer: HttpApiSecurity.bearer
+  },
+  // Middlware can specify errors that it may raise
+  error: Unauthorized
+}) {}

package/ai-docs/src/51_http-server/fixtures/api/System.ts

@@ -0,0 +1,10 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api"
+
+// Top level groups are added to the root of the derived HttpApiClient.
+//
+// `client.health()`
+export class SystemApi extends HttpApiGroup.make("system", { topLevel: true }).add(
+  HttpApiEndpoint.get("health", "/health", {
+    success: HttpApiSchema.NoContent
+  })
+) {}

package/ai-docs/src/51_http-server/fixtures/api/Users.ts

@@ -0,0 +1,107 @@
+import { Schema } from "effect"
+import { HttpApiEndpoint, HttpApiError, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api"
+import { User, UserId } from "../domain/User.ts"
+import { SearchQueryTooShort, UserNotFound } from "../domain/UserErrors.ts"
+import { Authorization } from "./Authorization.ts"
+
+export class UsersApiGroup extends HttpApiGroup.make("users")
+  .add(
+    HttpApiEndpoint.get("list", "/", {
+      query: {
+        search: Schema.optional(Schema.String)
+      },
+      // Use the `json` variant of the model for API responses. It shares the
+      // field declarations with the database variants, but can encode values
+      // differently where needed.
+      success: Schema.Array(User.json)
+    }),
+    HttpApiEndpoint.get("search", "/search", {
+      // For get requests, payload uses the query string
+      payload: {
+        search: Schema.String
+      },
+      success: [
+        Schema.Array(User.json),
+        Schema.String.pipe(HttpApiSchema.asText({
+          contentType: "text/csv"
+        }))
+      ],
+      error: [
+        SearchQueryTooShort.pipe(
+          // If you want an error to return no content, you can use
+          // `HttpApiSchema.asNoContent` and provide a decoder that transforms the
+          // error into the appropriate type.
+          HttpApiSchema.asNoContent({
+            decode: () => new SearchQueryTooShort()
+          })
+        ),
+        // You can also add some of the built in `HttpApiError`s to handle common
+        // error cases like bad requests, unauthorized, etc.
+        HttpApiError.RequestTimeoutNoContent
+      ]
+    }),
+    HttpApiEndpoint.get("getById", "/:id", {
+      params: {
+        // Path parameter values are automatically coerced from their string
+        // form using `Schema.toCodecStringTree`, so schemas that decode from
+        // other types (like numbers) work here as well.
+        id: UserId
+      },
+      success: User.json,
+      error: UserNotFound.pipe(
+        // If you want an error to return no content, you can use
+        // `HttpApiSchema.asNoContent` and provide a decoder that transforms the
+        // error into the appropriate type.
+        HttpApiSchema.asNoContent({
+          decode: () => new UserNotFound()
+        })
+      )
+    }),
+    HttpApiEndpoint.post("create", "/", {
+      // For post requests, payload uses the request body. It defaults to JSON,
+      // but you can specify other content types as well using
+      // `HttpApiSchema.asText`, `HttpApiSchema.asMultipart`, etc.
+      //
+      // The `jsonCreate` variant only exposes the fields clients are allowed
+      // to provide, so the generated id and timestamps cannot be set here.
+      payload: User.jsonCreate,
+      success: User.json
+    }),
+    HttpApiEndpoint.patch("update", "/:id", {
+      params: {
+        id: UserId
+      },
+      // The `jsonUpdate` variant similarly excludes the id and the managed
+      // timestamps from the update payload.
+      payload: User.jsonUpdate,
+      success: User.json,
+      error: UserNotFound.pipe(
+        HttpApiSchema.asNoContent({
+          decode: () => new UserNotFound()
+        })
+      )
+    }),
+    HttpApiEndpoint.get("me", "/me", {
+      success: User.json,
+      error: UserNotFound.pipe(HttpApiSchema.status(404))
+    })
+  )
+  // You can apply middleware to entire groups, which is useful for things like
+  // authentication and authorization.
+  //
+  // You can also apply middleware to individual endpoints if you need more
+  // fine-grained control.
+  .middleware(Authorization)
+  // To add a common prefix to all endpoints in a group, you can use the `prefix`
+  // method. This is useful for grouping related endpoints together under a common
+  // path segment. In this case, all endpoints in the `UsersApiGroup` will be
+  // prefixed with `/users`.
+  .prefix("/users")
+  // You can add OpenAPI annotations to groups, endpoints, and even parameters and
+  // request bodies. These will be merged together to generate the final OpenAPI
+  // docs for the API
+  .annotateMerge(OpenApi.annotations({
+    title: "Users",
+    description: "User management endpoints"
+  }))
+{}

package/ai-docs/src/51_http-server/fixtures/domain/User.ts

@@ -0,0 +1,21 @@
+import { Schema } from "effect"
+import { Model } from "effect/schema"
+
+export const UserId = Schema.String.pipe(Schema.brand("UserId"))
+export type UserId = typeof UserId.Type
+
+// `Model.Class` derives variants for the database (`User`, `User.insert`,
+// `User.update`) and the JSON API (`User.json`, `User.jsonCreate`,
+// `User.jsonUpdate`) from a single field declaration.
+export class User extends Model.Class<User>("User")({
+  // A UUID v4 primary key generated by the application on insert. It is
+  // excluded from the `jsonCreate` / `jsonUpdate` variants, so API clients can
+  // never set it.
+  id: Model.UuidV4Insert(UserId),
+  name: Schema.String,
+  email: Schema.String,
+  // Timestamps are managed by the model: set on insert, refreshed on update,
+  // and also excluded from the JSON create / update variants.
+  createdAt: Model.DateTimeInsert,
+  updatedAt: Model.DateTimeUpdate
+}) {}

package/ai-docs/src/51_http-server/fixtures/domain/UserErrors.ts

@@ -0,0 +1,22 @@
+import { Schema } from "effect"
+
+export class UserNotFound extends Schema.TaggedError<UserNotFound>()(
+  "UserNotFound",
+  {},
+  // You can specify the status code for this error inline
+  { httpApiStatus: 404 }
+) {}
+
+export class SearchQueryTooShort
+  extends Schema.TaggedError<SearchQueryTooShort>()("SearchQueryTooShort", {}, { httpApiStatus: 422 })
+{
+  static readonly minimumLength = 2
+}
+
+// Create a wrapper error class for all errors in the Users API.
+//
+// This prevents adding too many error types to services / endpoint definitions.
+//
+export class UsersError extends Schema.TaggedError<UsersError>()("UsersError", {
+  reason: Schema.Union([UserNotFound, SearchQueryTooShort])
+}) {}

package/ai-docs/src/51_http-server/fixtures/server/Authorization.ts

@@ -0,0 +1,37 @@
+import { DateTime, Effect, Layer, Redacted } from "effect"
+import { Authorization, CurrentUser, Unauthorized } from "../api/Authorization.ts"
+import { User, UserId } from "../domain/User.ts"
+
+const fixedTimestamp = DateTime.makeUnsafe("2026-01-01T00:00:00Z")
+const devUser = new User({
+  id: UserId.make("bf3dbe33-0ad2-4c9c-9c9e-733e57bdcbee"),
+  name: "Dev User",
+  email: "dev@acme.com",
+  createdAt: fixedTimestamp,
+  updatedAt: fixedTimestamp
+})
+
+// The implementation of the Authorization middleware. It is seperate from the
+// service definition to avoid leaking it into a client.
+export const AuthorizationLayer = Layer.effect(
+  Authorization,
+  Effect.gen(function*() {
+    // Here you could access services required by the middleware, like a
+    // database or an external auth provider.
+    yield* Effect.logInfo("Starting Authorization middleware")
+
+    return Authorization.of({
+      bearer: Effect.fn(function*(httpEffect, { credential }) {
+        // Validate the token and return an Unauthorized error if it's invalid.
+        const token = Redacted.value(credential)
+        if (token !== "dev-token") {
+          return yield* new Unauthorized({ message: "Missing or invalid bearer token" })
+        }
+
+        // Provide the current user to the rest of the stack. This will be
+        // available in any endpoint or middleware that runs after this one.
+        return yield* Effect.provideService(httpEffect, CurrentUser, devUser)
+      })
+    })
+  })
+)

package/ai-docs/src/51_http-server/fixtures/server/Users/http.ts

@@ -0,0 +1,80 @@
+import { Effect, Layer } from "effect"
+import { HttpApiBuilder, HttpApiError } from "effect/http-api"
+import { Api } from "../../api/Api.ts"
+import { CurrentUser } from "../../api/Authorization.ts"
+import { AuthorizationLayer } from "../Authorization.ts"
+import { Users } from "../Users.ts"
+
+// The handlers without their dependencies provided, so tests can supply an
+// alternative `Users` implementation.
+export const UsersApiHandlersNoDeps = HttpApiBuilder.group(
+  Api,
+  "users",
+  Effect.fn(function*(handlers) {
+    const users = yield* Users
+
+    return handlers.handleAll({
+      list: ({ query }) =>
+        users.list(query.search).pipe(
+          // The list endpoint expects no errors, so we convert any potential
+          // errors into a 500 Internal Server Error.
+          Effect.orDie
+        ),
+      search: Effect.fn(function*({ payload }) {
+        if (payload.search === "bad-request") {
+          // You can use the built in error types like any other
+          // Schema.TaggedError
+          return yield* new HttpApiError.RequestTimeout()
+        }
+        return yield* users.list(payload.search).pipe(
+          Effect.catchReason(
+            "UsersError",
+            "SearchQueryTooShort",
+            // Re-fail the "SearchQueryTooShort" reason
+            Effect.fail,
+            // All other reasons are unexpected, so we convert them into a 500
+            // Internal Server Error.
+            Effect.die
+          )
+        )
+      }),
+      getById: ({ params }) =>
+        users.getById(params.id).pipe(
+          // You can also use Effect.catchReasons to handle multiple error
+          // reasons at once
+          Effect.catchReasons("UsersError", {
+            UserNotFound: (e) => Effect.fail(e)
+          }, Effect.die)
+        ),
+      create: ({ payload }) =>
+        users.create(payload).pipe(
+          Effect.orDie
+          // You could alse use Effect.unwrapReason to moves rror reasons up to
+          // the top level, so you can handle them with Effect.catch or
+          // Effect.catchTag etc.
+          //
+          // Effect.unwrapReason("UsersError"),
+          // Effect.catchTags({
+          //   UserNotFound: Effect.die,
+          //   SearchQueryTooShort: Effect.die
+          // })
+        ),
+      update: ({ params, payload }) =>
+        users.update(params.id, payload).pipe(
+          Effect.catchReasons("UsersError", {
+            UserNotFound: (e) => Effect.fail(e)
+          }, Effect.die)
+        ),
+      me: () =>
+        // The Authorization middleware provides the CurrentUser service, so we
+        // can access it here.
+        CurrentUser
+    })
+  })
+)
+
+// The handlers with all dependencies provided, ready to serve. The SQL-backed
+// `Users.layer` keeps the database wiring out of the server entrypoint.
+export const UsersApiHandlers = UsersApiHandlersNoDeps.pipe(
+  Layer.provide([Users.layer, AuthorizationLayer])
+)

package/ai-docs/src/51_http-server/fixtures/server/Users.ts

@@ -0,0 +1,183 @@
+import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node"
+import { Context, Effect, Layer, Schema } from "effect"
+import { SqlClient, SqlModel, SqlSchema } from "effect/sql"
+import { User } from "../domain/User.ts"
+import type { UserId } from "../domain/User.ts"
+import { SearchQueryTooShort, UserNotFound, UsersError } from "../domain/UserErrors.ts"
+
+// The SqlClient layer determines which database the SQL implementation talks
+// to. Swap it for another driver package to target a different database.
+const SqlLayer = SqliteClient.layer({ filename: ":memory:" })
+
+// Migrations are effects keyed by `<id>_<name>` that run once, in id order. A
+// real application would keep each migration in its own file and load them
+// with `SqliteMigrator.fromFileSystem` instead of an inline record.
+const MigratorLayer = SqliteMigrator.layer({
+  loader: SqliteMigrator.fromRecord({
+    "0001_create_users": Effect.gen(function*() {
+      const sql = yield* SqlClient.SqlClient
+      yield* sql`
+        CREATE TABLE users (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          email TEXT NOT NULL,
+          createdAt TEXT NOT NULL,
+          updatedAt TEXT NOT NULL
+        )
+      `
+    })
+  })
+})
+
+export class Users extends Context.Service<Users, {
+  list(search: string | undefined): Effect.Effect<Array<User>, UsersError>
+  getById(id: UserId): Effect.Effect<User, UsersError>
+  create(input: typeof User.jsonCreate.Type): Effect.Effect<User, UsersError>
+  update(id: UserId, input: typeof User.jsonUpdate.Type): Effect.Effect<User, UsersError>
+}>()("acme/Users") {
+  // The SQL implementation only requires a `SqlClient`, so entrypoints and
+  // tests decide how the database is provided.
+  static readonly layerNoDeps = Layer.effect(
+    Users,
+    Effect.gen(function*() {
+      const sql = yield* SqlClient.SqlClient
+
+      // CRUD goes through a repository derived from the `User` model. Each
+      // operation uses the matching model variant to encode its input and
+      // decodes rows with the full model schema.
+      const repo = yield* SqlModel.makeRepository(User, {
+        tableName: "users",
+        spanPrefix: "Users",
+        idColumn: "id"
+      })
+
+      // Queries the repository does not cover are written with the `sql` tag
+      // and decoded with the model schema.
+      const listAll = SqlSchema.findAll({
+        Request: Schema.Void,
+        Result: User,
+        execute: () => sql`SELECT * FROM users ORDER BY createdAt`
+      })
+
+      const searchUsers = SqlSchema.findAll({
+        Request: Schema.String,
+        Result: User,
+        execute: (search) => {
+          const pattern = `%${search}%`
+          return sql`SELECT * FROM users WHERE name LIKE ${pattern} OR email LIKE ${pattern}`
+        }
+      })
+
+      const list = Effect.fn("Users.list")(function*(search: string | undefined) {
+        if (search === undefined || search.length === 0) {
+          return yield* Effect.orDie(listAll())
+        } else if (search.length < SearchQueryTooShort.minimumLength) {
+          return yield* new UsersError({
+            reason: new SearchQueryTooShort()
+          })
+        }
+        yield* Effect.annotateCurrentSpan({ search })
+        return yield* Effect.orDie(searchUsers(search))
+      })
+
+      const getById = Effect.fn("Users.getById")((id: UserId) =>
+        repo.findById(id).pipe(
+          Effect.catchTags({
+            NoSuchElementError: () => new UsersError({ reason: new UserNotFound() }),
+            // Database and encoding failures are unexpected, so treat them as
+            // defects to keep the service interface focused on domain errors.
+            SchemaError: Effect.die,
+            SqlError: Effect.die
+          })
+        )
+      )
+
+      const create = Effect.fn("Users.create")((input: typeof User.jsonCreate.Type) =>
+        // `User.insert.makeEffect` fills in the generated id and timestamps
+        // using the Effect clock, so tests can control them with `TestClock`.
+        User.insert.makeEffect(input).pipe(
+          Effect.flatMap(repo.insert),
+          Effect.orDie
+        )
+      )
+
+      const update = Effect.fn("Users.update")(function*(id: UserId, input: typeof User.jsonUpdate.Type) {
+        // Ensure the user exists first, so a missing id fails with the domain
+        // error instead of a defect.
+        yield* getById(id)
+        const update = yield* User.update.makeEffect({ id, ...input }).pipe(Effect.orDie)
+        return yield* repo.update(update).pipe(Effect.orDie)
+      })
+
+      return Users.of({ list, getById, create, update })
+    })
+  )
+
+  // The fully provided SQL implementation: the database client and migrations
+  // are implementation details, so this layer requires nothing.
+  static readonly layer: Layer.Layer<Users> = this.layerNoDeps.pipe(
+    Layer.provide(MigratorLayer.pipe(Layer.provideMerge(SqlLayer))),
+    Layer.orDie
+  )
+
+  // An in-memory implementation for tests, so the HTTP stack can be exercised
+  // without a database.
+  static readonly layerMemory = Layer.effect(
+    Users,
+    Effect.gen(function*() {
+      const users = new Map<UserId, User>()
+
+      const makeUser = (input: typeof User.jsonCreate.Type) =>
+        User.insert.makeEffect(input).pipe(
+          Effect.map((user) => new User(user)),
+          Effect.orDie
+        )
+
+      const admin = yield* makeUser({ name: "Admin", email: "admin@acme.dev" })
+      users.set(admin.id, admin)
+
+      const list = Effect.fn("Users.list")(function*(search: string | undefined) {
+        const allUsers = Array.from(users.values())
+        if (search === undefined || search.length === 0) {
+          return allUsers
+        } else if (search.length < SearchQueryTooShort.minimumLength) {
+          return yield* new UsersError({
+            reason: new SearchQueryTooShort()
+          })
+        }
+        yield* Effect.annotateCurrentSpan({ search })
+        const normalized = search.toLowerCase()
+        return allUsers.filter((user) =>
+          user.name.toLowerCase().includes(normalized) || user.email.toLowerCase().includes(normalized)
+        )
+      })
+
+      const getById = Effect.fn("Users.getById")(function*(id: UserId) {
+        yield* Effect.annotateCurrentSpan({ id })
+        const user = users.get(id)
+        if (user === undefined) {
+          return yield* new UsersError({
+            reason: new UserNotFound()
+          })
+        }
+        return user
+      })
+
+      const create = Effect.fn("Users.create")(function*(input: typeof User.jsonCreate.Type) {
+        const user = yield* makeUser(input)
+        users.set(user.id, user)
+        return user
+      })
+
+      const update = Effect.fn("Users.update")(function*(id: UserId, input: typeof User.jsonUpdate.Type) {
+        const existing = yield* getById(id)
+        const update = yield* User.update.makeEffect({ id, ...input }).pipe(Effect.orDie)
+        const updated = new User({ ...existing, ...update })
+        users.set(id, updated)
+        return updated
+      })
+
+      return Users.of({ list, getById, create, update })
+    })
+  )
+}

package/ai-docs/src/51_http-server/index.md

@@ -0,0 +1,3 @@
+## Building HttpApi servers
+
+`HttpApi` gives you schema-first, type-safe HTTP APIs with runtime validation, typed clients, and OpenAPI docs from one definition.

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

@@ -0,0 +1,117 @@
+/**
+ * @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 object selection has a Schema.Struct const and a same-named
+// interface for its decoded type. The const handles decoding, encoding and
+// `make`; use the interface in explicit type annotations when a named type
+// is useful. Inferred types and editor hovers can expand structurally rather
+// than showing the names, unlike the previous Schema.Opaque classes.
+export const PageInfo = Schema.Struct({
+  hasNextPage: Schema.Boolean,
+  endCursor: Schema.NullOr(Schema.String)
+})
+export interface PageInfo extends Schema.Struct.Type<typeof PageInfo.fields> {}
+
+export const Issue = Schema.Struct({ number: Schema.Int, title: Schema.String })
+export interface Issue extends Schema.Struct.Type<typeof Issue.fields> {}
+
+export const IssueConnection = Schema.Struct({
+  pageInfo: PageInfo,
+  nodes: Schema.NullOr(Schema.Array(Schema.NullOr(Issue)))
+})
+export interface IssueConnection extends Schema.Struct.Type<typeof IssueConnection.fields> {}
+
+export const Repository = Schema.Struct({ issues: IssueConnection })
+export interface Repository extends Schema.Struct.Type<typeof Repository.fields> {}
+
+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))