The best way to control Claude Code, Codex and more from any computer or phone

main
ts 122 lines 6.45 KB
Raw
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 })