@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 177 lines 7.72 KB
Raw
1 /** Joining a template reproduces the printed document; batched slices remain valid GraphQL. */
2 import type * as Ast from "@effect/graphql-generator/internal/Ast"
3 import * as Validate from "@effect/graphql-generator/internal/Validate"
4 import * as NodeServices from "@effect/platform-node/NodeServices"
5 import { assert, describe, it } from "@effect/vitest"
6 import * as Effect from "effect/Effect"
7 import type { GraphQL } from "effect/graphql"
8 import { renderSlices } from "effect/internal/graphql"
9 import { parseOrThrow, source } from "./utils/ast.ts"
10 import { assertNoErrors, generateTasks, importGenerated, taskSchemaSdl } from "./utils/generator.ts"
11 import { readSdl } from "./utils/model.ts"
12
13 // `TaskCore` references no variable, so a batch shares it. `TaskDue`
14 // references `$withDue`, so each slice gets its own copy.
15 const board = `
16 query Board($first: Int! = 5, $taskId: ID!, $withDue: Boolean! = false, $withTasks: Boolean!) {
17 tasks(first: $first) @include(if: $withTasks) {
18 ...TaskCore
19 ...TaskDue
20 }
21 current: task(id: $taskId) {
22 ...TaskDue
23 }
24 }
25
26 fragment TaskCore on Task {
27 id
28 title
29 }
30
31 fragment TaskDue on Task {
32 estimate @include(if: $withDue)
33 ...TaskCore
34 }
35 `
36
37 const importBoard = Effect.gen(function*() {
38 const generated = yield* generateTasks({ "src/board.graphql": board })
39 assertNoErrors(generated)
40 const module = yield* importGenerated(generated, "src/board.graphql.ts")
41 return module.Board as GraphQL.Any
42 }).pipe(Effect.provide(NodeServices.layer))
43
44 describe("Generator document templates", () => {
45 it.effect("joining the template gives the printed document", () =>
46 Effect.gen(function*() {
47 const Board = yield* importBoard
48 assert.isDefined(Board.template)
49 assert.strictEqual(
50 Board.document,
51 "query Board($first:Int!=5$taskId:ID!$withDue:Boolean!=false$withTasks:Boolean!){tasks(first:$first)@include(if:$withTasks){...TaskCore...TaskDue}current:task(id:$taskId){...TaskDue}}fragment TaskCore on Task{id title}fragment TaskDue on Task{estimate@include(if:$withDue)...TaskCore}"
52 )
53 }))
54
55 it.effect("two slices render a valid document with renamed variables and per-slice fragments", () =>
56 Effect.gen(function*() {
57 const Board = yield* importBoard
58 assert(Board.template !== undefined)
59 const text = renderSlices("query", "Board", Board.template, ["_0_", "_1_"])
60 const document = parseOrThrow(text)
61 assert.deepStrictEqual(
62 Validate.validate(readSdl(taskSchemaSdl), [{ source: source(text), document }]).map(({ message }) => message),
63 []
64 )
65
66 const [operation, ...fragments] = document.definitions
67 assert(operation?._tag === "OperationDefinition")
68 assert.deepStrictEqual(operation.variableDefinitions.map((v) => v.variable.name.value), [
69 "_0_first",
70 "_0_taskId",
71 "_0_withDue",
72 "_0_withTasks",
73 "_1_first",
74 "_1_taskId",
75 "_1_withDue",
76 "_1_withTasks"
77 ])
78 assert.deepStrictEqual(
79 operation.selectionSet.selections.map((s) => s._tag === "Field" ? s.alias?.value : s._tag),
80 ["_0_tasks", "_0_current", "_1_tasks", "_1_current"]
81 )
82 assert.deepStrictEqual(
83 fragments.map((f) => (f as Ast.FragmentDefinition).name.value),
84 ["TaskCore", "_0_TaskDue", "_1_TaskDue"]
85 )
86 }))
87
88 it.effect("variable-bearing operation directives round-trip but cannot be sliced", () =>
89 Effect.gen(function*() {
90 const generated = yield* generateTasks({
91 "schema/app.graphql": taskSchemaSdl + "directive @cached(ttl: Int!) on QUERY",
92 "src/cached.graphql": "query Cached($ttl: Int!) @cached(ttl: $ttl) { tasks { id } }"
93 })
94 assertNoErrors(generated)
95 const { Cached } = yield* importGenerated(generated, "src/cached.graphql.ts")
96 assert(Cached.template !== undefined)
97 assert.strictEqual(Cached.document, "query Cached($ttl:Int!)@cached(ttl:$ttl){tasks{id}}")
98 assert.throws(
99 () => renderSlices("query", "Cached", Cached.template, ["_0_", "_1_"]),
100 "Cannot render slices of operation Cached: its operation directives reference variables"
101 )
102 }).pipe(Effect.provide(NodeServices.layer)))
103
104 it.effect("root spreads and inline fragments round-trip but cannot be sliced", () =>
105 Effect.gen(function*() {
106 const generated = yield* generateTasks({
107 "src/roots.graphql": `
108 query Spread { ...Root }
109 query Inline { ... on Query { tasks { id } } }
110 fragment Root on Query { tasks { id } }
111 `
112 })
113 assertNoErrors(generated)
114 const module = yield* importGenerated(generated, "src/roots.graphql.ts")
115 for (
116 const [name, expected] of [
117 ["Spread", "query Spread{...Root}fragment Root on Query{tasks{id}}"],
118 ["Inline", "query Inline{...on Query{tasks{id}}}"]
119 ] as const
120 ) {
121 const operation = module[name] as GraphQL.Any
122 const template = operation.template
123 assert(template !== undefined)
124 assert.strictEqual(operation.document, expected)
125 assert.throws(
126 () => renderSlices("query", name, template, ["_0_", "_1_"]),
127 `Cannot render slices of operation ${name}: it has a fragment spread or inline fragment at the root`
128 )
129 }
130 }).pipe(Effect.provide(NodeServices.layer)))
131
132 it.effect("slicing rejects a per-slice fragment renamed onto a shared fragment's name", () =>
133 Effect.gen(function*() {
134 const generated = yield* generateTasks({
135 "src/collide.graphql": `
136 query Collide($show: Boolean!) { tasks { ...F ..._0_F } }
137 fragment F on Task { title @include(if: $show) }
138 fragment _0_F on Task { id }
139 `
140 })
141 assertNoErrors(generated)
142 const { Collide } = yield* importGenerated(generated, "src/collide.graphql.ts")
143 assert(Collide.template !== undefined)
144 assert.throws(() => renderSlices("query", "Collide", Collide.template, ["_0_", "_1_"]), /fragment _0_F/)
145 }).pipe(Effect.provide(NodeServices.layer)))
146
147 it.effect("slicing preserves dollar-name literals and renames fragments with transitive variable references", () =>
148 Effect.gen(function*() {
149 const generated = yield* generateTasks({
150 "src/literal.graphql": `
151 query Literal($taskId: ID! = "$taskId", $show: Boolean!) {
152 task(id: $taskId) { ...Wrapper }
153 literal: task(id: "$taskId") { id }
154 }
155 fragment Wrapper on Task { ...Details }
156 fragment Details on Task { title @include(if: $show) }
157 `
158 })
159 assertNoErrors(generated)
160 const { Literal } = yield* importGenerated(generated, "src/literal.graphql.ts")
161 assert(Literal.template !== undefined)
162 assert.strictEqual(
163 Literal.document,
164 "query Literal($taskId:ID!=\"$taskId\"$show:Boolean!){task(id:$taskId){...Wrapper}literal:task(id:\"$taskId\"){id}}fragment Wrapper on Task{...Details}fragment Details on Task{title@include(if:$show)}"
165 )
166 const text = renderSlices("query", "Literal", Literal.template, ["_0_", "_1_"])
167 assert.strictEqual(
168 text,
169 "query Literal($_0_taskId:ID!=\"$taskId\"$_0_show:Boolean!$_1_taskId:ID!=\"$taskId\"$_1_show:Boolean!){_0_task:task(id:$_0_taskId){..._0_Wrapper}_0_literal:task(id:\"$taskId\"){id}_1_task:task(id:$_1_taskId){..._1_Wrapper}_1_literal:task(id:\"$taskId\"){id}}fragment _0_Wrapper on Task{..._0_Details}fragment _1_Wrapper on Task{..._1_Details}fragment _0_Details on Task{title@include(if:$_0_show)}fragment _1_Details on Task{title@include(if:$_1_show)}"
170 )
171 assert.deepStrictEqual(
172 Validate.validate(readSdl(taskSchemaSdl), [{ source: source(text), document: parseOrThrow(text) }])
173 .map(({ message }) => message),
174 []
175 )
176 }).pipe(Effect.provide(NodeServices.layer)))
177 })