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

import * as Generator from "@effect/graphql-generator/Generator"
import * as NodeServices from "@effect/platform-node/NodeServices"
import { assert, describe, it } from "@effect/vitest"
import * as Effect from "effect/Effect"
import * as FileSystem from "effect/FileSystem"
import * as Path from "effect/Path"
import {
  assertDeclaredInOrder,
  assertNoErrors,
  generateIn,
  generateTasks,
  importGenerated,
  member
} from "./utils/generator.ts"

// `TaskSchedule` is defined before the `TaskCore` it spreads, so source order
// and dependency order disagree.
const fragments = `
fragment TaskSchedule on Task {
  estimate
  ...TaskCore
}

fragment TaskCore on Task {
  id
  title
}
`

const tasks = `
query Scheduled {
  tasks {
    ...TaskSchedule
  }
}

query Titled {
  tasks {
    ...TaskCore
    title
    done
  }
}
`

const generate = generateTasks({ "src/fragments.graphql": fragments, "src/tasks.graphql": tasks }).pipe(
  Effect.map((generated) => {
    assertNoErrors(generated)
    return {
      generated,
      fragments: generated.file("src/fragments.graphql.ts"),
      tasks: generated.file("src/tasks.graphql.ts")
    }
  })
)

describe("Generator per-file output", () => {
  it.effect("deletes lists only headered orphans, not handwritten files, live outputs or the shared module", () =>
    Effect.gen(function*() {
      const orphan =
        "// Generated by @effect/graphql-generator from orphan.graphql. Do not edit.\nexport const Orphan = 1\n"
      const generated = yield* generateIn({
        "schema.graphql": "type Query { hello: String! }",
        "src/live.graphql": "query Live { hello }",
        "src/live.graphql.ts": "// Generated by @effect/graphql-generator from live.graphql. Do not edit.\n",
        "src/orphan.graphql.ts": orphan,
        "src/handwritten.graphql.ts": "export const Handwritten = true\n",
        "src/shared.graphql.ts": "// Generated by @effect/graphql-generator from schema.graphql. Do not edit.\n"
      }, {
        schema: "./schema.graphql",
        documents: ["src/**/*.graphql"],
        shared: "./src/shared.graphql.ts"
      })
      assertNoErrors(generated)
      const path = yield* Path.Path
      assert.deepStrictEqual(generated.result.deletes.map((file) => path.basename(file)), ["orphan.graphql.ts"])
      const fs = yield* FileSystem.FileSystem
      assert.strictEqual(yield* fs.readFileString(generated.result.deletes[0]!), orphan)
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a shared module, which names no source, is never listed as stale", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": "type Query { hello: String! }",
        "src/live.graphql": "query Live { hello }",
        "src/orphan.graphql.ts": "// Generated by @effect/graphql-generator from orphan.graphql. Do not edit.\n",
        "src/other-shared.graphql.ts": "// Generated by @effect/graphql-generator. Do not edit.\n"
      }, { schema: "./schema.graphql", documents: ["src/**/*.graphql"] })
      assertNoErrors(generated)
      const path = yield* Path.Path
      assert.deepStrictEqual(generated.result.deletes.map((file) => path.basename(file)), ["orphan.graphql.ts"])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("an interface without implementations has the possible typenames never", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": "interface Lonely { id: ID! } type Query { lonely: Lonely }",
        "src/a.graphql": "query A { lonely { id } }"
      }, { schema: "./schema.graphql", documents: ["src/*.graphql"] })
      assertNoErrors(generated)
      assert.include(generated.file("schema.graphql.ts"), "export type Lonely = never")
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("schema names that TypeScript reserves for types never become type or class names", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": [
          "enum symbol { A B }",
          "input any { x: Int }",
          "type object { id: ID! }",
          "union string = object",
          "type Query { things(where: any, s: symbol): [object!] u: string }"
        ].join("\n"),
        "src/a.graphql": "query Q($w: any, $s: symbol) { things(where: $w, s: $s) { id } u { ... on object { id } } }"
      }, { schema: "./schema.graphql", documents: ["src/*.graphql"] })
      assertNoErrors(generated)
      const reserved = /\b(?:type|class) (?:any|bigint|boolean|never|number|object|string|symbol|undefined|unknown)\b/
      for (const file of generated.paths) {
        assert.deepStrictEqual(generated.file(file).split("\n").filter((line) => reserved.test(line)), [], file)
      }
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("colliding abstract type names have distinct typename aliases and matching references", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": [
          "type A { id: ID! }",
          "type B { id: ID! }",
          "union string = A",
          "union string_ = B",
          "type Query { a: string! b: string_! }"
        ].join("\n"),
        "src/a.graphql": "query Q { a { __typename } b { __typename } }"
      }, { schema: "./schema.graphql", documents: ["src/*.graphql"] })
      assertNoErrors(generated)
      const aliases = Array.from(
        generated.file("schema.graphql.ts").matchAll(/export type (\w+) = "([AB])"/g),
        (match) => [match[1], match[2]]
      )
      assert.deepStrictEqual(aliases.map((alias) => alias[1]), ["A", "B"])
      const references = Array.from(
        generated.file("src/a.graphql.ts").matchAll(/GraphQL.otherTypename<Shared\.Typename\.(\w+)>/g),
        (match) => match[1]
      )
      assert.deepStrictEqual(references, aliases.map((alias) => alias[0]))
      assert.notStrictEqual(aliases[0]![0], aliases[1]![0])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a shared path equal to the schema or a document is an error, and nothing is generated", () =>
    Effect.gen(function*() {
      for (const shared of ["./schema.graphql", "./src/a.graphql"]) {
        const generated = yield* generateIn({
          "schema.graphql": "type Query { hello: String! }",
          "src/a.graphql": "query A { hello }"
        }, { schema: "./schema.graphql", documents: ["src/*.graphql"], shared })
        assert.strictEqual(generated.result.diagnostics.filter((d) => d.severity === "error").length, 1, shared)
        assert.deepStrictEqual(generated.result.files, [], shared)
      }
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a dangling symlink under a documents root is skipped", () =>
    Effect.gen(function*() {
      const fs = yield* FileSystem.FileSystem
      const path = yield* Path.Path
      const cwd = yield* fs.makeTempDirectoryScoped({ prefix: "graphql-generator-" })
      yield* fs.makeDirectory(path.join(cwd, "src"))
      yield* fs.writeFileString(path.join(cwd, "schema.graphql"), "type Query { hello: String! }")
      yield* fs.writeFileString(path.join(cwd, "src", "a.graphql"), "query A { hello }")
      yield* fs.symlink(path.join(cwd, "missing"), path.join(cwd, "src", "dangling"))
      const result = yield* Generator.generate({ schema: "./schema.graphql", documents: ["src/**/*.graphql"] }, { cwd })
      assert.deepStrictEqual(result.diagnostics, [])
      assert.include(result.files.map((file) => path.basename(file.path)), "a.graphql.ts")
    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)))

  it.effect("an absolute documents pattern is a ConfigError", () =>
    Effect.gen(function*() {
      const error = yield* generateIn({
        "schema.graphql": "type Query { hello: String! }",
        "src/a.graphql": "query A { hello }"
      }, { schema: "./schema.graphql", documents: ["/abs/src/*.graphql"] }).pipe(Effect.flip)
      assert.strictEqual(error._tag, "ConfigError")
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect(".gql documents name their group without the extension and are cleaned up as stale", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": "type Query { hello: String! }",
        "src/other.gql": "query Other { hello }",
        "src/gone.gql.ts": "// Generated by @effect/graphql-generator from gone.gql. Do not edit.\n"
      }, { schema: "./schema.graphql", documents: ["src/*.gql"] })
      assertNoErrors(generated)
      assert.match(generated.file("src/other.gql.ts"), /^export const OtherGraphQLGroup\b/m)
      const path = yield* Path.Path
      assert.deepStrictEqual(generated.result.deletes.map((file) => path.basename(file)), ["gone.gql.ts"])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("fragments are declared after the fragments they spread", () =>
    Effect.gen(function*() {
      const { fragments } = yield* generate
      assertDeclaredInOrder(fragments, ["TaskCore", "TaskSchedule"])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a fragment whose keys overlap its siblings is written out inline", () =>
    Effect.gen(function*() {
      const { tasks } = yield* generate
      assert.notInclude(tasks, "...TaskCore.fields")
      assert.strictEqual(member(tasks, "id"), "Shared.ID")
      assert.strictEqual(member(tasks, "title"), "Schema.String")
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("documents append every fragment they use, including through other fragments, in order of first use", () =>
    Effect.gen(function*() {
      const { generated } = yield* generate
      const module = yield* importGenerated(generated, "src/tasks.graphql.ts")
      assert.strictEqual(
        module.Scheduled.document,
        "query Scheduled{tasks{...TaskSchedule}}fragment TaskSchedule on Task{estimate...TaskCore}fragment TaskCore on Task{id title}"
      )
    }).pipe(Effect.provide(NodeServices.layer)))
})