sailfork / t3code-github / .repos/ effect/ packages/ tools/ graphql-generator/ test/ Generator.naming.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, declaration, fileLines, generateIn, member, members } from "./utils/generator.ts"

const schema = `
type User { id: ID! login: String! name: String! }
type AuthorUser { name: String! }
type Issue { id: ID! title: String! author: User assignee: User extra: AuthorUser }
type Pull { id: ID! author: User }
union Item = Issue | Pull
type Wrapper { item: Item }
type Query { issues: [Issue!]! pulls: [Issue!]! items: [Item!]! a: Wrapper b: Wrapper }
`

const generate = (documents: Readonly<Record<string, string>>) =>
  generateIn({ "schema.graphql": schema, ...documents }, { schema: "./schema.graphql", documents: ["src/*.graphql"] })

const generateBoard = (document: string) =>
  generate({ "src/board.graphql": document }).pipe(
    Effect.map((generated) => {
      assertNoErrors(generated)
      return generated.file("src/board.graphql.ts")
    })
  )

const selectionNames = (text: string): ReadonlyArray<string> =>
  fileLines(text).flatMap((line) => {
    const match = /^export const (\w+) = Schema\.Struct\(/.exec(line)
    return match === null ? [] : [match[1]!]
  }).sort()

describe("Generator nested selection names", () => {
  it.effect("nested selections use bare type names, including inside fragments", () =>
    Effect.gen(function*() {
      const board = yield* generateBoard(`
query Board {
  issues { id author { login } }
  pulls { ...IssueSummary }
}

fragment IssueSummary on Issue { title assignee { login } }
`)
      assert.deepStrictEqual(selectionNames(board), ["Issue", "IssueSummary", "User"])
      assert.strictEqual(
        declaration(board, "Issue"),
        "export const Issue = Schema.Struct({"
      )
      assert.include(fileLines(board), "export interface Issue extends Schema.Struct.Type<typeof Issue.fields> {}")
      assert.strictEqual(member(board, "issues"), "Schema.Array(Issue)")
      assert.strictEqual(member(board, "author"), "Schema.NullOr(User)")
      assert.strictEqual(member(board, "pulls"), "Schema.Array(IssueSummary)")
      assert.strictEqual(member(board, "assignee"), "Schema.NullOr(User)")
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("identical selections share one schema across operations, whatever their field order", () =>
    Effect.gen(function*() {
      const reordered = yield* generateBoard(
        "query Board { issues { author { login name } } } query Feed { pulls { id author { name login } } }"
      )
      assert.deepStrictEqual(selectionNames(reordered), ["IssuesIssue", "PullsIssue", "User"])
      assert.deepStrictEqual(members(reordered, "author"), ["Schema.NullOr(User)", "Schema.NullOr(User)"])

      const board = yield* generateBoard("query Board { issues { author { login } assignee { login } } }")
      assert.deepStrictEqual(selectionNames(board), ["Issue", "User"])
      assert.strictEqual(member(board, "author"), "Schema.NullOr(User)")
      assert.strictEqual(member(board, "assignee"), "Schema.NullOr(User)")

      const reorderedMembers = yield* generateBoard(`
query Board {
  a { item { ... on Issue { id } ... on Pull { id } } }
  b { item { ... on Pull { id } ... on Issue { id } } }
}
`)
      assert.deepStrictEqual(selectionNames(reorderedMembers), [
        "Issue",
        "ItemOther",
        "Pull",
        "Wrapper"
      ])

      // The same alias over different fields is a different selection, even though it decodes the same way.
      const aliased = yield* generateBoard(
        "query Board { issues { author { value: login } assignee { value: name } } }"
      )
      assert.deepStrictEqual(selectionNames(aliased), ["AssigneeUser", "AuthorUser", "Issue"])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("clashing shapes fall back to field keys, then parents, and only then the operation", () =>
    Effect.gen(function*() {
      const board = yield* generateBoard("query Board { issues { author { login } } pulls { author { id login } } }")
      assert.deepStrictEqual(selectionNames(board), [
        "IssuesAuthorUser",
        "IssuesIssue",
        "PullsAuthorUser",
        "PullsIssue"
      ])
      assert.strictEqual(member(board, "issues"), "Schema.Array(IssuesIssue)")
      assert.strictEqual(member(board, "pulls"), "Schema.Array(PullsIssue)")
      assert.deepStrictEqual(members(board, "author").slice().sort(), [
        "Schema.NullOr(IssuesAuthorUser)",
        "Schema.NullOr(PullsAuthorUser)"
      ])

      // The shared `{ login }` takes the path of `assignee`, its first occurrence in the document.
      const feed = yield* generateBoard(`
query Feed {
  items {
    ... on Issue { author { id } }
    ... on Pull { assignee: author { login } }
    ... on Issue { later: author { login } }
  }
}
`)
      assert.deepStrictEqual(selectionNames(feed), [
        "AssigneeUser",
        "AuthorUser",
        "Issue",
        "ItemOther",
        "Pull"
      ])
      assert.strictEqual(member(feed, "later"), "Schema.NullOr(AssigneeUser)")

      const operations = yield* generateBoard(
        "query Board { issues { author { login } } } query Feed { issues { author { id } } }"
      )
      assert.deepStrictEqual(selectionNames(operations), [
        "BoardIssuesAuthorUser",
        "BoardIssuesIssue",
        "FeedIssuesAuthorUser",
        "FeedIssuesIssue"
      ])
      assert.deepStrictEqual(members(operations, "author"), [
        "Schema.NullOr(BoardIssuesAuthorUser)",
        "Schema.NullOr(FeedIssuesAuthorUser)"
      ])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("names colliding with an operation or named fragment import fall back instead of failing", () =>
    Effect.gen(function*() {
      const generated = yield* generate({
        "src/user.graphql": "fragment User on User { name }",
        "src/board.graphql": "query Issue { issues { title author { login } assignee { ...User } } }"
      })
      assertNoErrors(generated)
      const board = generated.file("src/board.graphql.ts")
      assert.include(board, "import { User } from \"./user.graphql.ts\"")
      assert.deepStrictEqual(selectionNames(board), ["AuthorUser", "IssuesIssue"])
      assert.strictEqual(member(board, "issues"), "Schema.Array(IssuesIssue)")
      assert.strictEqual(member(board, "author"), "Schema.NullOr(AuthorUser)")
      assert.strictEqual(member(board, "assignee"), "Schema.NullOr(User)")
    }).pipe(Effect.provide(NodeServices.layer)))
})