The best way to control Claude Code, Codex and more from any computer or phone
| 1 | /** Generated modules load without binding collisions; cyclic fragment imports are rejected. */ |
| 2 | import * as NodeServices from "@effect/platform-node/NodeServices" |
| 3 | import { assert, describe, it } from "@effect/vitest" |
| 4 | import * as Effect from "effect/Effect" |
| 5 | import * as Schema from "effect/Schema" |
| 6 | import { assertNoErrors, type Generated, generateIn, importGenerated } from "./utils/generator.ts" |
| 7 | |
| 8 | const config = { schema: "./schema.graphql", documents: ["src/*.graphql"] } |
| 9 | |
| 10 | const located = (generated: Generated) => |
| 11 | generated.result.diagnostics.map(({ column, line, path, severity }) => ({ severity, path, line, column })) |
| 12 | |
| 13 | describe("Generator module graph", () => { |
| 14 | it.effect("fragments spread across two files in both directions are a located error, not a module cycle", () => |
| 15 | Effect.gen(function*() { |
| 16 | const generated = yield* generateIn({ |
| 17 | "schema.graphql": "type Query { x: Int! }", |
| 18 | "src/a.graphql": "fragment A2 on Query { x }\nfragment A1 on Query { ...B1 }\nquery Q { ...A1 }", |
| 19 | "src/b.graphql": "fragment B1 on Query { ...A2 }" |
| 20 | }, config) |
| 21 | assert.deepStrictEqual(located(generated), [{ severity: "error", path: "src/a.graphql", line: 2, column: 24 }]) |
| 22 | const message = generated.result.diagnostics[0]!.message |
| 23 | assert.match(message, /cycle/i) |
| 24 | assert.include(message, "a.graphql") |
| 25 | assert.include(message, "b.graphql") |
| 26 | assert.deepStrictEqual(generated.result.files, []) |
| 27 | }).pipe(Effect.provide(NodeServices.layer))) |
| 28 | }) |
| 29 | |
| 30 | describe("Generator group bindings", () => { |
| 31 | it.effect("digit-leading filenames export a loadable underscore-prefixed GraphQL group", () => |
| 32 | Effect.gen(function*() { |
| 33 | const generated = yield* generateIn({ |
| 34 | "schema.graphql": "type Query { x: Int! }", |
| 35 | "src/123-ops.graphql": "query Q { x }" |
| 36 | }, config) |
| 37 | assertNoErrors(generated) |
| 38 | const ops = yield* importGenerated(generated, "src/123-ops.graphql.ts") |
| 39 | assert.isDefined(ops._123OpsGraphQLGroup) |
| 40 | assert.isUndefined(ops._123OpsGroup) |
| 41 | }).pipe(Effect.provide(NodeServices.layer))) |
| 42 | |
| 43 | it.effect("an empty PascalCase filename reports the GraphQLGroup import collision without emitting files", () => |
| 44 | Effect.gen(function*() { |
| 45 | const generated = yield* generateIn({ |
| 46 | "schema.graphql": "type Query { x: Int! }", |
| 47 | "src/---.graphql": "query Q { x }" |
| 48 | }, config) |
| 49 | assert.strictEqual(generated.result.diagnostics.length, 1) |
| 50 | const diagnostic = generated.result.diagnostics[0]! |
| 51 | assert.strictEqual(diagnostic.severity, "error") |
| 52 | assert.strictEqual(diagnostic.path, "src/---.graphql") |
| 53 | assert.include(diagnostic.message, "GraphQLGroup") |
| 54 | assert.deepStrictEqual(generated.result.files, []) |
| 55 | }).pipe(Effect.provide(NodeServices.layer))) |
| 56 | |
| 57 | it.effect("a local fragment named like the file's group is a located error", () => |
| 58 | Effect.gen(function*() { |
| 59 | const generated = yield* generateIn({ |
| 60 | "schema.graphql": "type Query { x: Int! }", |
| 61 | "src/ops.graphql": "fragment OpsGraphQLGroup on Query { x }\nquery Q { ...OpsGraphQLGroup }" |
| 62 | }, config) |
| 63 | assert.deepStrictEqual(located(generated), [{ severity: "error", path: "src/ops.graphql", line: 1, column: 10 }]) |
| 64 | assert.include(generated.result.diagnostics[0]!.message, `"OpsGraphQLGroup"`) |
| 65 | assert.match(generated.result.diagnostics[0]!.message, /group/) |
| 66 | assert.deepStrictEqual(generated.result.files, []) |
| 67 | }).pipe(Effect.provide(NodeServices.layer))) |
| 68 | |
| 69 | it.effect("a fragment named like the file's group, imported only because a spread was inlined, is a located error", () => |
| 70 | Effect.gen(function*() { |
| 71 | // `y` overlaps `Outer`, so `Outer` is written out inline and its `...OpsGraphQLGroup` |
| 72 | // becomes an import of `OpsGraphQLGroup` into ops.graphql.ts. |
| 73 | const generated = yield* generateIn({ |
| 74 | "schema.graphql": "type Query { x: Int! y: Int! }", |
| 75 | "src/frags.graphql": |
| 76 | "fragment OpsGraphQLGroup on Query { x }\nfragment Outer on Query { ...OpsGraphQLGroup y }", |
| 77 | "src/ops.graphql": "query Q { y ...Outer }" |
| 78 | }, config) |
| 79 | assert.deepStrictEqual(located(generated), [{ severity: "error", path: "src/ops.graphql", line: 1, column: 13 }]) |
| 80 | assert.include(generated.result.diagnostics[0]!.message, `"OpsGraphQLGroup"`) |
| 81 | assert.match(generated.result.diagnostics[0]!.message, /group/) |
| 82 | assert.deepStrictEqual(generated.result.files, []) |
| 83 | }).pipe(Effect.provide(NodeServices.layer))) |
| 84 | }) |
| 85 | |
| 86 | describe("Generator schema names", () => { |
| 87 | it.effect("an enum named Schema and an input object named default load and round-trip", () => |
| 88 | Effect.gen(function*() { |
| 89 | const generated = yield* generateIn({ |
| 90 | "schema.graphql": |
| 91 | "enum Schema { X Y }\ninput default { value: Schema }\ntype Query { value(filter: default): Schema! }", |
| 92 | "src/ops.graphql": "query Q($filter: default) { value(filter: $filter) }" |
| 93 | }, config) |
| 94 | assertNoErrors(generated) |
| 95 | const shared = yield* importGenerated(generated, "schema.graphql.ts") |
| 96 | assert.deepStrictEqual(shared.Schema.literals, ["X", "Y"]) |
| 97 | assert.isDefined(shared.default) |
| 98 | const ops = yield* importGenerated(generated, "src/ops.graphql.ts") |
| 99 | assert.deepStrictEqual(Schema.decodeUnknownSync(ops.Q.result)({ value: "X" }), { value: "X" }) |
| 100 | assert.deepStrictEqual(Schema.encodeSync(ops.Q.variables)({ filter: { value: "Y" } }), { filter: { value: "Y" } }) |
| 101 | }).pipe(Effect.provide(NodeServices.layer))) |
| 102 | }) |
| 103 | |
| 104 | describe("Generator __proto__ keys", () => { |
| 105 | it.effect("a __proto__ alias and variable are own struct fields that decode and encode", () => |
| 106 | Effect.gen(function*() { |
| 107 | const generated = yield* generateIn({ |
| 108 | "schema.graphql": "type Query { x(n: Int): Int! }", |
| 109 | "src/ops.graphql": "query Q($__proto__: Int) { __proto__: x(n: $__proto__) }" |
| 110 | }, config) |
| 111 | assertNoErrors(generated) |
| 112 | const ops = yield* importGenerated(generated, "src/ops.graphql.ts") |
| 113 | assert.deepStrictEqual(Object.keys(ops.Q.result.fields), ["__proto__"]) |
| 114 | assert.deepStrictEqual(Object.keys(ops.Q.variables.fields), ["__proto__"]) |
| 115 | const decoded = Schema.decodeUnknownSync(ops.Q.result)(JSON.parse(`{"__proto__":1}`)) |
| 116 | assert.isTrue(Object.hasOwn(decoded, "__proto__")) |
| 117 | assert.strictEqual(decoded["__proto__"], 1) |
| 118 | const encoded = Schema.encodeSync(ops.Q.variables)(JSON.parse(`{"__proto__":3}`)) |
| 119 | assert.isTrue(Object.hasOwn(encoded, "__proto__")) |
| 120 | assert.strictEqual(encoded["__proto__"], 3) |
| 121 | }).pipe(Effect.provide(NodeServices.layer))) |
| 122 | }) |