sailfork / t3code-github / .repos/ effect/ packages/ tools/ graphql-generator/ test/ Generator.mapping.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,
  docOf,
  generateIn,
  generateTasks,
  member,
  taskConfig,
  warnings
} from "./utils/generator.ts"

describe("Generator mapping", () => {
  it.effect("DateTime and URI have overridable defaults while other custom scalars stay Json", () =>
    Effect.gen(function*() {
      const inputs = {
        "schema.graphql": `
          scalar DateTime
          scalar URI
          scalar datetime
          scalar uri
          scalar GitObjectID
          type Query { timestamp: DateTime! url: URI! lowerDate: datetime! lowerUri: uri! oid: GitObjectID! }
        `,
        "src/ops.graphql": "query Scalars { timestamp url lowerDate lowerUri oid }"
      }
      const config = { schema: "./schema.graphql", documents: ["src/*.graphql"] }
      const defaults = yield* generateIn(inputs, config)
      const overridden = yield* generateIn(inputs, {
        ...config,
        scalars: { DateTime: "./scalars.ts#Timestamp", URI: "./scalars.ts#Url" }
      })
      for (const generated of [defaults, overridden]) {
        assertNoErrors(generated)
        const shared = generated.file("schema.graphql.ts")
        for (const name of ["GitObjectID", "datetime", "uri"]) {
          assert.strictEqual(declaration(shared, name), `export const ${name} = Schema.Json`)
        }
      }
      const overrideShared = overridden.file("schema.graphql.ts")
      assert.match(declaration(overrideShared, "DateTime"), /^export const DateTime = \w+\.Timestamp$/)
      assert.match(declaration(overrideShared, "URI"), /^export const URI = \w+\.Url$/)
      const shared = defaults.file("schema.graphql.ts")
      assert.deepStrictEqual({
        DateTime: declaration(shared, "DateTime"),
        URI: declaration(shared, "URI"),
        warnings: [defaults, overridden].map((generated) => warnings(generated).map(({ message }) => message))
      }, {
        DateTime: "export const DateTime = Schema.DateTimeUtcFromString",
        URI: "export const URI = Schema.String",
        warnings: [
          ["Custom scalars without a mapping decode as Schema.Json: GitObjectID, datetime, uri. Map each one to a codec with `scalars` in the config."],
          ["Custom scalars without a mapping decode as Schema.Json: GitObjectID, datetime, uri. Map each one to a codec with `scalars` in the config."]
        ]
      })
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a non-null variable with a default is optional(T) and keeps the default as @default", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({
        "src/ops.graphql": "query Tasks($first: Int! = 20) { tasks(first: $first) { id } }"
      })
      assertNoErrors(generated)
      const ops = generated.file("src/ops.graphql.ts")
      assert.strictEqual(member(ops, "first"), "Schema.optional(Shared.Int)")
      assert.deepStrictEqual(docOf(ops, "first"), ["@default 20"])
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a recursive input object is a Codec, with an Encoded type when a field may transform", () =>
    Effect.gen(function*() {
      const generated = yield* generateIn({
        "schema.graphql": `
          scalar Stamp
          input Tree { child: Tree }
          input Dated { at: Stamp next: Dated }
          input Unused { self: Unused }
          type Query { tree(t: Tree, d: Dated, u: Unused): Int }
        `,
        "src/ops.graphql": "query Q($t: Tree, $d: Dated) { tree(t: $t, d: $d) }"
      }, { schema: "./schema.graphql", documents: ["src/*.graphql"], scalars: { Stamp: "./scalars.ts#Stamp" } })
      assertNoErrors(generated)
      const shared = generated.file("schema.graphql.ts")
      assert.deepStrictEqual({
        Tree: declaration(shared, "Tree"),
        Dated: declaration(shared, "Dated"),
        unused: shared.includes("Unused")
      }, {
        Tree: "export const Tree: Schema.Codec<Tree> = Schema.Struct({",
        Dated: "export const Dated: Schema.Codec<Dated, DatedEncoded> = Schema.Struct({",
        unused: false
      })
      assert.include(shared, "export interface DatedEncoded {\n  readonly at?: typeof Stamp.Encoded | null | undefined")
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a scalars entry overrides a built-in", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks(
        { "src/ops.graphql": "query Tasks { tasks { id } }" },
        { ...taskConfig, scalars: { ID: "./scalars.ts#NodeId" } }
      )
      assertNoErrors(generated)
      assert.match(declaration(generated.file("schema/app.graphql.ts"), "ID"), /^export const ID = \w+\.NodeId$/)
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("the shared module defaults to the schema's name and directory", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks({ "src/ops.graphql": "query Tasks { tasks { id } }" })
      assertNoErrors(generated)
      assert.deepStrictEqual(generated.paths, ["schema/app.graphql.ts", "src/ops.graphql.ts"])
      assert.match(generated.file("src/ops.graphql.ts"), /^import \* as Shared from "\.\.\/schema\/app\.graphql\.ts"$/m)
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("a relative scalar module with an extension other than .ts or .js is imported as written", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks(
        { "src/ops.graphql": "query Tasks { tasks { due } }" },
        { ...taskConfig, scalars: { Timestamp: "./scalars.mjs#Timestamp" } }
      )
      assertNoErrors(generated)
      assert.match(generated.file("schema/app.graphql.ts"), /^import \* as \w+ from "\.\.\/scalars\.mjs"$/m)
    }).pipe(Effect.provide(NodeServices.layer)))

  it.effect("importExtension applies to generated and relative scalar modules, not bare specifiers", () =>
    Effect.gen(function*() {
      const generated = yield* generateTasks(
        { "src/ops.graphql": "query Tasks { tasks { due bodyHTML } }" },
        { ...taskConfig, importExtension: ".js", scalars: { ...taskConfig.scalars, HTML: "@acme/scalars#HTML" } }
      )
      assertNoErrors(generated)
      const shared = generated.file("schema/app.graphql.ts")
      assert.match(generated.file("src/ops.graphql.ts"), /^import \* as Shared from "\.\.\/schema\/app\.graphql\.js"$/m)
      assert.match(shared, /^import \* as \w+ from "\.\.\/scalars\.js"$/m)
      assert.match(shared, /^import \* as \w+ from "@acme\/scalars"$/m)
    }).pipe(Effect.provide(NodeServices.layer)))
})