sailfork / t3code-github / .repos/ effect/ packages/ tools/ graphql-generator/ test/ Generator.abstract.test.ts

/** Generated interface and union selections decode through their result schemas. */
import * as NodeServices from "@effect/platform-node/NodeServices"
import { assert, describe, it } from "@effect/vitest"
import * as Effect from "effect/Effect"
import * as Schema from "effect/Schema"
import { assertNoErrors, generateIn, importGenerated } from "./utils/generator.ts"

const decoderFor = Effect.fnUntraced(function*(schema: string, document: string) {
  const generated = yield* generateIn(
    { "schema.graphql": schema, "src/ops.graphql": document },
    { schema: "./schema.graphql", documents: ["src/*.graphql"] }
  )
  assertNoErrors(generated)
  const ops = yield* importGenerated(generated, "src/ops.graphql.ts")
  return Schema.decodeUnknownSync(ops.Q.result)
})

describe("Generator abstract members", () => {
  it.effect("a fragment on the only possible type of an interface keeps its own member", () =>
    Effect.gen(function*() {
      const decode = yield* decoderFor(
        "interface Only { id: ID! }\ntype User implements Only { id: ID! name: String! }\ntype Query { only: Only }",
        "query Q { only { ... on User { name } } }"
      )
      const user = { only: { __typename: "User", name: "Ann" } }
      assert.deepStrictEqual(decode(user), user)
      assert.throws(() => decode({ only: { __typename: "User" } }))
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("an interface fragment covering every member of a union generates and decodes", () =>
    Effect.gen(function*() {
      const decode = yield* decoderFor(
        `interface Named { name: String! }
union Result = User | Bot
type User implements Named { id: ID! name: String! }
type Bot implements Named { id: ID! name: String! }
type Query { results: [Result!]! }`,
        "query Q { results { ... on Named { name } } }"
      )
      const results = { results: [{ __typename: "User", name: "Ann" }, { __typename: "Bot", name: "ci" }] }
      assert.deepStrictEqual(decode(results), results)
      assert.throws(() => decode({ results: [{ __typename: "Bot" }] }))
    }).pipe(Effect.provide(NodeServices.layer)))
})