ether-code 0.7.8 → 0.8.0

package/parsers/ether-parser-graphql.js

@@ -0,0 +1,539 @@
+const { EtherParserBase, TokenType } = require('./ether-parser-base')
+
+class EtherParserGraphQL extends EtherParserBase {
+  constructor(options = {}) {
+    super(options)
+    this.loadI18n(['i18n-graphql.json'])
+  }
+
+  parse(source) {
+    this.tokenize(source)
+    return this.parseGraphQLProgram()
+  }
+
+  parseGraphQLProgram() {
+    const document = {
+      type: 'GraphQLDocument',
+      definitions: []
+    }
+    
+    this.skipNewlines()
+    
+    while (!this.isAtEnd()) {
+      const def = this.parseGraphQLDefinition()
+      if (def) {
+        document.definitions.push(def)
+      }
+      this.skipNewlines()
+    }
+    
+    return document
+  }
+
+  parseGraphQLDefinition() {
+    this.skipNewlines()
+    const token = this.current()
+    
+    if (!token || token.type === TokenType.EOF) return null
+    
+    const value = token.value ? token.value.toLowerCase() : ''
+    
+    if (value === 'type' || value === 'modele') {
+      return this.parseGraphQLType()
+    }
+    
+    if (value === 'query' || value === 'requete') {
+      return this.parseGraphQLOperation('query')
+    }
+    
+    if (value === 'mutation') {
+      return this.parseGraphQLOperation('mutation')
+    }
+    
+    if (value === 'subscription' || value === 'abonnement') {
+      return this.parseGraphQLOperation('subscription')
+    }
+    
+    if (value === 'input' || value === 'entree') {
+      return this.parseGraphQLInput()
+    }
+    
+    if (value === 'enum' || value === 'enumeration') {
+      return this.parseGraphQLEnum()
+    }
+    
+    if (value === 'interface') {
+      return this.parseGraphQLInterface()
+    }
+    
+    if (value === 'schema' || value === 'schéma') {
+      return this.parseGraphQLSchema()
+    }
+    
+    this.advance()
+    return null
+  }
+
+  parseGraphQLType() {
+    this.advance()
+    
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    let implements_ = []
+    if (this.matchValue('implements') || this.matchValue('implemente')) {
+      while (!this.isAtEnd()) {
+        const implToken = this.current()
+        if (!implToken || implToken.type !== TokenType.IDENTIFIER) break
+        if (implToken.value.toLowerCase() === 'implements' || 
+            implToken.value === '{') break
+        implements_.push(implToken.value)
+        this.advance()
+        this.match(TokenType.COMMA) || this.match(TokenType.AMPERSAND)
+      }
+    }
+    
+    const fields = this.parseGraphQLFields()
+    
+    return {
+      type: 'TypeDefinition',
+      name: name,
+      implements: implements_,
+      fields: fields
+    }
+  }
+
+  parseGraphQLFields() {
+    const fields = []
+    
+    this.skipNewlines()
+    
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
+        this.skipNewlines()
+        const field = this.parseGraphQLField()
+        if (field) {
+          fields.push(field)
+        }
+        this.skipNewlines()
+      }
+    } else if (this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        const current = this.current()
+        
+        if (current && current.type === TokenType.DEDENT) {
+          this.advance()
+          break
+        }
+        
+        if (current && current.type === TokenType.NEWLINE) {
+          this.advance()
+          continue
+        }
+        
+        const field = this.parseGraphQLField()
+        if (field) {
+          fields.push(field)
+        }
+      }
+    }
+    
+    return fields
+  }
+
+  parseGraphQLField() {
+    const nameToken = this.current()
+    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) return null
+    
+    const name = nameToken.value
+    this.advance()
+    
+    const args = []
+    if (this.match(TokenType.LPAREN)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+        const arg = this.parseGraphQLArgument()
+        if (arg) {
+          args.push(arg)
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    this.match(TokenType.COLON)
+    
+    const fieldType = this.parseGraphQLType_()
+    
+    return {
+      name: name,
+      arguments: args,
+      type: fieldType
+    }
+  }
+
+  parseGraphQLArgument() {
+    const nameToken = this.current()
+    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) return null
+    
+    const name = nameToken.value
+    this.advance()
+    
+    this.match(TokenType.COLON)
+    
+    const argType = this.parseGraphQLType_()
+    
+    let defaultValue = null
+    if (this.match(TokenType.EQUALS)) {
+      defaultValue = this.parseGraphQLValue()
+    }
+    
+    return {
+      name: name,
+      type: argType,
+      defaultValue: defaultValue
+    }
+  }
+
+  parseGraphQLType_() {
+    let isNonNull = false
+    let isList = false
+    let listItemNonNull = false
+    
+    let typeName = null
+    
+    if (this.match(TokenType.LBRACKET)) {
+      isList = true
+      const innerType = this.current()
+      if (innerType && innerType.type === TokenType.IDENTIFIER) {
+        typeName = this.translateGraphQLType(innerType.value)
+        this.advance()
+      }
+      if (this.match(TokenType.BANG)) {
+        listItemNonNull = true
+      }
+      this.match(TokenType.RBRACKET)
+    } else {
+      const typeToken = this.current()
+      if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
+        typeName = this.translateGraphQLType(typeToken.value)
+        this.advance()
+      }
+    }
+    
+    if (this.match(TokenType.BANG)) {
+      isNonNull = true
+    }
+    
+    return {
+      name: typeName,
+      isList: isList,
+      isNonNull: isNonNull,
+      listItemNonNull: listItemNonNull
+    }
+  }
+
+  translateGraphQLType(type) {
+    const map = {
+      'chaine': 'String',
+      'texte': 'String',
+      'entier': 'Int',
+      'nombre': 'Int',
+      'flottant': 'Float',
+      'decimal': 'Float',
+      'booleen': 'Boolean',
+      'bool': 'Boolean',
+      'identifiant': 'ID',
+      'id': 'ID'
+    }
+    
+    return map[type.toLowerCase()] || type
+  }
+
+  parseGraphQLValue() {
+    const token = this.current()
+    if (!token) return null
+    
+    if (token.type === TokenType.STRING) {
+      this.advance()
+      return { type: 'StringValue', value: token.value.replace(/^["']|["']$/g, '') }
+    }
+    
+    if (token.type === TokenType.NUMBER || token.type === TokenType.INTEGER) {
+      this.advance()
+      return { type: 'NumberValue', value: parseFloat(token.value) }
+    }
+    
+    if (token.type === TokenType.IDENTIFIER) {
+      const val = token.value.toLowerCase()
+      this.advance()
+      
+      if (val === 'vrai' || val === 'true') {
+        return { type: 'BooleanValue', value: true }
+      }
+      if (val === 'faux' || val === 'false') {
+        return { type: 'BooleanValue', value: false }
+      }
+      if (val === 'nul' || val === 'null') {
+        return { type: 'NullValue' }
+      }
+      
+      return { type: 'EnumValue', value: token.value }
+    }
+    
+    return null
+  }
+
+  parseGraphQLOperation(opType) {
+    this.advance()
+    
+    let name = null
+    const nameToken = this.current()
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    const variables = []
+    if (this.match(TokenType.LPAREN)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+        const varToken = this.current()
+        if (varToken && varToken.type === TokenType.IDENTIFIER) {
+          const varName = varToken.value
+          this.advance()
+          this.match(TokenType.COLON)
+          const varType = this.parseGraphQLType_()
+          variables.push({ name: varName, type: varType })
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    const selections = this.parseGraphQLSelectionSet()
+    
+    return {
+      type: 'OperationDefinition',
+      operation: opType,
+      name: name,
+      variables: variables,
+      selectionSet: selections
+    }
+  }
+
+  parseGraphQLSelectionSet() {
+    const selections = []
+    
+    this.skipNewlines()
+    
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
+        this.skipNewlines()
+        const selection = this.parseGraphQLSelection()
+        if (selection) {
+          selections.push(selection)
+        }
+        this.skipNewlines()
+      }
+    } else if (this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        const current = this.current()
+        
+        if (current && current.type === TokenType.DEDENT) {
+          this.advance()
+          break
+        }
+        
+        if (current && current.type === TokenType.NEWLINE) {
+          this.advance()
+          continue
+        }
+        
+        const selection = this.parseGraphQLSelection()
+        if (selection) {
+          selections.push(selection)
+        }
+      }
+    }
+    
+    return selections
+  }
+
+  parseGraphQLSelection() {
+    const nameToken = this.current()
+    if (!nameToken || nameToken.type !== TokenType.IDENTIFIER) return null
+    
+    const name = nameToken.value
+    this.advance()
+    
+    const args = []
+    if (this.match(TokenType.LPAREN)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RPAREN)) {
+        const argName = this.current()
+        if (argName && argName.type === TokenType.IDENTIFIER) {
+          const argNameVal = argName.value
+          this.advance()
+          this.match(TokenType.COLON)
+          const argValue = this.parseGraphQLValue()
+          args.push({ name: argNameVal, value: argValue })
+        }
+        this.match(TokenType.COMMA)
+      }
+    }
+    
+    let nestedSelections = []
+    const next = this.current()
+    if (next && (next.type === TokenType.LBRACE || next.type === TokenType.INDENT)) {
+      nestedSelections = this.parseGraphQLSelectionSet()
+    }
+    
+    return {
+      type: 'Field',
+      name: name,
+      arguments: args,
+      selectionSet: nestedSelections
+    }
+  }
+
+  parseGraphQLInput() {
+    this.advance()
+    
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    const fields = this.parseGraphQLFields()
+    
+    return {
+      type: 'InputTypeDefinition',
+      name: name,
+      fields: fields
+    }
+  }
+
+  parseGraphQLEnum() {
+    this.advance()
+    
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    const values = []
+    
+    this.skipNewlines()
+    
+    if (this.match(TokenType.LBRACE)) {
+      while (!this.isAtEnd() && !this.match(TokenType.RBRACE)) {
+        this.skipNewlines()
+        const valueToken = this.current()
+        if (valueToken && valueToken.type === TokenType.IDENTIFIER) {
+          values.push(valueToken.value)
+          this.advance()
+        }
+        this.skipNewlines()
+      }
+    } else if (this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        const current = this.current()
+        
+        if (current && current.type === TokenType.DEDENT) {
+          this.advance()
+          break
+        }
+        
+        if (current && current.type === TokenType.NEWLINE) {
+          this.advance()
+          continue
+        }
+        
+        if (current && current.type === TokenType.IDENTIFIER) {
+          values.push(current.value)
+          this.advance()
+        }
+      }
+    }
+    
+    return {
+      type: 'EnumDefinition',
+      name: name,
+      values: values
+    }
+  }
+
+  parseGraphQLInterface() {
+    this.advance()
+    
+    const nameToken = this.current()
+    let name = null
+    if (nameToken && nameToken.type === TokenType.IDENTIFIER) {
+      name = nameToken.value
+      this.advance()
+    }
+    
+    const fields = this.parseGraphQLFields()
+    
+    return {
+      type: 'InterfaceDefinition',
+      name: name,
+      fields: fields
+    }
+  }
+
+  parseGraphQLSchema() {
+    this.advance()
+    
+    const definitions = {}
+    
+    this.skipNewlines()
+    
+    if (this.match(TokenType.LBRACE) || this.match(TokenType.INDENT)) {
+      while (!this.isAtEnd()) {
+        const current = this.current()
+        
+        if (current && (current.type === TokenType.RBRACE || current.type === TokenType.DEDENT)) {
+          this.advance()
+          break
+        }
+        
+        if (current && current.type === TokenType.NEWLINE) {
+          this.advance()
+          continue
+        }
+        
+        if (current && current.type === TokenType.IDENTIFIER) {
+          const opType = current.value.toLowerCase()
+          this.advance()
+          this.match(TokenType.COLON)
+          
+          const typeToken = this.current()
+          if (typeToken && typeToken.type === TokenType.IDENTIFIER) {
+            definitions[opType] = typeToken.value
+            this.advance()
+          }
+        }
+      }
+    }
+    
+    return {
+      type: 'SchemaDefinition',
+      definitions: definitions
+    }
+  }
+
+  parseStatement(lang) {
+    return this.parseGraphQLDefinition()
+  }
+
+  parseExpression(lang) {
+    return null
+  }
+}
+
+module.exports = { EtherParserGraphQL }