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

import * as NodeServices from "@effect/platform-node/NodeServices"
import { assert, describe, it } from "@effect/vitest"
import * as Effect from "effect/Effect"
import {
  assertNoErrors,
  fileLines,
  type Generated,
  generateIn,
  generateTasks,
  taskConfig,
  warnings
} from "./utils/generator.ts"
import { fixture } from "./utils/model.ts"

const located = (generated: Generated) =>
  generated.result.diagnostics.map(({ column, line, message, severity }) => ({ severity, line, column, message }))

describe("Generator diagnostics", () => {
  it.effect("unmapped custom scalars decode as Schema.Json with one warning listing each one reached", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({
        "src/a.graphql": "query A { tasks { bodyHTML } }",
        "src/b.graphql": "query B { tasks { bodyHTML due } }"
      })
      assertNoErrors(generated)
      assert.include(fileLines(generated.file("schema/app.graphql.ts")), "export const HTML = Schema.Json")
      assert.deepStrictEqual(warnings(generated).map((warning) => warning.message), [
        "Custom scalars without a mapping decode as Schema.Json: HTML. Map each one to a codec with `scalars` in the config."
      ])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a scalars key naming a type that isn't a scalar is a config error", () =>
    Effect.gen(function*() {
      const error = yield* generateTasks(
        { "src/a.graphql": "query A { tasks { id } }" },
        { ...taskConfig, scalars: { Task: "./scalars.ts#Task" } }
      ).pipe(Effect.flip)
      assert.strictEqual(error._tag, "ConfigError")
      assert.include(error.message, "Task")
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a type-system definition in a document file is a located error", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({
        "src/ops.graphql": "query A { tasks { id } }\n\ntype Extra {\n  a: Int\n}\n"
      })
      assert.deepStrictEqual(located(generated), [
        { severity: "error", line: 3, column: 1, message: `The "Extra" definition is not executable.` }
      ])
      assert.deepStrictEqual(generated.result.files, [])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a definition named like a binding of the generated module is a located error", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({ "src/ops.graphql": "query Schema { tasks { id } }" })
      assert.deepStrictEqual(located(generated), [{
        severity: "error",
        line: 1,
        column: 7,
        message: `The name "Schema" is reserved in generated code; rename this definition.`
      }])
      assert.deepStrictEqual(generated.result.files, [])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a field whose type the schema never defines is an Unknown type error, not a crash", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": "type Query { a: Missing }",
        "src/a.graphql": "query Q { a }"
      }, { schema: "./schema.graphql", documents: ["src/*.graphql"] })
      assert.deepStrictEqual(generated.result.diagnostics.map(({ message, severity }) => ({ severity, message })), [
        { severity: "error", message: `Unknown type "Missing".` }
      ])
      assert.deepStrictEqual(generated.result.files, [])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("eval and arguments, which strict mode can't bind, are reserved definition names", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({
        "src/ops.graphql": "query eval { tasks { id } }\nquery arguments { tasks { id } }"
      })
      assert.deepStrictEqual(located(generated).map(({ line, message }) => ({ line, message })), [
        { line: 1, message: `The name "eval" is reserved in generated code; rename this definition.` },
        { line: 2, message: `The name "arguments" is reserved in generated code; rename this definition.` }
      ])
      assert.deepStrictEqual(generated.result.files, [])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a shared module path that is also a document's output is an error, and nothing is generated", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({ "src/ops.graphql": "query Tasks { tasks { id } }" }, {
        ...taskConfig,
        shared: "./src/ops.graphql.ts"
      })
      assert.strictEqual(generated.result.diagnostics.filter((d) => d.severity === "error").length, 1)
      assert.deepStrictEqual(generated.result.files, [])
    }).pipe(Effect.provide(NodeServices.layer)))
})

describe("Generator introspection JSON schema", () => {
  const search =
    `query Search($filter: SearchFilter, $limit: Int = 10) { now search(term: "x", filter: $filter, limit: $limit) }`

  it.effect("a .json schema generates the same files as its SDL, with the shared module named <schema>.graphql.ts", () =>
    Effect.gen(function*() {
      const fromJson = yield* generateIn(
        { "schema/modern.json": fixture("introspection/modern.json"), "src/search.graphql": search },
        { schema: "./schema/modern.json", documents: ["src/*.graphql"] }
      )
      const fromSdl = yield* generateIn(
        { "schema/modern.graphql": fixture("introspection/modern.graphql"), "src/search.graphql": search },
        { schema: "./schema/modern.graphql", documents: ["src/*.graphql"] }
      )
      assertNoErrors(fromJson)
      assert.deepStrictEqual(fromJson.paths, ["schema/modern.graphql.ts", "src/search.graphql.ts"])
      assert.deepStrictEqual(fromSdl.paths, fromJson.paths)
      for (const path of fromJson.paths) {
        assert.strictEqual(fromJson.file(path), fromSdl.file(path), path)
      }
    }).pipe(Effect.provide(NodeServices.layer)))
})