+5

.changeset/orange-dryers-count.md

··· 1 1 + --- 2 2 + '@0no-co/graphql.web': patch 3 3 + --- 4 4 + 5 5 + Move over unit tests from `graphql-web-lite` and fix minor discrepancies to reference implementation.

+371 -1

src/__tests__/parser.test.ts

··· 2 2 import { readFileSync } from 'fs'; 3 3 4 4 import { parse as graphql_parse } from 'graphql'; 5 5 - import { parse } from '../parser'; 5 5 + import { parse, parseType, parseValue } from '../parser'; 6 6 + import { Kind } from '../kind'; 6 7 7 8 describe('print', () => { 8 9 it('prints the kitchen sink document like graphql.js does', () => { ··· 12 13 const doc = parse(sink); 13 14 expect(doc).toMatchSnapshot(); 14 15 expect(doc).toEqual(graphql_parse(sink, { noLocation: true })); 16 16 + }); 17 17 + 18 18 + it('parse provides errors', () => { 19 19 + expect(() => parse('{')).toThrow(); 20 20 + }); 21 21 + 22 22 + it('parses variable inline values', () => { 23 23 + expect(() => { 24 24 + return parse('{ field(complex: { a: { b: [ $var ] } }) }'); 25 25 + }).not.toThrow(); 26 26 + }); 27 27 + 28 28 + it('parses constant default values', () => { 29 29 + expect(() => { 30 30 + return parse('query Foo($x: Complex = { a: { b: [ "test" ] } }) { field }'); 31 31 + }).not.toThrow(); 32 32 + expect(() => { 33 33 + return parse('query Foo($x: Complex = { a: { b: [ $var ] } }) { field }'); 34 34 + }).toThrow(); 35 35 + }); 36 36 + 37 37 + it('parses variable definition directives', () => { 38 38 + expect(() => { 39 39 + return parse('query Foo($x: Boolean = false @bar) { field }'); 40 40 + }).not.toThrow(); 41 41 + }); 42 42 + 43 43 + it('does not accept fragments spread of "on"', () => { 44 44 + expect(() => { 45 45 + return parse('{ ...on }'); 46 46 + }).toThrow(); 47 47 + }); 48 48 + 49 49 + it('parses multi-byte characters', () => { 50 50 + // Note: \u0A0A could be naively interpreted as two line-feed chars. 51 51 + const ast = parse(` 52 52 + # This comment has a \u0A0A multi-byte character. 53 53 + { field(arg: "Has a \u0A0A multi-byte character.") } 54 54 + `); 55 55 + 56 56 + expect(ast).toHaveProperty( 57 57 + 'definitions.0.selectionSet.selections.0.arguments.0.value.value', 58 58 + 'Has a \u0A0A multi-byte character.' 59 59 + ); 60 60 + }); 61 61 + 62 62 + it('parses anonymous mutation operations', () => { 63 63 + expect(() => { 64 64 + return parse(` 65 65 + mutation { 66 66 + mutationField 67 67 + } 68 68 + `); 69 69 + }).not.toThrow(); 70 70 + }); 71 71 + 72 72 + it('parses anonymous subscription operations', () => { 73 73 + expect(() => { 74 74 + return parse(` 75 75 + subscription { 76 76 + subscriptionField 77 77 + } 78 78 + `); 79 79 + }).not.toThrow(); 80 80 + }); 81 81 + 82 82 + it('parses named mutation operations', () => { 83 83 + expect(() => { 84 84 + return parse(` 85 85 + mutation Foo { 86 86 + mutationField 87 87 + } 88 88 + `); 89 89 + }).not.toThrow(); 90 90 + }); 91 91 + 92 92 + it('parses named subscription operations', () => { 93 93 + expect(() => { 94 94 + return parse(` 95 95 + subscription Foo { 96 96 + subscriptionField 97 97 + } 98 98 + `); 99 99 + }).not.toThrow(); 100 100 + }); 101 101 + 102 102 + it('creates ast', () => { 103 103 + const result = parse(` 104 104 + { 105 105 + node(id: 4) { 106 106 + id, 107 107 + name 108 108 + } 109 109 + } 110 110 + `); 111 111 + 112 112 + expect(result).toMatchObject({ 113 113 + kind: Kind.DOCUMENT, 114 114 + definitions: [ 115 115 + { 116 116 + kind: Kind.OPERATION_DEFINITION, 117 117 + operation: 'query', 118 118 + name: undefined, 119 119 + variableDefinitions: [], 120 120 + directives: [], 121 121 + selectionSet: { 122 122 + kind: Kind.SELECTION_SET, 123 123 + selections: [ 124 124 + { 125 125 + kind: Kind.FIELD, 126 126 + alias: undefined, 127 127 + name: { 128 128 + kind: Kind.NAME, 129 129 + value: 'node', 130 130 + }, 131 131 + arguments: [ 132 132 + { 133 133 + kind: Kind.ARGUMENT, 134 134 + name: { 135 135 + kind: Kind.NAME, 136 136 + value: 'id', 137 137 + }, 138 138 + value: { 139 139 + kind: Kind.INT, 140 140 + value: '4', 141 141 + }, 142 142 + }, 143 143 + ], 144 144 + directives: [], 145 145 + selectionSet: { 146 146 + kind: Kind.SELECTION_SET, 147 147 + selections: [ 148 148 + { 149 149 + kind: Kind.FIELD, 150 150 + alias: undefined, 151 151 + name: { 152 152 + kind: Kind.NAME, 153 153 + value: 'id', 154 154 + }, 155 155 + arguments: [], 156 156 + directives: [], 157 157 + selectionSet: undefined, 158 158 + }, 159 159 + { 160 160 + kind: Kind.FIELD, 161 161 + alias: undefined, 162 162 + name: { 163 163 + kind: Kind.NAME, 164 164 + value: 'name', 165 165 + }, 166 166 + arguments: [], 167 167 + directives: [], 168 168 + selectionSet: undefined, 169 169 + }, 170 170 + ], 171 171 + }, 172 172 + }, 173 173 + ], 174 174 + }, 175 175 + }, 176 176 + ], 177 177 + }); 178 178 + }); 179 179 + 180 180 + it('creates ast from nameless query without variables', () => { 181 181 + const result = parse(` 182 182 + query { 183 183 + node { 184 184 + id 185 185 + } 186 186 + } 187 187 + `); 188 188 + 189 189 + expect(result).toMatchObject({ 190 190 + kind: Kind.DOCUMENT, 191 191 + definitions: [ 192 192 + { 193 193 + kind: Kind.OPERATION_DEFINITION, 194 194 + operation: 'query', 195 195 + name: undefined, 196 196 + variableDefinitions: [], 197 197 + directives: [], 198 198 + selectionSet: { 199 199 + kind: Kind.SELECTION_SET, 200 200 + selections: [ 201 201 + { 202 202 + kind: Kind.FIELD, 203 203 + alias: undefined, 204 204 + name: { 205 205 + kind: Kind.NAME, 206 206 + value: 'node', 207 207 + }, 208 208 + arguments: [], 209 209 + directives: [], 210 210 + selectionSet: { 211 211 + kind: Kind.SELECTION_SET, 212 212 + selections: [ 213 213 + { 214 214 + kind: Kind.FIELD, 215 215 + alias: undefined, 216 216 + name: { 217 217 + kind: Kind.NAME, 218 218 + value: 'id', 219 219 + }, 220 220 + arguments: [], 221 221 + directives: [], 222 222 + selectionSet: undefined, 223 223 + }, 224 224 + ], 225 225 + }, 226 226 + }, 227 227 + ], 228 228 + }, 229 229 + }, 230 230 + ], 231 231 + }); 232 232 + }); 233 233 + 234 234 + it('allows parsing without source location information', () => { 235 235 + const result = parse('{ id }', { noLocation: true }); 236 236 + expect('loc' in result).toBe(false); 237 237 + }); 238 238 + 239 239 + describe('parseValue', () => { 240 240 + it('parses null value', () => { 241 241 + const result = parseValue('null'); 242 242 + expect(result).toEqual({ kind: Kind.NULL }); 243 243 + }); 244 244 + 245 245 + it('parses list values', () => { 246 246 + const result = parseValue('[123 "abc"]'); 247 247 + expect(result).toEqual({ 248 248 + kind: Kind.LIST, 249 249 + values: [ 250 250 + { 251 251 + kind: Kind.INT, 252 252 + value: '123', 253 253 + }, 254 254 + { 255 255 + kind: Kind.STRING, 256 256 + value: 'abc', 257 257 + block: false, 258 258 + }, 259 259 + ], 260 260 + }); 261 261 + }); 262 262 + 263 263 + it('parses block strings', () => { 264 264 + const result = parseValue('["""long""" "short"]'); 265 265 + expect(result).toEqual({ 266 266 + kind: Kind.LIST, 267 267 + values: [ 268 268 + { 269 269 + kind: Kind.STRING, 270 270 + value: 'long', 271 271 + block: true, 272 272 + }, 273 273 + { 274 274 + kind: Kind.STRING, 275 275 + value: 'short', 276 276 + block: false, 277 277 + }, 278 278 + ], 279 279 + }); 280 280 + }); 281 281 + 282 282 + it('allows variables', () => { 283 283 + const result = parseValue('{ field: $var }'); 284 284 + expect(result).toEqual({ 285 285 + kind: Kind.OBJECT, 286 286 + fields: [ 287 287 + { 288 288 + kind: Kind.OBJECT_FIELD, 289 289 + name: { 290 290 + kind: Kind.NAME, 291 291 + value: 'field', 292 292 + }, 293 293 + value: { 294 294 + kind: Kind.VARIABLE, 295 295 + name: { 296 296 + kind: Kind.NAME, 297 297 + value: 'var', 298 298 + }, 299 299 + }, 300 300 + }, 301 301 + ], 302 302 + }); 303 303 + }); 304 304 + 305 305 + it('correct message for incomplete variable', () => { 306 306 + expect(() => { 307 307 + return parseValue('$'); 308 308 + }).toThrow(); 309 309 + }); 310 310 + 311 311 + it('correct message for unexpected token', () => { 312 312 + expect(() => { 313 313 + return parseValue(':'); 314 314 + }).toThrow(); 315 315 + }); 316 316 + }); 317 317 + 318 318 + describe('parseType', () => { 319 319 + it('parses well known types', () => { 320 320 + const result = parseType('String'); 321 321 + expect(result).toEqual({ 322 322 + kind: Kind.NAMED_TYPE, 323 323 + name: { 324 324 + kind: Kind.NAME, 325 325 + value: 'String', 326 326 + }, 327 327 + }); 328 328 + }); 329 329 + 330 330 + it('parses custom types', () => { 331 331 + const result = parseType('MyType'); 332 332 + expect(result).toEqual({ 333 333 + kind: Kind.NAMED_TYPE, 334 334 + name: { 335 335 + kind: Kind.NAME, 336 336 + value: 'MyType', 337 337 + }, 338 338 + }); 339 339 + }); 340 340 + 341 341 + it('parses list types', () => { 342 342 + const result = parseType('[MyType]'); 343 343 + expect(result).toEqual({ 344 344 + kind: Kind.LIST_TYPE, 345 345 + type: { 346 346 + kind: Kind.NAMED_TYPE, 347 347 + name: { 348 348 + kind: Kind.NAME, 349 349 + value: 'MyType', 350 350 + }, 351 351 + }, 352 352 + }); 353 353 + }); 354 354 + 355 355 + it('parses non-null types', () => { 356 356 + const result = parseType('MyType!'); 357 357 + expect(result).toEqual({ 358 358 + kind: Kind.NON_NULL_TYPE, 359 359 + type: { 360 360 + kind: Kind.NAMED_TYPE, 361 361 + name: { 362 362 + kind: Kind.NAME, 363 363 + value: 'MyType', 364 364 + }, 365 365 + }, 366 366 + }); 367 367 + }); 368 368 + 369 369 + it('parses nested types', () => { 370 370 + const result = parseType('[MyType!]'); 371 371 + expect(result).toEqual({ 372 372 + kind: Kind.LIST_TYPE, 373 373 + type: { 374 374 + kind: Kind.NON_NULL_TYPE, 375 375 + type: { 376 376 + kind: Kind.NAMED_TYPE, 377 377 + name: { 378 378 + kind: Kind.NAME, 379 379 + value: 'MyType', 380 380 + }, 381 381 + }, 382 382 + }, 383 383 + }); 384 384 + }); 15 385 }); 16 386 });

+96 -1

src/__tests__/printer.test.ts

··· 1 1 import { describe, it, expect } from 'vitest'; 2 2 import { readFileSync } from 'fs'; 3 3 4 4 - import { print as graphql_print } from 'graphql'; 4 4 + import { parse, print as graphql_print } from 'graphql'; 5 5 import { print } from '../printer'; 6 6 7 7 + function dedentString(string) { 8 8 + const trimmedStr = string 9 9 + .replace(/^\n*/m, '') // remove leading newline 10 10 + .replace(/[ \t\n]*$/, ''); // remove trailing spaces and tabs 11 11 + // fixes indentation by removing leading spaces and tabs from each line 12 12 + let indent = ''; 13 13 + for (const char of trimmedStr) { 14 14 + if (char !== ' ' && char !== '\t') { 15 15 + break; 16 16 + } 17 17 + indent += char; 18 18 + } 19 19 + 20 20 + return trimmedStr.replace(RegExp('^' + indent, 'mg'), ''); // remove indent 21 21 + } 22 22 + 23 23 + function dedent(strings, ...values) { 24 24 + let str = strings[0]; 25 25 + for (let i = 1; i < strings.length; ++i) str += values[i - 1] + strings[i]; // interpolation 26 26 + return dedentString(str); 27 27 + } 28 28 + 7 29 describe('print', () => { 8 30 it('prints the kitchen sink document like graphql.js does', () => { 9 31 const sink = JSON.parse(readFileSync(__dirname + '/kitchen_sink.json', { encoding: 'utf8' })); 10 32 const doc = print(sink); 11 33 expect(doc).toMatchSnapshot(); 12 34 expect(doc).toEqual(graphql_print(sink)); 35 35 + }); 36 36 + 37 37 + it('prints minimal ast', () => { 38 38 + const ast = { 39 39 + kind: 'Field', 40 40 + name: { kind: 'Name', value: 'foo' }, 41 41 + }; 42 42 + expect(print(ast as any)).toBe('foo'); 43 43 + }); 44 44 + 45 45 + // NOTE: The shim won't throw for invalid AST nodes 46 46 + it('returns empty strings for invalid AST', () => { 47 47 + const badAST = { random: 'Data' }; 48 48 + expect(print(badAST as any)).toBe(''); 49 49 + }); 50 50 + 51 51 + it('correctly prints non-query operations without name', () => { 52 52 + const queryASTShorthanded = parse('query { id, name }'); 53 53 + expect(print(queryASTShorthanded)).toBe(dedent` 54 54 + { 55 55 + id 56 56 + name 57 57 + } 58 58 + `); 59 59 + 60 60 + const mutationAST = parse('mutation { id, name }'); 61 61 + expect(print(mutationAST)).toBe(dedent` 62 62 + mutation { 63 63 + id 64 64 + name 65 65 + } 66 66 + `); 67 67 + 68 68 + const queryASTWithArtifacts = parse('query ($foo: TestType) @testDirective { id, name }'); 69 69 + expect(print(queryASTWithArtifacts)).toBe(dedent` 70 70 + query ($foo: TestType) @testDirective { 71 71 + id 72 72 + name 73 73 + } 74 74 + `); 75 75 + 76 76 + const mutationASTWithArtifacts = parse('mutation ($foo: TestType) @testDirective { id, name }'); 77 77 + expect(print(mutationASTWithArtifacts)).toBe(dedent` 78 78 + mutation ($foo: TestType) @testDirective { 79 79 + id 80 80 + name 81 81 + } 82 82 + `); 83 83 + }); 84 84 + 85 85 + it('prints query with variable directives', () => { 86 86 + const queryASTWithVariableDirective = parse( 87 87 + 'query ($foo: TestType = {a: 123} @testDirective(if: true) @test) { id }' 88 88 + ); 89 89 + expect(print(queryASTWithVariableDirective)).toBe(dedent` 90 90 + query ($foo: TestType = {a: 123} @testDirective(if: true) @test) { 91 91 + id 92 92 + } 93 93 + `); 94 94 + }); 95 95 + 96 96 + it('keeps arguments on one line if line is short (<= 80 chars)', () => { 97 97 + const printed = print(parse('{trip(wheelchair:false arriveBy:false){dateTime}}')); 98 98 + 99 99 + expect(printed).toBe( 100 100 + dedent` 101 101 + { 102 102 + trip(wheelchair: false, arriveBy: false) { 103 103 + dateTime 104 104 + } 105 105 + } 106 106 + ` 107 107 + ); 13 108 }); 14 109 });

+437

src/__tests__/visitor.test.ts

··· 1 1 + import { describe, it, expect } from 'vitest'; 2 2 + import { Kind, parse, print } from 'graphql'; 3 3 + import { visit, BREAK } from '../visitor'; 4 4 + 5 5 + function checkVisitorFnArgs(ast, args, isEdited = false) { 6 6 + const [node, key, parent, path, ancestors] = args; 7 7 + 8 8 + expect(node).toBeInstanceOf(Object); 9 9 + expect(Object.values(Kind)).toContain(node.kind); 10 10 + 11 11 + const isRoot = key === undefined; 12 12 + if (isRoot) { 13 13 + if (!isEdited) { 14 14 + expect(node).toEqual(ast); 15 15 + } 16 16 + expect(parent).toEqual(undefined); 17 17 + expect(path).toEqual([]); 18 18 + expect(ancestors).toEqual([]); 19 19 + return; 20 20 + } 21 21 + 22 22 + expect(typeof key).toMatch(/number|string/); 23 23 + 24 24 + expect(parent).toHaveProperty([key]); 25 25 + 26 26 + expect(path).toBeInstanceOf(Array); 27 27 + expect(path[path.length - 1]).toEqual(key); 28 28 + 29 29 + expect(ancestors).toBeInstanceOf(Array); 30 30 + expect(ancestors.length).toEqual(path.length - 1); 31 31 + 32 32 + if (!isEdited) { 33 33 + let currentNode = ast; 34 34 + for (let i = 0; i < ancestors.length; ++i) { 35 35 + expect(ancestors[i]).toEqual(currentNode); 36 36 + 37 37 + currentNode = currentNode[path[i]]; 38 38 + expect(currentNode).not.toEqual(undefined); 39 39 + } 40 40 + } 41 41 + } 42 42 + 43 43 + function getValue(node: any) { 44 44 + return 'value' in node ? node.value : undefined; 45 45 + } 46 46 + 47 47 + describe('Visitor', () => { 48 48 + it('handles empty visitor', () => { 49 49 + const ast = parse('{ a }', { noLocation: true }); 50 50 + expect(() => visit(ast, {})).not.toThrow(); 51 51 + }); 52 52 + 53 53 + it('validates path argument', () => { 54 54 + const visited: any[] = []; 55 55 + 56 56 + const ast = parse('{ a }', { noLocation: true }); 57 57 + 58 58 + visit(ast, { 59 59 + enter(_node, _key, _parent, path) { 60 60 + checkVisitorFnArgs(ast, arguments); 61 61 + visited.push(['enter', path.slice()]); 62 62 + }, 63 63 + leave(_node, _key, _parent, path) { 64 64 + checkVisitorFnArgs(ast, arguments); 65 65 + visited.push(['leave', path.slice()]); 66 66 + }, 67 67 + }); 68 68 + 69 69 + expect(visited).toEqual([ 70 70 + ['enter', []], 71 71 + ['enter', ['definitions', 0]], 72 72 + ['enter', ['definitions', 0, 'selectionSet']], 73 73 + ['enter', ['definitions', 0, 'selectionSet', 'selections', 0]], 74 74 + ['enter', ['definitions', 0, 'selectionSet', 'selections', 0, 'name']], 75 75 + ['leave', ['definitions', 0, 'selectionSet', 'selections', 0, 'name']], 76 76 + ['leave', ['definitions', 0, 'selectionSet', 'selections', 0]], 77 77 + ['leave', ['definitions', 0, 'selectionSet']], 78 78 + ['leave', ['definitions', 0]], 79 79 + ['leave', []], 80 80 + ]); 81 81 + }); 82 82 + 83 83 + it('validates ancestors argument', () => { 84 84 + const ast = parse('{ a }', { noLocation: true }); 85 85 + const visitedNodes: any[] = []; 86 86 + 87 87 + visit(ast, { 88 88 + enter(node, key, parent, _path, ancestors) { 89 89 + const inArray = typeof key === 'number'; 90 90 + if (inArray) { 91 91 + visitedNodes.push(parent); 92 92 + } 93 93 + visitedNodes.push(node); 94 94 + 95 95 + const expectedAncestors = visitedNodes.slice(0, -2); 96 96 + expect(ancestors).toEqual(expectedAncestors); 97 97 + }, 98 98 + leave(_node, key, _parent, _path, ancestors) { 99 99 + const expectedAncestors = visitedNodes.slice(0, -2); 100 100 + expect(ancestors).toEqual(expectedAncestors); 101 101 + 102 102 + const inArray = typeof key === 'number'; 103 103 + if (inArray) { 104 104 + visitedNodes.pop(); 105 105 + } 106 106 + visitedNodes.pop(); 107 107 + }, 108 108 + }); 109 109 + }); 110 110 + 111 111 + it('allows editing a node both on enter and on leave', () => { 112 112 + const ast = parse('{ a, b, c { a, b, c } }', { noLocation: true }); 113 113 + 114 114 + let selectionSet; 115 115 + 116 116 + const editedAST = visit(ast, { 117 117 + OperationDefinition: { 118 118 + enter(node) { 119 119 + checkVisitorFnArgs(ast, arguments); 120 120 + selectionSet = node.selectionSet; 121 121 + return { 122 122 + ...node, 123 123 + selectionSet: { 124 124 + kind: 'SelectionSet', 125 125 + selections: [], 126 126 + }, 127 127 + didEnter: true, 128 128 + }; 129 129 + }, 130 130 + leave(node) { 131 131 + checkVisitorFnArgs(ast, arguments, /* isEdited */ true); 132 132 + return { 133 133 + ...node, 134 134 + selectionSet, 135 135 + didLeave: true, 136 136 + }; 137 137 + }, 138 138 + }, 139 139 + }); 140 140 + 141 141 + expect(editedAST).toEqual({ 142 142 + ...ast, 143 143 + definitions: [ 144 144 + { 145 145 + ...ast.definitions[0], 146 146 + didEnter: true, 147 147 + didLeave: true, 148 148 + }, 149 149 + ], 150 150 + }); 151 151 + }); 152 152 + 153 153 + it('allows editing the root node on enter and on leave', () => { 154 154 + const ast = parse('{ a, b, c { a, b, c } }', { noLocation: true }); 155 155 + 156 156 + const { definitions } = ast; 157 157 + 158 158 + const editedAST = visit(ast, { 159 159 + Document: { 160 160 + enter(node) { 161 161 + checkVisitorFnArgs(ast, arguments); 162 162 + return { 163 163 + ...node, 164 164 + definitions: [], 165 165 + didEnter: true, 166 166 + }; 167 167 + }, 168 168 + leave(node) { 169 169 + checkVisitorFnArgs(ast, arguments, /* isEdited */ true); 170 170 + return { 171 171 + ...node, 172 172 + definitions, 173 173 + didLeave: true, 174 174 + }; 175 175 + }, 176 176 + }, 177 177 + }); 178 178 + 179 179 + expect(editedAST).toEqual({ 180 180 + ...ast, 181 181 + didEnter: true, 182 182 + didLeave: true, 183 183 + }); 184 184 + }); 185 185 + 186 186 + it('allows for editing on enter', () => { 187 187 + const ast = parse('{ a, b, c { a, b, c } }', { noLocation: true }); 188 188 + const editedAST = visit(ast, { 189 189 + enter(node) { 190 190 + checkVisitorFnArgs(ast, arguments); 191 191 + if (node.kind === 'Field' && node.name.value === 'b') { 192 192 + return null; 193 193 + } 194 194 + }, 195 195 + }); 196 196 + 197 197 + expect(ast).toEqual(parse('{ a, b, c { a, b, c } }', { noLocation: true })); 198 198 + 199 199 + expect(editedAST).toEqual(parse('{ a, c { a, c } }', { noLocation: true })); 200 200 + }); 201 201 + 202 202 + it('allows for editing on leave', () => { 203 203 + const ast = parse('{ a, b, c { a, b, c } }', { noLocation: true }); 204 204 + const editedAST = visit(ast, { 205 205 + leave(node) { 206 206 + checkVisitorFnArgs(ast, arguments, /* isEdited */ true); 207 207 + if (node.kind === 'Field' && node.name.value === 'b') { 208 208 + return null; 209 209 + } 210 210 + }, 211 211 + }); 212 212 + 213 213 + expect(ast).toEqual(parse('{ a, b, c { a, b, c } }', { noLocation: true })); 214 214 + 215 215 + expect(editedAST).toEqual(parse('{ a, c { a, c } }', { noLocation: true })); 216 216 + }); 217 217 + 218 218 + it('ignores false returned on leave', () => { 219 219 + const ast = parse('{ a, b, c { a, b, c } }', { noLocation: true }); 220 220 + const returnedAST = visit(ast, { 221 221 + leave() { 222 222 + return false; 223 223 + }, 224 224 + }); 225 225 + 226 226 + expect(returnedAST).toEqual(parse('{ a, b, c { a, b, c } }', { noLocation: true })); 227 227 + }); 228 228 + 229 229 + it('visits edited node', () => { 230 230 + const addedField = { 231 231 + kind: 'Field', 232 232 + name: { 233 233 + kind: 'Name', 234 234 + value: '__typename', 235 235 + }, 236 236 + }; 237 237 + 238 238 + let didVisitAddedField; 239 239 + 240 240 + const ast = parse('{ a { x } }', { noLocation: true }); 241 241 + visit(ast, { 242 242 + enter(node) { 243 243 + checkVisitorFnArgs(ast, arguments, /* isEdited */ true); 244 244 + if (node.kind === 'Field' && node.name.value === 'a') { 245 245 + return { 246 246 + kind: 'Field', 247 247 + selectionSet: [addedField, node.selectionSet], 248 248 + }; 249 249 + } 250 250 + if (node === addedField) { 251 251 + didVisitAddedField = true; 252 252 + } 253 253 + }, 254 254 + }); 255 255 + 256 256 + expect(didVisitAddedField).toEqual(true); 257 257 + }); 258 258 + 259 259 + it('allows skipping a sub-tree', () => { 260 260 + const visited: any[] = []; 261 261 + 262 262 + const ast = parse('{ a, b { x }, c }', { noLocation: true }); 263 263 + visit(ast, { 264 264 + enter(node) { 265 265 + checkVisitorFnArgs(ast, arguments); 266 266 + visited.push(['enter', node.kind, getValue(node)]); 267 267 + if (node.kind === 'Field' && node.name.value === 'b') { 268 268 + return false; 269 269 + } 270 270 + }, 271 271 + 272 272 + leave(node) { 273 273 + checkVisitorFnArgs(ast, arguments); 274 274 + visited.push(['leave', node.kind, getValue(node)]); 275 275 + }, 276 276 + }); 277 277 + 278 278 + expect(visited).toEqual([ 279 279 + ['enter', 'Document', undefined], 280 280 + ['enter', 'OperationDefinition', undefined], 281 281 + ['enter', 'SelectionSet', undefined], 282 282 + ['enter', 'Field', undefined], 283 283 + ['enter', 'Name', 'a'], 284 284 + ['leave', 'Name', 'a'], 285 285 + ['leave', 'Field', undefined], 286 286 + ['enter', 'Field', undefined], 287 287 + ['enter', 'Field', undefined], 288 288 + ['enter', 'Name', 'c'], 289 289 + ['leave', 'Name', 'c'], 290 290 + ['leave', 'Field', undefined], 291 291 + ['leave', 'SelectionSet', undefined], 292 292 + ['leave', 'OperationDefinition', undefined], 293 293 + ['leave', 'Document', undefined], 294 294 + ]); 295 295 + }); 296 296 + 297 297 + it('allows early exit while visiting', () => { 298 298 + const visited: any[] = []; 299 299 + 300 300 + const ast = parse('{ a, b { x }, c }', { noLocation: true }); 301 301 + visit(ast, { 302 302 + enter(node) { 303 303 + checkVisitorFnArgs(ast, arguments); 304 304 + visited.push(['enter', node.kind, getValue(node)]); 305 305 + if (node.kind === 'Name' && node.value === 'x') { 306 306 + return BREAK; 307 307 + } 308 308 + }, 309 309 + leave(node) { 310 310 + checkVisitorFnArgs(ast, arguments); 311 311 + visited.push(['leave', node.kind, getValue(node)]); 312 312 + }, 313 313 + }); 314 314 + 315 315 + expect(visited).toEqual([ 316 316 + ['enter', 'Document', undefined], 317 317 + ['enter', 'OperationDefinition', undefined], 318 318 + ['enter', 'SelectionSet', undefined], 319 319 + ['enter', 'Field', undefined], 320 320 + ['enter', 'Name', 'a'], 321 321 + ['leave', 'Name', 'a'], 322 322 + ['leave', 'Field', undefined], 323 323 + ['enter', 'Field', undefined], 324 324 + ['enter', 'Name', 'b'], 325 325 + ['leave', 'Name', 'b'], 326 326 + ['enter', 'SelectionSet', undefined], 327 327 + ['enter', 'Field', undefined], 328 328 + ['enter', 'Name', 'x'], 329 329 + ]); 330 330 + }); 331 331 + 332 332 + it('allows early exit while leaving', () => { 333 333 + const visited: any[] = []; 334 334 + 335 335 + const ast = parse('{ a, b { x }, c }', { noLocation: true }); 336 336 + visit(ast, { 337 337 + enter(node) { 338 338 + checkVisitorFnArgs(ast, arguments); 339 339 + visited.push(['enter', node.kind, getValue(node)]); 340 340 + }, 341 341 + 342 342 + leave(node) { 343 343 + checkVisitorFnArgs(ast, arguments); 344 344 + visited.push(['leave', node.kind, getValue(node)]); 345 345 + if (node.kind === 'Name' && node.value === 'x') { 346 346 + return BREAK; 347 347 + } 348 348 + }, 349 349 + }); 350 350 + 351 351 + expect(visited).toEqual([ 352 352 + ['enter', 'Document', undefined], 353 353 + ['enter', 'OperationDefinition', undefined], 354 354 + ['enter', 'SelectionSet', undefined], 355 355 + ['enter', 'Field', undefined], 356 356 + ['enter', 'Name', 'a'], 357 357 + ['leave', 'Name', 'a'], 358 358 + ['leave', 'Field', undefined], 359 359 + ['enter', 'Field', undefined], 360 360 + ['enter', 'Name', 'b'], 361 361 + ['leave', 'Name', 'b'], 362 362 + ['enter', 'SelectionSet', undefined], 363 363 + ['enter', 'Field', undefined], 364 364 + ['enter', 'Name', 'x'], 365 365 + ['leave', 'Name', 'x'], 366 366 + ]); 367 367 + }); 368 368 + 369 369 + it('allows a named functions visitor API', () => { 370 370 + const visited: any[] = []; 371 371 + 372 372 + const ast = parse('{ a, b { x }, c }', { noLocation: true }); 373 373 + visit(ast, { 374 374 + Name(node) { 375 375 + checkVisitorFnArgs(ast, arguments); 376 376 + visited.push(['enter', node.kind, getValue(node)]); 377 377 + }, 378 378 + SelectionSet: { 379 379 + enter(node) { 380 380 + checkVisitorFnArgs(ast, arguments); 381 381 + visited.push(['enter', node.kind, getValue(node)]); 382 382 + }, 383 383 + leave(node) { 384 384 + checkVisitorFnArgs(ast, arguments); 385 385 + visited.push(['leave', node.kind, getValue(node)]); 386 386 + }, 387 387 + }, 388 388 + }); 389 389 + 390 390 + expect(visited).toEqual([ 391 391 + ['enter', 'SelectionSet', undefined], 392 392 + ['enter', 'Name', 'a'], 393 393 + ['enter', 'Name', 'b'], 394 394 + ['enter', 'SelectionSet', undefined], 395 395 + ['enter', 'Name', 'x'], 396 396 + ['leave', 'SelectionSet', undefined], 397 397 + ['enter', 'Name', 'c'], 398 398 + ['leave', 'SelectionSet', undefined], 399 399 + ]); 400 400 + }); 401 401 + 402 402 + it('handles deep immutable edits correctly when using "enter"', () => { 403 403 + const formatNode = node => { 404 404 + if ( 405 405 + node.selectionSet && 406 406 + !node.selectionSet.selections.some( 407 407 + node => node.kind === Kind.FIELD && node.name.value === '__typename' && !node.alias 408 408 + ) 409 409 + ) { 410 410 + return { 411 411 + ...node, 412 412 + selectionSet: { 413 413 + ...node.selectionSet, 414 414 + selections: [ 415 415 + ...node.selectionSet.selections, 416 416 + { 417 417 + kind: Kind.FIELD, 418 418 + name: { 419 419 + kind: Kind.NAME, 420 420 + value: '__typename', 421 421 + }, 422 422 + }, 423 423 + ], 424 424 + }, 425 425 + }; 426 426 + } 427 427 + }; 428 428 + const ast = parse('{ players { nodes { id } } }'); 429 429 + const expected = parse('{ players { nodes { id __typename } __typename } }'); 430 430 + const visited = visit(ast, { 431 431 + Field: formatNode, 432 432 + InlineFragment: formatNode, 433 433 + }); 434 434 + 435 435 + expect(print(visited)).toEqual(print(expected)); 436 436 + }); 437 437 + });

+7

src/kind.js

··· 10 10 INLINE_FRAGMENT: 'InlineFragment', 11 11 FRAGMENT_DEFINITION: 'FragmentDefinition', 12 12 VARIABLE: 'Variable', 13 13 + INT: 'IntValue', 14 14 + FLOAT: 'FloatValue', 15 15 + STRING: 'StringValue', 16 16 + BOOLEAN: 'BooleanValue', 17 17 + NULL: 'NullValue', 18 18 + ENUM: 'EnumValue', 19 19 + LIST: 'ListValue', 13 20 OBJECT: 'ObjectValue', 14 21 OBJECT_FIELD: 'ObjectField', 15 22 DIRECTIVE: 'Directive',

+2 -2

src/parser.ts

··· 26 26 27 27 const leadingRe = / +(?=[^\s])/y; 28 28 export function blockString(string: string) { 29 29 + const lines = string.split('\n'); 29 30 let out = ''; 30 31 let commonIndent = 0; 31 32 let firstNonEmptyLine = 0; 32 32 - let lastNonEmptyLine = -1; 33 33 - const lines = string.split('\n'); 33 33 + let lastNonEmptyLine = lines.length - 1; 34 34 for (let i = 0; i < lines.length; i++) { 35 35 leadingRe.lastIndex = 0; 36 36 if (leadingRe.test(lines[i])) {

+7 -2

src/visitor.ts

··· 16 16 ) { 17 17 let hasEdited = false; 18 18 19 19 - const enter = (visitor[node.kind] && visitor[node.kind].enter) || visitor[node.kind]; 19 19 + const enter = 20 20 + (visitor[node.kind] && visitor[node.kind].enter) || 21 21 + visitor[node.kind] || 22 22 + (visitor as EnterLeaveVisitor<ASTNode>).enter; 20 23 const resultEnter = enter && enter.call(visitor, node, key, parent, path, ancestors); 21 24 if (resultEnter === false) { 22 25 return node; ··· 69 72 } 70 73 71 74 if (parent) ancestors.pop(); 72 72 - const leave = visitor[node.kind] && visitor[node.kind].leave; 75 75 + const leave = 76 76 + (visitor[node.kind] && visitor[node.kind].leave) || 77 77 + (visitor as EnterLeaveVisitor<ASTNode>).leave; 73 78 const resultLeave = leave && leave.call(visitor, node, key, parent, path, ancestors); 74 79 if (resultLeave === BREAK) { 75 80 throw BREAK;