ether-code 0.1.6 → 0.1.7

package/parsers/graphql-parser.js

@@ -1,2011 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const AST = require('./ast-graphql')
-
-class EtherGraphQLParser {
-  constructor(i18nPath = null) {
-    this.i18n = null
-    this.keywordMap = {}
-    this.reverseKeywordMap = {}
-    this.tokens = []
-    this.pos = 0
-    this.indentStack = [0]
-    this.currentIndent = 0
-    
-    if (i18nPath) {
-      this.loadI18n(i18nPath)
-    }
-  }
-
-  loadI18n(filePath) {
-    const content = fs.readFileSync(filePath, 'utf-8')
-    this.i18n = JSON.parse(content)
-    this.buildKeywordMaps()
-  }
-
-  buildKeywordMaps() {
-    if (!this.i18n) return
-
-    const processSection = (section, category = null) => {
-      for (const [key, translations] of Object.entries(section)) {
-        if (typeof translations === 'object' && translations.fr) {
-          const graphqlValue = translations.graphql || key
-          for (const [lang, value] of Object.entries(translations)) {
-            if (lang !== 'graphql' && value) {
-              const mapKey = category ? `${category}.${value}` : value
-              this.keywordMap[value.toLowerCase()] = {
-                graphql: graphqlValue,
-                category: category,
-                key: key
-              }
-              if (!this.reverseKeywordMap[graphqlValue]) {
-                this.reverseKeywordMap[graphqlValue] = {}
-              }
-              this.reverseKeywordMap[graphqlValue][lang] = value
-            }
-          }
-        } else if (typeof translations === 'object') {
-          processSection(translations, key)
-        }
-      }
-    }
-
-    processSection(this.i18n.operations)
-    processSection(this.i18n.typeDefinitions)
-    processSection(this.i18n.keywords)
-    processSection(this.i18n.builtInScalars)
-    processSection(this.i18n.customScalars)
-    processSection(this.i18n.literals)
-    processSection(this.i18n.directives)
-    processSection(this.i18n.directiveArguments)
-    processSection(this.i18n.metaFields)
-    processSection(this.i18n.introspection)
-    processSection(this.i18n.commonFieldNames)
-    processSection(this.i18n.paginationArgs)
-    processSection(this.i18n.connectionTypes)
-  }
-
-  translateKeyword(word) {
-    const lower = word.toLowerCase()
-    if (this.keywordMap[lower]) {
-      return this.keywordMap[lower].graphql
-    }
-    return word
-  }
-
-  translateType(typeName) {
-    const typeMap = {
-      'texte': 'String',
-      'text': 'String',
-      'texto': 'String',
-      'текст': 'String',
-      '文本': 'String',
-      'テキスト': 'String',
-      'entier': 'Int',
-      'integer': 'Int',
-      'entero': 'Int',
-      'целое': 'Int',
-      '整数': 'Int',
-      'decimal': 'Float',
-      'float': 'Float',
-      'дробное': 'Float',
-      '浮点': 'Float',
-      '浮動小数点': 'Float',
-      'booleen': 'Boolean',
-      'booléen': 'Boolean',
-      'boolean': 'Boolean',
-      'booleano': 'Boolean',
-      'логический': 'Boolean',
-      '布尔': 'Boolean',
-      'ブール': 'Boolean',
-      'dateheure': 'DateTime',
-      'datetime': 'DateTime',
-      'fechahora': 'DateTime',
-      'датавремя': 'DateTime',
-      '日期时间': 'DateTime',
-      '日時': 'DateTime',
-      'date': 'Date',
-      'fecha': 'Date',
-      'дата': 'Date',
-      '日期': 'Date',
-      '日付': 'Date',
-      'heure': 'Time',
-      'time': 'Time',
-      'hora': 'Time',
-      'время': 'Time',
-      '时间': 'Time',
-      '時刻': 'Time'
-    }
-    const lower = typeName.toLowerCase()
-    return typeMap[lower] || typeName
-  }
-
-  tokenize(source) {
-    this.tokens = []
-    const lines = source.split('\n')
-    let lineNum = 0
-
-    for (const line of lines) {
-      lineNum++
-      const trimmed = line.trimEnd()
-      if (trimmed.length === 0) continue
-
-      const indent = line.length - line.trimStart().length
-      const content = line.trimStart()
-
-      if (content.startsWith('#')) continue
-
-      this.tokens.push({
-        type: 'LINE',
-        indent: indent,
-        content: content,
-        line: lineNum,
-        tokens: this.tokenizeLine(content)
-      })
-    }
-
-    return this.tokens
-  }
-
-  tokenizeLine(line) {
-    const tokens = []
-    let pos = 0
-
-    while (pos < line.length) {
-      if (/\s/.test(line[pos])) {
-        pos++
-        continue
-      }
-
-      if (line.substring(pos, pos + 3) === '...') {
-        tokens.push({ type: 'SPREAD', value: '...' })
-        pos += 3
-        continue
-      }
-
-      if (line.substring(pos, pos + 3) === '"""') {
-        const endPos = line.indexOf('"""', pos + 3)
-        if (endPos !== -1) {
-          tokens.push({ type: 'BLOCK_STRING', value: line.substring(pos + 3, endPos) })
-          pos = endPos + 3
-        } else {
-          tokens.push({ type: 'BLOCK_STRING_START', value: line.substring(pos + 3) })
-          pos = line.length
-        }
-        continue
-      }
-
-      if (line[pos] === '"' || line[pos] === "'") {
-        const quote = line[pos]
-        let str = ''
-        pos++
-        while (pos < line.length && line[pos] !== quote) {
-          if (line[pos] === '\\' && pos + 1 < line.length) {
-            pos++
-            switch (line[pos]) {
-              case 'n': str += '\n'; break
-              case 't': str += '\t'; break
-              case 'r': str += '\r'; break
-              case '\\': str += '\\'; break
-              case '"': str += '"'; break
-              case "'": str += "'"; break
-              default: str += line[pos]
-            }
-          } else {
-            str += line[pos]
-          }
-          pos++
-        }
-        pos++
-        tokens.push({ type: 'STRING', value: str })
-        continue
-      }
-
-      if (line[pos] === '@') {
-        let directive = '@'
-        pos++
-        while (pos < line.length && /[\w]/.test(line[pos])) {
-          directive += line[pos]
-          pos++
-        }
-        tokens.push({ type: 'DIRECTIVE', value: directive })
-        continue
-      }
-
-      if (line[pos] === ':') {
-        tokens.push({ type: 'COLON', value: ':' })
-        pos++
-        continue
-      }
-
-      if (line[pos] === '=') {
-        tokens.push({ type: 'EQUALS', value: '=' })
-        pos++
-        continue
-      }
-
-      if (line[pos] === ',') {
-        tokens.push({ type: 'COMMA', value: ',' })
-        pos++
-        continue
-      }
-
-      if (line[pos] === '!') {
-        tokens.push({ type: 'BANG', value: '!' })
-        pos++
-        continue
-      }
-
-      if (line[pos] === '|') {
-        tokens.push({ type: 'PIPE', value: '|' })
-        pos++
-        continue
-      }
-
-      if (line[pos] === '-' && line[pos + 1] === '>') {
-        tokens.push({ type: 'ARROW', value: '->' })
-        pos += 2
-        continue
-      }
-
-      if (/[-]?\d/.test(line[pos])) {
-        let num = ''
-        if (line[pos] === '-') {
-          num = '-'
-          pos++
-        }
-        while (pos < line.length && /[\d.]/.test(line[pos])) {
-          num += line[pos]
-          pos++
-        }
-        if (num.includes('.')) {
-          tokens.push({ type: 'FLOAT', value: parseFloat(num) })
-        } else {
-          tokens.push({ type: 'INT', value: parseInt(num, 10) })
-        }
-        continue
-      }
-
-      if (/[\w_\u00C0-\u024F\u0400-\u04FF\u4E00-\u9FFF\u3040-\u30FF]/.test(line[pos])) {
-        let ident = ''
-        while (pos < line.length && /[\w_\u00C0-\u024F\u0400-\u04FF\u4E00-\u9FFF\u3040-\u30FF]/.test(line[pos])) {
-          ident += line[pos]
-          pos++
-        }
-        tokens.push({ type: 'IDENTIFIER', value: ident })
-        continue
-      }
-
-      pos++
-    }
-
-    return tokens
-  }
-
-  parse(source) {
-    this.tokenize(source)
-    this.pos = 0
-    const definitions = []
-
-    while (this.pos < this.tokens.length) {
-      const def = this.parseDefinition()
-      if (def) {
-        definitions.push(def)
-      }
-    }
-
-    return new AST.DocumentNode(definitions)
-  }
-
-  currentLine() {
-    return this.tokens[this.pos] || null
-  }
-
-  advance() {
-    this.pos++
-  }
-
-  parseDefinition() {
-    const line = this.currentLine()
-    if (!line) return null
-
-    const firstToken = line.tokens[0]
-    if (!firstToken) {
-      this.advance()
-      return null
-    }
-
-    const keyword = this.translateKeyword(firstToken.value)
-
-    switch (keyword) {
-      case 'query':
-      case 'mutation':
-      case 'subscription':
-        return this.parseOperationDefinition(keyword)
-      case 'fragment':
-        return this.parseFragmentDefinition()
-      case 'type':
-        return this.parseObjectTypeDefinition()
-      case 'input':
-        return this.parseInputObjectTypeDefinition()
-      case 'interface':
-        return this.parseInterfaceTypeDefinition()
-      case 'union':
-        return this.parseUnionTypeDefinition()
-      case 'enum':
-        return this.parseEnumTypeDefinition()
-      case 'scalar':
-        return this.parseScalarTypeDefinition()
-      case 'schema':
-        return this.parseSchemaDefinition()
-      case 'directive':
-        return this.parseDirectiveDefinition()
-      case 'extend':
-        return this.parseTypeExtension()
-      default:
-        if (firstToken.type === 'STRING' || firstToken.type === 'BLOCK_STRING') {
-          return this.parseDefinitionWithDescription()
-        }
-        this.advance()
-        return null
-    }
-  }
-
-  parseDefinitionWithDescription() {
-    const line = this.currentLine()
-    const descToken = line.tokens[0]
-    const description = new AST.StringValueNode(
-      descToken.value,
-      descToken.type === 'BLOCK_STRING'
-    )
-    this.advance()
-    
-    const def = this.parseDefinition()
-    if (def) {
-      def.description = description
-    }
-    return def
-  }
-
-  parseOperationDefinition(operation) {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let variableDefinitions = []
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      const nextToken = line.tokens[tokenIdx + 1]
-      if (!nextToken || nextToken.type !== 'COLON' || 
-          (line.tokens[tokenIdx + 2] && this.translateKeyword(line.tokens[tokenIdx].value) !== 'with')) {
-        name = new AST.NameNode(line.tokens[tokenIdx].value)
-        tokenIdx++
-      }
-    }
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'with') {
-      tokenIdx++
-      variableDefinitions = this.parseVariableDefinitionsInline(line.tokens, tokenIdx)
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const selectionSet = this.parseSelectionSet(baseIndent)
-
-    return new AST.OperationDefinitionNode(
-      operation,
-      name,
-      variableDefinitions,
-      directives,
-      selectionSet
-    )
-  }
-
-  parseVariableDefinitionsInline(tokens, startIdx) {
-    const definitions = []
-    let idx = startIdx
-
-    while (idx < tokens.length) {
-      if (tokens[idx].type === 'DIRECTIVE') break
-
-      if (tokens[idx].type === 'IDENTIFIER') {
-        const varName = new AST.NameNode(tokens[idx].value)
-        idx++
-
-        if (tokens[idx] && tokens[idx].type === 'COLON') {
-          idx++
-        }
-
-        let type = null
-        let defaultValue = null
-
-        if (tokens[idx]) {
-          const typeResult = this.parseTypeInline(tokens, idx)
-          type = typeResult.type
-          idx = typeResult.nextIdx
-        }
-
-        if (tokens[idx] && tokens[idx].type === 'EQUALS') {
-          idx++
-          const valueResult = this.parseValueInline(tokens, idx)
-          defaultValue = valueResult.value
-          idx = valueResult.nextIdx
-        }
-
-        definitions.push(new AST.VariableDefinitionNode(
-          new AST.VariableNode(varName),
-          type,
-          defaultValue,
-          []
-        ))
-      }
-
-      if (tokens[idx] && tokens[idx].type === 'COMMA') {
-        idx++
-      } else {
-        break
-      }
-    }
-
-    return definitions
-  }
-
-  parseTypeInline(tokens, startIdx) {
-    let idx = startIdx
-    let isListNonNull = false
-    let isItemNonNull = false
-    let isList = false
-    let typeName = null
-
-    if (tokens[idx] && this.translateKeyword(tokens[idx].value) === '[]') {
-      isList = true
-      idx++
-    }
-
-    const listKeyword = tokens[idx] ? this.translateKeyword(tokens[idx].value) : null
-    if (listKeyword === 'list' || listKeyword === '[]') {
-      isList = true
-      idx++
-      if (tokens[idx] && tokens[idx].type === 'BANG') {
-        isListNonNull = true
-        idx++
-      }
-    }
-
-    if (tokens[idx] && tokens[idx].type === 'IDENTIFIER') {
-      typeName = this.translateType(tokens[idx].value)
-      idx++
-    }
-
-    if (tokens[idx] && tokens[idx].type === 'BANG') {
-      isItemNonNull = true
-      idx++
-    }
-
-    let type = new AST.NamedTypeNode(new AST.NameNode(typeName))
-
-    if (isItemNonNull) {
-      type = new AST.NonNullTypeNode(type)
-    }
-
-    if (isList) {
-      type = new AST.ListTypeNode(type)
-      if (isListNonNull) {
-        type = new AST.NonNullTypeNode(type)
-      }
-    }
-
-    return { type, nextIdx: idx }
-  }
-
-  parseValueInline(tokens, startIdx) {
-    let idx = startIdx
-    const token = tokens[idx]
-
-    if (!token) {
-      return { value: null, nextIdx: idx }
-    }
-
-    if (token.type === 'STRING') {
-      return { value: new AST.StringValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    if (token.type === 'INT') {
-      return { value: new AST.IntValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    if (token.type === 'FLOAT') {
-      return { value: new AST.FloatValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    if (token.type === 'IDENTIFIER') {
-      const translated = this.translateKeyword(token.value)
-      if (translated === 'true') {
-        return { value: new AST.BooleanValueNode(true), nextIdx: idx + 1 }
-      }
-      if (translated === 'false') {
-        return { value: new AST.BooleanValueNode(false), nextIdx: idx + 1 }
-      }
-      if (translated === 'null') {
-        return { value: new AST.NullValueNode(), nextIdx: idx + 1 }
-      }
-      return { value: new AST.EnumValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    return { value: null, nextIdx: idx + 1 }
-  }
-
-  parseDirectiveInline(tokens, startIdx) {
-    const directiveToken = tokens[startIdx]
-    const name = new AST.NameNode(this.translateKeyword(directiveToken.value.substring(1)))
-    const args = []
-    let idx = startIdx + 1
-
-    if (tokens[idx] && tokens[idx].type === 'COLON') {
-      idx++
-      while (idx < tokens.length) {
-        if (tokens[idx].type === 'DIRECTIVE') break
-
-        if (tokens[idx].type === 'IDENTIFIER') {
-          const argName = new AST.NameNode(this.translateKeyword(tokens[idx].value))
-          idx++
-
-          if (tokens[idx] && tokens[idx].type === 'EQUALS') {
-            idx++
-            const valueResult = this.parseValueInline(tokens, idx)
-            args.push(new AST.ArgumentNode(argName, valueResult.value))
-            idx = valueResult.nextIdx
-          }
-        }
-
-        if (tokens[idx] && tokens[idx].type === 'COMMA') {
-          idx++
-        } else {
-          break
-        }
-      }
-    }
-
-    return new AST.DirectiveNode(name, args)
-  }
-
-  parseSelectionSet(parentIndent) {
-    const selections = []
-
-    while (this.pos < this.tokens.length) {
-      const line = this.currentLine()
-      if (!line || line.indent <= parentIndent) break
-
-      const selection = this.parseSelection(line)
-      if (selection) {
-        selections.push(selection)
-      }
-    }
-
-    return new AST.SelectionSetNode(selections)
-  }
-
-  parseSelection(line) {
-    const firstToken = line.tokens[0]
-    if (!firstToken) {
-      this.advance()
-      return null
-    }
-
-    if (firstToken.type === 'SPREAD') {
-      return this.parseFragmentSpreadOrInline(line)
-    }
-
-    return this.parseField(line)
-  }
-
-  parseFragmentSpreadOrInline(line) {
-    const baseIndent = line.indent
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'on') {
-      tokenIdx++
-      const typeName = new AST.NameNode(line.tokens[tokenIdx].value)
-      const typeCondition = new AST.NamedTypeNode(typeName)
-      tokenIdx++
-
-      const directives = []
-      for (let i = tokenIdx; i < line.tokens.length; i++) {
-        if (line.tokens[i].type === 'DIRECTIVE') {
-          directives.push(this.parseDirectiveInline(line.tokens, i))
-        }
-      }
-
-      this.advance()
-      const selectionSet = this.parseSelectionSet(baseIndent)
-
-      return new AST.InlineFragmentNode(typeCondition, directives, selectionSet)
-    }
-
-    const fragmentName = new AST.NameNode(line.tokens[tokenIdx].value)
-    tokenIdx++
-
-    const directives = []
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    return new AST.FragmentSpreadNode(fragmentName, directives)
-  }
-
-  parseField(line) {
-    const baseIndent = line.indent
-    let alias = null
-    let name = null
-    let args = []
-    let directives = []
-    let tokenIdx = 0
-
-    const firstIdent = line.tokens[tokenIdx]
-    if (firstIdent && firstIdent.type === 'IDENTIFIER') {
-      if (line.tokens[tokenIdx + 1] && line.tokens[tokenIdx + 1].type === 'COLON') {
-        if (line.tokens[tokenIdx + 2] && line.tokens[tokenIdx + 2].type === 'IDENTIFIER') {
-          const nextNext = line.tokens[tokenIdx + 3]
-          if (!nextNext || nextNext.type === 'COLON' || nextNext.type === 'DIRECTIVE') {
-            alias = new AST.NameNode(firstIdent.value)
-            tokenIdx += 2
-            name = new AST.NameNode(this.translateKeyword(line.tokens[tokenIdx].value))
-            tokenIdx++
-          } else {
-            name = new AST.NameNode(this.translateKeyword(firstIdent.value))
-            tokenIdx++
-          }
-        } else {
-          name = new AST.NameNode(this.translateKeyword(firstIdent.value))
-          tokenIdx++
-        }
-      } else {
-        name = new AST.NameNode(this.translateKeyword(firstIdent.value))
-        tokenIdx++
-      }
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COLON') {
-      tokenIdx++
-      args = this.parseArgumentsInline(line.tokens, tokenIdx)
-      tokenIdx = this.findNextDirectiveOrEnd(line.tokens, tokenIdx)
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    
-    let selectionSet = null
-    if (this.pos < this.tokens.length && this.currentLine().indent > baseIndent) {
-      selectionSet = this.parseSelectionSet(baseIndent)
-    }
-
-    return new AST.FieldNode(alias, name, args, directives, selectionSet)
-  }
-
-  parseArgumentsInline(tokens, startIdx) {
-    const args = []
-    let idx = startIdx
-
-    while (idx < tokens.length) {
-      if (tokens[idx].type === 'DIRECTIVE') break
-
-      if (tokens[idx].type === 'IDENTIFIER') {
-        const argName = new AST.NameNode(this.translateKeyword(tokens[idx].value))
-        idx++
-
-        if (tokens[idx] && tokens[idx].type === 'EQUALS') {
-          idx++
-          const valueResult = this.parseArgumentValue(tokens, idx)
-          args.push(new AST.ArgumentNode(argName, valueResult.value))
-          idx = valueResult.nextIdx
-        }
-      }
-
-      if (tokens[idx] && tokens[idx].type === 'COMMA') {
-        idx++
-      } else if (tokens[idx] && tokens[idx].type !== 'IDENTIFIER') {
-        break
-      }
-    }
-
-    return args
-  }
-
-  parseArgumentValue(tokens, startIdx) {
-    let idx = startIdx
-    const token = tokens[idx]
-
-    if (!token) {
-      return { value: null, nextIdx: idx }
-    }
-
-    if (token.type === 'STRING') {
-      return { value: new AST.StringValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    if (token.type === 'INT') {
-      return { value: new AST.IntValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    if (token.type === 'FLOAT') {
-      return { value: new AST.FloatValueNode(token.value), nextIdx: idx + 1 }
-    }
-
-    if (token.type === 'IDENTIFIER') {
-      const translated = this.translateKeyword(token.value)
-      if (translated === 'true') {
-        return { value: new AST.BooleanValueNode(true), nextIdx: idx + 1 }
-      }
-      if (translated === 'false') {
-        return { value: new AST.BooleanValueNode(false), nextIdx: idx + 1 }
-      }
-      if (translated === 'null') {
-        return { value: new AST.NullValueNode(), nextIdx: idx + 1 }
-      }
-
-      if (tokens[idx + 1] && tokens[idx + 1].type === 'COLON') {
-        return this.parseObjectValueInline(tokens, idx)
-      }
-
-      return { value: new AST.VariableNode(new AST.NameNode(token.value)), nextIdx: idx + 1 }
-    }
-
-    return { value: null, nextIdx: idx + 1 }
-  }
-
-  parseObjectValueInline(tokens, startIdx) {
-    const fields = []
-    let idx = startIdx
-
-    while (idx < tokens.length) {
-      if (tokens[idx].type === 'DIRECTIVE') break
-      if (tokens[idx].type === 'COMMA' && tokens[idx + 1] && 
-          tokens[idx + 1].type === 'IDENTIFIER' && 
-          tokens[idx + 2] && tokens[idx + 2].type === 'EQUALS') {
-        break
-      }
-
-      if (tokens[idx].type === 'IDENTIFIER') {
-        const fieldName = new AST.NameNode(tokens[idx].value)
-        idx++
-
-        if (tokens[idx] && tokens[idx].type === 'COLON') {
-          idx++
-          const valueResult = this.parseValueInline(tokens, idx)
-          fields.push(new AST.ObjectFieldNode(fieldName, valueResult.value))
-          idx = valueResult.nextIdx
-        }
-      }
-
-      if (tokens[idx] && tokens[idx].type === 'COMMA') {
-        if (tokens[idx + 1] && tokens[idx + 1].type === 'IDENTIFIER' &&
-            tokens[idx + 2] && tokens[idx + 2].type === 'EQUALS') {
-          break
-        }
-        idx++
-      } else {
-        break
-      }
-    }
-
-    return { value: new AST.ObjectValueNode(fields), nextIdx: idx }
-  }
-
-  findNextDirectiveOrEnd(tokens, startIdx) {
-    for (let i = startIdx; i < tokens.length; i++) {
-      if (tokens[i].type === 'DIRECTIVE') return i
-    }
-    return tokens.length
-  }
-
-  parseFragmentDefinition() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let typeCondition = null
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'on') {
-      tokenIdx++
-      if (line.tokens[tokenIdx]) {
-        typeCondition = new AST.NamedTypeNode(new AST.NameNode(line.tokens[tokenIdx].value))
-        tokenIdx++
-      }
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const selectionSet = this.parseSelectionSet(baseIndent)
-
-    return new AST.FragmentDefinitionNode(name, typeCondition, directives, selectionSet)
-  }
-
-  parseObjectTypeDefinition() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let interfaces = []
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'implements') {
-      tokenIdx++
-      while (tokenIdx < line.tokens.length) {
-        if (line.tokens[tokenIdx].type === 'DIRECTIVE') break
-        if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-          interfaces.push(new AST.NamedTypeNode(new AST.NameNode(line.tokens[tokenIdx].value)))
-          tokenIdx++
-        }
-        if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COMMA') {
-          tokenIdx++
-        } else {
-          break
-        }
-      }
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const fields = this.parseFieldDefinitions(baseIndent)
-
-    return new AST.ObjectTypeDefinitionNode(null, name, interfaces, directives, fields)
-  }
-
-  parseFieldDefinitions(parentIndent) {
-    const fields = []
-
-    while (this.pos < this.tokens.length) {
-      const line = this.currentLine()
-      if (!line || line.indent <= parentIndent) break
-
-      const field = this.parseFieldDefinition(line)
-      if (field) {
-        fields.push(field)
-      }
-    }
-
-    return fields
-  }
-
-  parseFieldDefinition(line) {
-    let name = null
-    let args = []
-    let type = null
-    let directives = []
-    let tokenIdx = 0
-    let description = null
-
-    if (line.tokens[0] && (line.tokens[0].type === 'STRING' || line.tokens[0].type === 'BLOCK_STRING')) {
-      description = new AST.StringValueNode(line.tokens[0].value, line.tokens[0].type === 'BLOCK_STRING')
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(this.translateKeyword(line.tokens[tokenIdx].value))
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COLON') {
-      tokenIdx++
-      
-      while (tokenIdx < line.tokens.length) {
-        if (line.tokens[tokenIdx].type === 'ARROW') break
-        if (line.tokens[tokenIdx].type === 'DIRECTIVE') break
-        
-        if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-          const nextToken = line.tokens[tokenIdx + 1]
-          if (nextToken && nextToken.type === 'EQUALS') {
-            const argName = new AST.NameNode(this.translateKeyword(line.tokens[tokenIdx].value))
-            tokenIdx += 2
-            
-            const typeResult = this.parseTypeInline(line.tokens, tokenIdx)
-            let defaultValue = null
-            tokenIdx = typeResult.nextIdx
-            
-            if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'EQUALS') {
-              tokenIdx++
-              const valueResult = this.parseValueInline(line.tokens, tokenIdx)
-              defaultValue = valueResult.value
-              tokenIdx = valueResult.nextIdx
-            }
-            
-            args.push(new AST.InputValueDefinitionNode(null, argName, typeResult.type, defaultValue, []))
-          } else {
-            break
-          }
-        }
-        
-        if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COMMA') {
-          tokenIdx++
-        } else {
-          break
-        }
-      }
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'ARROW') {
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx]) {
-      const typeResult = this.parseTypeInline(line.tokens, tokenIdx)
-      type = typeResult.type
-      tokenIdx = typeResult.nextIdx
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-
-    return new AST.FieldDefinitionNode(description, name, args, type, directives)
-  }
-
-  parseInputObjectTypeDefinition() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const fields = this.parseInputFieldDefinitions(baseIndent)
-
-    return new AST.InputObjectTypeDefinitionNode(null, name, directives, fields)
-  }
-
-  parseInputFieldDefinitions(parentIndent) {
-    const fields = []
-
-    while (this.pos < this.tokens.length) {
-      const line = this.currentLine()
-      if (!line || line.indent <= parentIndent) break
-
-      const field = this.parseInputFieldDefinition(line)
-      if (field) {
-        fields.push(field)
-      }
-    }
-
-    return fields
-  }
-
-  parseInputFieldDefinition(line) {
-    let name = null
-    let type = null
-    let defaultValue = null
-    let directives = []
-    let tokenIdx = 0
-    let description = null
-
-    if (line.tokens[0] && (line.tokens[0].type === 'STRING' || line.tokens[0].type === 'BLOCK_STRING')) {
-      description = new AST.StringValueNode(line.tokens[0].value, line.tokens[0].type === 'BLOCK_STRING')
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(this.translateKeyword(line.tokens[tokenIdx].value))
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COLON') {
-      tokenIdx++
-      const typeResult = this.parseTypeInline(line.tokens, tokenIdx)
-      type = typeResult.type
-      tokenIdx = typeResult.nextIdx
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'EQUALS') {
-      tokenIdx++
-      const valueResult = this.parseValueInline(line.tokens, tokenIdx)
-      defaultValue = valueResult.value
-      tokenIdx = valueResult.nextIdx
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-
-    return new AST.InputValueDefinitionNode(description, name, type, defaultValue, directives)
-  }
-
-  parseInterfaceTypeDefinition() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let interfaces = []
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'implements') {
-      tokenIdx++
-      while (tokenIdx < line.tokens.length) {
-        if (line.tokens[tokenIdx].type === 'DIRECTIVE') break
-        if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-          interfaces.push(new AST.NamedTypeNode(new AST.NameNode(line.tokens[tokenIdx].value)))
-          tokenIdx++
-        }
-        if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COMMA') {
-          tokenIdx++
-        } else {
-          break
-        }
-      }
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const fields = this.parseFieldDefinitions(baseIndent)
-
-    return new AST.InterfaceTypeDefinitionNode(null, name, interfaces, directives, fields)
-  }
-
-  parseUnionTypeDefinition() {
-    const line = this.currentLine()
-    let name = null
-    let directives = []
-    let types = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'EQUALS') {
-      tokenIdx++
-    }
-
-    while (tokenIdx < line.tokens.length) {
-      if (line.tokens[tokenIdx].type === 'DIRECTIVE') break
-      if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-        types.push(new AST.NamedTypeNode(new AST.NameNode(line.tokens[tokenIdx].value)))
-        tokenIdx++
-      }
-      if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'PIPE') {
-        tokenIdx++
-      } else if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COMMA') {
-        tokenIdx++
-      } else {
-        break
-      }
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-
-    return new AST.UnionTypeDefinitionNode(null, name, directives, types)
-  }
-
-  parseEnumTypeDefinition() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const values = this.parseEnumValues(baseIndent)
-
-    return new AST.EnumTypeDefinitionNode(null, name, directives, values)
-  }
-
-  parseEnumValues(parentIndent) {
-    const values = []
-
-    while (this.pos < this.tokens.length) {
-      const line = this.currentLine()
-      if (!line || line.indent <= parentIndent) break
-
-      let description = null
-      let tokenIdx = 0
-
-      if (line.tokens[0] && (line.tokens[0].type === 'STRING' || line.tokens[0].type === 'BLOCK_STRING')) {
-        description = new AST.StringValueNode(line.tokens[0].value, line.tokens[0].type === 'BLOCK_STRING')
-        tokenIdx++
-      }
-
-      if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-        const name = new AST.NameNode(line.tokens[tokenIdx].value)
-        tokenIdx++
-
-        const directives = []
-        for (let i = tokenIdx; i < line.tokens.length; i++) {
-          if (line.tokens[i].type === 'DIRECTIVE') {
-            directives.push(this.parseDirectiveInline(line.tokens, i))
-          }
-        }
-
-        values.push(new AST.EnumValueDefinitionNode(description, name, directives))
-      }
-
-      this.advance()
-    }
-
-    return values
-  }
-
-  parseScalarTypeDefinition() {
-    const line = this.currentLine()
-    let name = null
-    let directives = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-
-    return new AST.ScalarTypeDefinitionNode(null, name, directives)
-  }
-
-  parseSchemaDefinition() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let directives = []
-    let tokenIdx = 1
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const operationTypes = this.parseOperationTypes(baseIndent)
-
-    return new AST.SchemaDefinitionNode(null, directives, operationTypes)
-  }
-
-  parseOperationTypes(parentIndent) {
-    const operationTypes = []
-
-    while (this.pos < this.tokens.length) {
-      const line = this.currentLine()
-      if (!line || line.indent <= parentIndent) break
-
-      if (line.tokens[0] && line.tokens[0].type === 'IDENTIFIER') {
-        const operation = this.translateKeyword(line.tokens[0].value)
-        let type = null
-
-        if (line.tokens[1] && line.tokens[1].type === 'COLON') {
-          if (line.tokens[2] && line.tokens[2].type === 'IDENTIFIER') {
-            type = new AST.NamedTypeNode(new AST.NameNode(line.tokens[2].value))
-          }
-        }
-
-        if (type) {
-          operationTypes.push(new AST.OperationTypeDefinitionNode(operation, type))
-        }
-      }
-
-      this.advance()
-    }
-
-    return operationTypes
-  }
-
-  parseDirectiveDefinition() {
-    const line = this.currentLine()
-    let name = null
-    let args = []
-    let repeatable = false
-    let locations = []
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'DIRECTIVE') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value.substring(1))
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'on') {
-      tokenIdx++
-    }
-
-    while (tokenIdx < line.tokens.length) {
-      if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-        const loc = line.tokens[tokenIdx].value.toUpperCase()
-        locations.push(new AST.NameNode(loc))
-        tokenIdx++
-      }
-      if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'PIPE') {
-        tokenIdx++
-      } else if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COMMA') {
-        tokenIdx++
-      } else {
-        break
-      }
-    }
-
-    this.advance()
-
-    return new AST.DirectiveDefinitionNode(null, name, args, repeatable, locations)
-  }
-
-  parseTypeExtension() {
-    const line = this.currentLine()
-    let tokenIdx = 1
-
-    if (line.tokens[tokenIdx]) {
-      const extendedType = this.translateKeyword(line.tokens[tokenIdx].value)
-      
-      switch (extendedType) {
-        case 'type':
-          return this.parseObjectTypeExtension()
-        case 'input':
-          return this.parseInputObjectTypeExtension()
-        case 'interface':
-          return this.parseInterfaceTypeExtension()
-        case 'union':
-          return this.parseUnionTypeExtension()
-        case 'enum':
-          return this.parseEnumTypeExtension()
-        case 'scalar':
-          return this.parseScalarTypeExtension()
-        case 'schema':
-          return this.parseSchemaExtension()
-      }
-    }
-
-    this.advance()
-    return null
-  }
-
-  parseObjectTypeExtension() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let interfaces = []
-    let directives = []
-    let tokenIdx = 2
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && this.translateKeyword(line.tokens[tokenIdx].value) === 'implements') {
-      tokenIdx++
-      while (tokenIdx < line.tokens.length) {
-        if (line.tokens[tokenIdx].type === 'DIRECTIVE') break
-        if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-          interfaces.push(new AST.NamedTypeNode(new AST.NameNode(line.tokens[tokenIdx].value)))
-          tokenIdx++
-        }
-        if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'COMMA') {
-          tokenIdx++
-        } else {
-          break
-        }
-      }
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const fields = this.parseFieldDefinitions(baseIndent)
-
-    return new AST.ObjectTypeExtensionNode(name, interfaces, directives, fields)
-  }
-
-  parseInputObjectTypeExtension() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let directives = []
-    let tokenIdx = 2
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const fields = this.parseInputFieldDefinitions(baseIndent)
-
-    return new AST.InputObjectTypeExtensionNode(name, directives, fields)
-  }
-
-  parseInterfaceTypeExtension() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let interfaces = []
-    let directives = []
-    let tokenIdx = 2
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const fields = this.parseFieldDefinitions(baseIndent)
-
-    return new AST.InterfaceTypeExtensionNode(name, interfaces, directives, fields)
-  }
-
-  parseUnionTypeExtension() {
-    const line = this.currentLine()
-    let name = null
-    let directives = []
-    let types = []
-    let tokenIdx = 2
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'EQUALS') {
-      tokenIdx++
-    }
-
-    while (tokenIdx < line.tokens.length) {
-      if (line.tokens[tokenIdx].type === 'DIRECTIVE') break
-      if (line.tokens[tokenIdx].type === 'IDENTIFIER') {
-        types.push(new AST.NamedTypeNode(new AST.NameNode(line.tokens[tokenIdx].value)))
-        tokenIdx++
-      }
-      if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'PIPE') {
-        tokenIdx++
-      } else {
-        break
-      }
-    }
-
-    this.advance()
-
-    return new AST.UnionTypeExtensionNode(name, directives, types)
-  }
-
-  parseEnumTypeExtension() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let name = null
-    let directives = []
-    let tokenIdx = 2
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const values = this.parseEnumValues(baseIndent)
-
-    return new AST.EnumTypeExtensionNode(name, directives, values)
-  }
-
-  parseScalarTypeExtension() {
-    const line = this.currentLine()
-    let name = null
-    let directives = []
-    let tokenIdx = 2
-
-    if (line.tokens[tokenIdx] && line.tokens[tokenIdx].type === 'IDENTIFIER') {
-      name = new AST.NameNode(line.tokens[tokenIdx].value)
-      tokenIdx++
-    }
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-
-    return new AST.ScalarTypeExtensionNode(name, directives)
-  }
-
-  parseSchemaExtension() {
-    const line = this.currentLine()
-    const baseIndent = line.indent
-    let directives = []
-    let tokenIdx = 2
-
-    for (let i = tokenIdx; i < line.tokens.length; i++) {
-      if (line.tokens[i].type === 'DIRECTIVE') {
-        directives.push(this.parseDirectiveInline(line.tokens, i))
-      }
-    }
-
-    this.advance()
-    const operationTypes = this.parseOperationTypes(baseIndent)
-
-    return new AST.SchemaExtensionNode(directives, operationTypes)
-  }
-}
-
-class GraphQLCodeGenerator {
-  constructor() {
-    this.indent = 0
-  }
-
-  generate(ast) {
-    if (!ast) return ''
-
-    switch (ast.type) {
-      case 'Document':
-        return ast.definitions.map(d => this.generate(d)).join('\n\n')
-
-      case 'OperationDefinition':
-        return this.generateOperation(ast)
-
-      case 'FragmentDefinition':
-        return this.generateFragment(ast)
-
-      case 'ObjectTypeDefinition':
-        return this.generateObjectType(ast)
-
-      case 'InputObjectTypeDefinition':
-        return this.generateInputType(ast)
-
-      case 'InterfaceTypeDefinition':
-        return this.generateInterface(ast)
-
-      case 'UnionTypeDefinition':
-        return this.generateUnion(ast)
-
-      case 'EnumTypeDefinition':
-        return this.generateEnum(ast)
-
-      case 'ScalarTypeDefinition':
-        return this.generateScalar(ast)
-
-      case 'SchemaDefinition':
-        return this.generateSchema(ast)
-
-      case 'DirectiveDefinition':
-        return this.generateDirectiveDefinition(ast)
-
-      case 'ObjectTypeExtension':
-      case 'InputObjectTypeExtension':
-      case 'InterfaceTypeExtension':
-      case 'UnionTypeExtension':
-      case 'EnumTypeExtension':
-      case 'ScalarTypeExtension':
-      case 'SchemaExtension':
-        return this.generateExtension(ast)
-
-      default:
-        return ''
-    }
-  }
-
-  generateOperation(ast) {
-    let result = ast.operation
-
-    if (ast.name) {
-      result += ' ' + ast.name.value
-    }
-
-    if (ast.variableDefinitions && ast.variableDefinitions.length > 0) {
-      result += '(' + ast.variableDefinitions.map(v => this.generateVariableDefinition(v)).join(', ') + ')'
-    }
-
-    if (ast.directives && ast.directives.length > 0) {
-      result += ' ' + ast.directives.map(d => this.generateDirective(d)).join(' ')
-    }
-
-    result += ' ' + this.generateSelectionSet(ast.selectionSet)
-
-    return result
-  }
-
-  generateVariableDefinition(ast) {
-    let result = '$' + ast.variable.name.value + ': ' + this.generateType(ast.type)
-
-    if (ast.defaultValue) {
-      result += ' = ' + this.generateValue(ast.defaultValue)
-    }
-
-    return result
-  }
-
-  generateType(ast) {
-    if (!ast) return ''
-
-    switch (ast.type) {
-      case 'NamedType':
-        return ast.name.value
-
-      case 'ListType':
-        return '[' + this.generateType(ast.type) + ']'
-
-      case 'NonNullType':
-        return this.generateType(ast.type) + '!'
-
-      default:
-        return ''
-    }
-  }
-
-  generateValue(ast) {
-    if (!ast) return 'null'
-
-    switch (ast.type) {
-      case 'IntValue':
-        return String(ast.value)
-
-      case 'FloatValue':
-        return String(ast.value)
-
-      case 'StringValue':
-        if (ast.block) {
-          return '"""' + ast.value + '"""'
-        }
-        return '"' + ast.value.replace(/"/g, '\\"') + '"'
-
-      case 'BooleanValue':
-        return ast.value ? 'true' : 'false'
-
-      case 'NullValue':
-        return 'null'
-
-      case 'EnumValue':
-        return ast.value
-
-      case 'Variable':
-        return '$' + ast.name.value
-
-      case 'ListValue':
-        return '[' + ast.values.map(v => this.generateValue(v)).join(', ') + ']'
-
-      case 'ObjectValue':
-        return '{' + ast.fields.map(f => f.name.value + ': ' + this.generateValue(f.value)).join(', ') + '}'
-
-      default:
-        return ''
-    }
-  }
-
-  generateDirective(ast) {
-    let result = '@' + ast.name.value
-
-    if (ast.arguments && ast.arguments.length > 0) {
-      result += '(' + ast.arguments.map(a => a.name.value + ': ' + this.generateValue(a.value)).join(', ') + ')'
-    }
-
-    return result
-  }
-
-  generateSelectionSet(ast) {
-    if (!ast || !ast.selections || ast.selections.length === 0) {
-      return ''
-    }
-
-    this.indent++
-    const selections = ast.selections.map(s => this.generateSelection(s)).join('\n')
-    this.indent--
-
-    return '{\n' + selections + '\n' + this.getIndent() + '}'
-  }
-
-  generateSelection(ast) {
-    const prefix = this.getIndent()
-
-    switch (ast.type) {
-      case 'Field':
-        return prefix + this.generateField(ast)
-
-      case 'FragmentSpread':
-        return prefix + '...' + ast.name.value + this.generateDirectives(ast.directives)
-
-      case 'InlineFragment':
-        let result = prefix + '...'
-        if (ast.typeCondition) {
-          result += ' on ' + ast.typeCondition.name.value
-        }
-        result += this.generateDirectives(ast.directives)
-        result += ' ' + this.generateSelectionSet(ast.selectionSet)
-        return result
-
-      default:
-        return ''
-    }
-  }
-
-  generateField(ast) {
-    let result = ''
-
-    if (ast.alias) {
-      result += ast.alias.value + ': '
-    }
-
-    result += ast.name.value
-
-    if (ast.arguments && ast.arguments.length > 0) {
-      result += '(' + ast.arguments.map(a => a.name.value + ': ' + this.generateValue(a.value)).join(', ') + ')'
-    }
-
-    result += this.generateDirectives(ast.directives)
-
-    if (ast.selectionSet && ast.selectionSet.selections && ast.selectionSet.selections.length > 0) {
-      result += ' ' + this.generateSelectionSet(ast.selectionSet)
-    }
-
-    return result
-  }
-
-  generateDirectives(directives) {
-    if (!directives || directives.length === 0) return ''
-    return ' ' + directives.map(d => this.generateDirective(d)).join(' ')
-  }
-
-  generateFragment(ast) {
-    let result = 'fragment ' + ast.name.value
-
-    if (ast.typeCondition) {
-      result += ' on ' + ast.typeCondition.name.value
-    }
-
-    result += this.generateDirectives(ast.directives)
-    result += ' ' + this.generateSelectionSet(ast.selectionSet)
-
-    return result
-  }
-
-  generateObjectType(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'type ' + ast.name.value
-
-    if (ast.interfaces && ast.interfaces.length > 0) {
-      result += ' implements ' + ast.interfaces.map(i => i.name.value).join(' & ')
-    }
-
-    result += this.generateDirectives(ast.directives)
-    result += ' {\n'
-
-    this.indent++
-    result += ast.fields.map(f => this.getIndent() + this.generateFieldDefinition(f)).join('\n')
-    this.indent--
-
-    result += '\n}'
-
-    return result
-  }
-
-  generateFieldDefinition(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n' + this.getIndent()
-    }
-
-    result += ast.name.value
-
-    if (ast.arguments && ast.arguments.length > 0) {
-      result += '(' + ast.arguments.map(a => this.generateInputValueDefinition(a)).join(', ') + ')'
-    }
-
-    result += ': ' + this.generateType(ast.type)
-    result += this.generateDirectives(ast.directives)
-
-    return result
-  }
-
-  generateInputValueDefinition(ast) {
-    let result = ast.name.value + ': ' + this.generateType(ast.type)
-
-    if (ast.defaultValue) {
-      result += ' = ' + this.generateValue(ast.defaultValue)
-    }
-
-    result += this.generateDirectives(ast.directives)
-
-    return result
-  }
-
-  generateInputType(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'input ' + ast.name.value
-    result += this.generateDirectives(ast.directives)
-    result += ' {\n'
-
-    this.indent++
-    result += ast.fields.map(f => this.getIndent() + this.generateInputValueDefinition(f)).join('\n')
-    this.indent--
-
-    result += '\n}'
-
-    return result
-  }
-
-  generateInterface(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'interface ' + ast.name.value
-
-    if (ast.interfaces && ast.interfaces.length > 0) {
-      result += ' implements ' + ast.interfaces.map(i => i.name.value).join(' & ')
-    }
-
-    result += this.generateDirectives(ast.directives)
-    result += ' {\n'
-
-    this.indent++
-    result += ast.fields.map(f => this.getIndent() + this.generateFieldDefinition(f)).join('\n')
-    this.indent--
-
-    result += '\n}'
-
-    return result
-  }
-
-  generateUnion(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'union ' + ast.name.value
-    result += this.generateDirectives(ast.directives)
-    result += ' = ' + ast.types.map(t => t.name.value).join(' | ')
-
-    return result
-  }
-
-  generateEnum(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'enum ' + ast.name.value
-    result += this.generateDirectives(ast.directives)
-    result += ' {\n'
-
-    this.indent++
-    result += ast.values.map(v => {
-      let line = this.getIndent()
-      if (v.description) {
-        line = this.getIndent() + this.generateValue(v.description) + '\n' + this.getIndent()
-      }
-      return line + v.name.value + this.generateDirectives(v.directives)
-    }).join('\n')
-    this.indent--
-
-    result += '\n}'
-
-    return result
-  }
-
-  generateScalar(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'scalar ' + ast.name.value
-    result += this.generateDirectives(ast.directives)
-
-    return result
-  }
-
-  generateSchema(ast) {
-    let result = 'schema'
-    result += this.generateDirectives(ast.directives)
-    result += ' {\n'
-
-    this.indent++
-    result += ast.operationTypes.map(o => this.getIndent() + o.operation + ': ' + o.type.name.value).join('\n')
-    this.indent--
-
-    result += '\n}'
-
-    return result
-  }
-
-  generateDirectiveDefinition(ast) {
-    let result = ''
-
-    if (ast.description) {
-      result += this.generateValue(ast.description) + '\n'
-    }
-
-    result += 'directive @' + ast.name.value
-
-    if (ast.arguments && ast.arguments.length > 0) {
-      result += '(' + ast.arguments.map(a => this.generateInputValueDefinition(a)).join(', ') + ')'
-    }
-
-    if (ast.repeatable) {
-      result += ' repeatable'
-    }
-
-    result += ' on ' + ast.locations.map(l => l.value).join(' | ')
-
-    return result
-  }
-
-  generateExtension(ast) {
-    const typeMap = {
-      'ObjectTypeExtension': 'type',
-      'InputObjectTypeExtension': 'input',
-      'InterfaceTypeExtension': 'interface',
-      'UnionTypeExtension': 'union',
-      'EnumTypeExtension': 'enum',
-      'ScalarTypeExtension': 'scalar',
-      'SchemaExtension': 'schema'
-    }
-
-    let result = 'extend ' + typeMap[ast.type]
-
-    if (ast.name) {
-      result += ' ' + ast.name.value
-    }
-
-    if (ast.interfaces && ast.interfaces.length > 0) {
-      result += ' implements ' + ast.interfaces.map(i => i.name.value).join(' & ')
-    }
-
-    result += this.generateDirectives(ast.directives)
-
-    if (ast.fields && ast.fields.length > 0) {
-      result += ' {\n'
-      this.indent++
-      result += ast.fields.map(f => this.getIndent() + this.generateFieldDefinition(f)).join('\n')
-      this.indent--
-      result += '\n}'
-    }
-
-    if (ast.types && ast.types.length > 0) {
-      result += ' = ' + ast.types.map(t => t.name.value).join(' | ')
-    }
-
-    if (ast.values && ast.values.length > 0) {
-      result += ' {\n'
-      this.indent++
-      result += ast.values.map(v => this.getIndent() + v.name.value + this.generateDirectives(v.directives)).join('\n')
-      this.indent--
-      result += '\n}'
-    }
-
-    if (ast.operationTypes && ast.operationTypes.length > 0) {
-      result += ' {\n'
-      this.indent++
-      result += ast.operationTypes.map(o => this.getIndent() + o.operation + ': ' + o.type.name.value).join('\n')
-      this.indent--
-      result += '\n}'
-    }
-
-    return result
-  }
-
-  getIndent() {
-    return '  '.repeat(this.indent)
-  }
-}
-
-module.exports = {
-  EtherGraphQLParser,
-  GraphQLCodeGenerator
-}