/**
* @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 const PullRequestPullRequest = Schema.Struct({
number: Shared.Int,
title: Schema.String
})
export interface PullRequestPullRequest extends Schema.Struct.Type<typeof PullRequestPullRequest.fields> {}
export const Repository = Schema.Struct({
pullRequest: Schema.NullOr(PullRequestPullRequest)
})
export interface Repository extends Schema.Struct.Type<typeof Repository.fields> {}
// 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)
)