ether-code 0.1.0

package/generators/graphql-generator.js

@@ -0,0 +1,868 @@
+const fs = require('fs')
+
+class GraphQLGenerator {
+  constructor(i18nPath = null) {
+    this.i18n = null
+    this.indent = 0
+    this.output = ''
+    this.keywordMap = {}
+    this.typeMap = {}
+    this.directiveMap = {}
+    
+    if (i18nPath) {
+      this.loadI18n(i18nPath)
+    }
+  }
+
+  loadI18n(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    this.i18n = JSON.parse(content)
+    this.buildMaps()
+  }
+
+  buildMaps() {
+    this.keywordMap = {}
+    this.typeMap = {}
+    this.directiveMap = {}
+    
+    if (!this.i18n) return
+
+    const addToMap = (map, section) => {
+      if (!section) return
+      for (const [key, translations] of Object.entries(section)) {
+        if (translations && translations.fr && translations.graphql) {
+          map[translations.fr.toLowerCase()] = translations.graphql
+        }
+      }
+    }
+
+    for (const sectionName of Object.keys(this.i18n)) {
+      addToMap(this.keywordMap, this.i18n[sectionName])
+    }
+  }
+
+  translate(word) {
+    if (!word) return ''
+    const lower = word.toLowerCase()
+    return this.keywordMap[lower] || this.translateGeneric(word)
+  }
+
+  translateGeneric(word) {
+    const translations = {
+      'type': 'type',
+      'requête': 'Query',
+      'mutation': 'Mutation',
+      'abonnement': 'Subscription',
+      'schema': 'schema',
+      'interface': 'interface',
+      'union': 'union',
+      'enum': 'enum',
+      'énumération': 'enum',
+      'entrée': 'input',
+      'scalaire': 'scalar',
+      'étend': 'extend',
+      'implémente': 'implements',
+      'fragment': 'fragment',
+      'sur': 'on',
+      'directive': 'directive',
+      'répéter': '@repeatable',
+      'chaîne': 'String',
+      'entier': 'Int',
+      'flottant': 'Float',
+      'booléen': 'Boolean',
+      'identifiant': 'ID',
+      'date': 'Date',
+      'datetime': 'DateTime',
+      'json': 'JSON',
+      'url': 'URL',
+      'courriel': 'Email',
+      'vrai': 'true',
+      'faux': 'false',
+      'nul': 'null',
+      'non nul': '!',
+      'liste': '[]',
+      'déprécié': '@deprecated',
+      'ignorer': '@skip',
+      'inclure': '@include',
+      'si': 'if',
+      'raison': 'reason',
+      'requiert': '@requires',
+      'fournit': '@provides',
+      'clé': '@key',
+      'externe': '@external',
+      'champs': 'fields'
+    }
+
+    const lower = word.toLowerCase()
+    return translations[lower] || word
+  }
+
+  translateType(type) {
+    if (!type) return ''
+    
+    const types = {
+      'chaîne': 'String',
+      'entier': 'Int',
+      'flottant': 'Float',
+      'booléen': 'Boolean',
+      'identifiant': 'ID',
+      'date': 'Date',
+      'datetime': 'DateTime',
+      'heure': 'Time',
+      'json': 'JSON',
+      'url': 'URL',
+      'courriel': 'Email',
+      'telephone': 'Phone',
+      'uuid': 'UUID',
+      'grand entier': 'BigInt',
+      'decimal': 'Decimal',
+      'positif entier': 'PositiveInt',
+      'négatif entier': 'NegativeInt',
+      'non négatif entier': 'NonNegativeInt',
+      'non positif entier': 'NonPositiveInt',
+      'positif flottant': 'PositiveFloat',
+      'négatif flottant': 'NegativeFloat',
+      'non vide chaîne': 'NonEmptyString',
+      'upload': 'Upload',
+      'vide': 'Void'
+    }
+
+    const lower = type.toLowerCase()
+    return types[lower] || type
+  }
+
+  generate(ast) {
+    this.output = ''
+    this.indent = 0
+
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
+        this.generateNode(node)
+        this.output += '\n'
+      }
+    } else if (ast && ast.type) {
+      this.generateNode(ast)
+    } else if (ast && ast.definitions) {
+      for (const def of ast.definitions) {
+        this.generateNode(def)
+        this.output += '\n'
+      }
+    }
+
+    return this.output.trim()
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type || node.kind) {
+      case 'SchemaDefinition':
+        return this.generateSchema(node)
+      case 'TypeDefinition':
+      case 'ObjectTypeDefinition':
+        return this.generateTypeDefinition(node)
+      case 'InterfaceDefinition':
+      case 'InterfaceTypeDefinition':
+        return this.generateInterface(node)
+      case 'UnionDefinition':
+      case 'UnionTypeDefinition':
+        return this.generateUnion(node)
+      case 'EnumDefinition':
+      case 'EnumTypeDefinition':
+        return this.generateEnum(node)
+      case 'InputDefinition':
+      case 'InputObjectTypeDefinition':
+        return this.generateInput(node)
+      case 'ScalarDefinition':
+      case 'ScalarTypeDefinition':
+        return this.generateScalar(node)
+      case 'DirectiveDefinition':
+        return this.generateDirectiveDefinition(node)
+      case 'ExtendType':
+      case 'TypeExtension':
+      case 'ObjectTypeExtension':
+        return this.generateExtendType(node)
+      case 'FragmentDefinition':
+        return this.generateFragment(node)
+      case 'OperationDefinition':
+        return this.generateOperation(node)
+      case 'Query':
+        return this.generateQuery(node)
+      case 'Mutation':
+        return this.generateMutation(node)
+      case 'Subscription':
+        return this.generateSubscription(node)
+      case 'Field':
+      case 'FieldDefinition':
+        return this.generateField(node)
+      case 'Argument':
+      case 'InputValueDefinition':
+        return this.generateArgument(node)
+      case 'Directive':
+        return this.generateDirective(node)
+      case 'Variable':
+        return this.generateVariable(node)
+      case 'SelectionSet':
+        return this.generateSelectionSet(node)
+      default:
+        return ''
+    }
+  }
+
+  generateSchema(node) {
+    this.writeLine('schema {')
+    this.indent++
+
+    if (node.query) {
+      this.writeLine(`query: ${this.translate(node.query)}`)
+    }
+    if (node.mutation) {
+      this.writeLine(`mutation: ${this.translate(node.mutation)}`)
+    }
+    if (node.subscription) {
+      this.writeLine(`subscription: ${this.translate(node.subscription)}`)
+    }
+
+    const operations = node.operations || node.operationTypes || []
+    for (const op of operations) {
+      const opType = this.translate(op.operation || op.type)
+      const typeName = this.translate(op.type?.name || op.name)
+      this.writeLine(`${opType}: ${typeName}`)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateTypeDefinition(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const interfaces = node.interfaces || []
+    const directives = node.directives || []
+    const fields = node.fields || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `type ${name}`
+
+    if (interfaces.length > 0) {
+      const interfaceNames = interfaces.map(i => i.name?.value || i.name || i)
+      declaration += ` implements ${interfaceNames.join(' & ')}`
+    }
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    for (const field of fields) {
+      this.generateField(field)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateInterface(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const directives = node.directives || []
+    const fields = node.fields || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `interface ${name}`
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    for (const field of fields) {
+      this.generateField(field)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateUnion(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const types = node.types || []
+    const directives = node.directives || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `union ${name}`
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    const typeNames = types.map(t => t.name?.value || t.name || t)
+    declaration += ` = ${typeNames.join(' | ')}`
+
+    this.writeLine(declaration)
+  }
+
+  generateEnum(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const values = node.values || []
+    const directives = node.directives || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `enum ${name}`
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    for (const value of values) {
+      const valueName = value.name?.value || value.name || value
+      const valueDesc = value.description?.value || value.description
+      const valueDirectives = value.directives || []
+
+      if (valueDesc) {
+        this.writeDescription(valueDesc)
+      }
+
+      let valueLine = valueName
+      if (valueDirectives.length > 0) {
+        valueLine += ' ' + valueDirectives.map(d => this.generateDirective(d)).join(' ')
+      }
+
+      this.writeLine(valueLine)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateInput(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const fields = node.fields || []
+    const directives = node.directives || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `input ${name}`
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    for (const field of fields) {
+      this.generateInputField(field)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateScalar(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const directives = node.directives || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `scalar ${name}`
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration)
+  }
+
+  generateDirectiveDefinition(node) {
+    const name = node.name?.value || node.name
+    const description = node.description?.value || node.description
+    const args = node.arguments || node.args || []
+    const locations = node.locations || []
+    const repeatable = node.repeatable
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let declaration = `directive @${name}`
+
+    if (args.length > 0) {
+      const argsStr = args.map(a => this.generateArgumentDefinition(a)).join(', ')
+      declaration += `(${argsStr})`
+    }
+
+    if (repeatable) {
+      declaration += ' repeatable'
+    }
+
+    const locationNames = locations.map(l => l.value || l)
+    declaration += ` on ${locationNames.join(' | ')}`
+
+    this.writeLine(declaration)
+  }
+
+  generateExtendType(node) {
+    const name = node.name?.value || node.name
+    const interfaces = node.interfaces || []
+    const directives = node.directives || []
+    const fields = node.fields || []
+
+    let declaration = `extend type ${name}`
+
+    if (interfaces.length > 0) {
+      const interfaceNames = interfaces.map(i => i.name?.value || i.name || i)
+      declaration += ` implements ${interfaceNames.join(' & ')}`
+    }
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    if (fields.length > 0) {
+      this.writeLine(declaration + ' {')
+      this.indent++
+
+      for (const field of fields) {
+        this.generateField(field)
+      }
+
+      this.indent--
+      this.writeLine('}')
+    } else {
+      this.writeLine(declaration)
+    }
+  }
+
+  generateFragment(node) {
+    const name = node.name?.value || node.name
+    const typeCondition = node.typeCondition?.name?.value || node.typeCondition || node.on
+    const directives = node.directives || []
+    const selections = node.selectionSet?.selections || node.selections || []
+
+    let declaration = `fragment ${name} on ${typeCondition}`
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    for (const selection of selections) {
+      this.generateSelection(selection)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateOperation(node) {
+    const operation = node.operation || 'query'
+    const name = node.name?.value || node.name || ''
+    const variables = node.variableDefinitions || node.variables || []
+    const directives = node.directives || []
+    const selections = node.selectionSet?.selections || node.selections || []
+
+    let declaration = operation
+    if (name) {
+      declaration += ` ${name}`
+    }
+
+    if (variables.length > 0) {
+      const varsStr = variables.map(v => this.generateVariableDefinition(v)).join(', ')
+      declaration += `(${varsStr})`
+    }
+
+    if (directives.length > 0) {
+      declaration += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(declaration + ' {')
+    this.indent++
+
+    for (const selection of selections) {
+      this.generateSelection(selection)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateQuery(node) {
+    node.operation = 'query'
+    return this.generateOperation(node)
+  }
+
+  generateMutation(node) {
+    node.operation = 'mutation'
+    return this.generateOperation(node)
+  }
+
+  generateSubscription(node) {
+    node.operation = 'subscription'
+    return this.generateOperation(node)
+  }
+
+  generateField(node) {
+    const name = this.translate(node.name?.value || node.name)
+    const description = node.description?.value || node.description
+    const args = node.arguments || node.args || []
+    const type = this.generateType(node.type)
+    const directives = node.directives || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let fieldLine = name
+
+    if (args.length > 0) {
+      if (args.length <= 2) {
+        const argsStr = args.map(a => this.generateArgumentDefinition(a)).join(', ')
+        fieldLine += `(${argsStr})`
+      } else {
+        fieldLine += '('
+        this.writeLine(fieldLine)
+        this.indent++
+        for (let i = 0; i < args.length; i++) {
+          const argStr = this.generateArgumentDefinition(args[i])
+          this.writeLine(argStr + (i < args.length - 1 ? ',' : ''))
+        }
+        this.indent--
+        fieldLine = ')'
+      }
+    }
+
+    fieldLine += `: ${type}`
+
+    if (directives.length > 0) {
+      fieldLine += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(fieldLine)
+  }
+
+  generateInputField(node) {
+    const name = this.translate(node.name?.value || node.name)
+    const description = node.description?.value || node.description
+    const type = this.generateType(node.type)
+    const defaultValue = node.defaultValue
+    const directives = node.directives || []
+
+    if (description) {
+      this.writeDescription(description)
+    }
+
+    let fieldLine = `${name}: ${type}`
+
+    if (defaultValue !== undefined) {
+      fieldLine += ` = ${this.generateValue(defaultValue)}`
+    }
+
+    if (directives.length > 0) {
+      fieldLine += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(fieldLine)
+  }
+
+  generateArgumentDefinition(arg) {
+    const name = this.translate(arg.name?.value || arg.name)
+    const description = arg.description?.value || arg.description
+    const type = this.generateType(arg.type)
+    const defaultValue = arg.defaultValue
+    const directives = arg.directives || []
+
+    let argStr = `${name}: ${type}`
+
+    if (defaultValue !== undefined) {
+      argStr += ` = ${this.generateValue(defaultValue)}`
+    }
+
+    if (directives.length > 0) {
+      argStr += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    return argStr
+  }
+
+  generateType(type) {
+    if (!type) return 'String'
+    
+    if (typeof type === 'string') {
+      return this.translateType(type)
+    }
+
+    const kind = type.kind || type.type
+
+    if (kind === 'NonNullType' || type.nonNull) {
+      const innerType = this.generateType(type.type || type.ofType)
+      return `${innerType}!`
+    }
+
+    if (kind === 'ListType' || type.list) {
+      const innerType = this.generateType(type.type || type.ofType)
+      return `[${innerType}]`
+    }
+
+    if (kind === 'NamedType' || type.name) {
+      return this.translateType(type.name?.value || type.name)
+    }
+
+    return this.translateType(String(type))
+  }
+
+  generateDirective(directive) {
+    const name = directive.name?.value || directive.name
+    const args = directive.arguments || directive.args || []
+
+    let result = `@${name}`
+
+    if (args.length > 0) {
+      const argsStr = args.map(a => {
+        const argName = a.name?.value || a.name
+        const argValue = this.generateValue(a.value)
+        return `${argName}: ${argValue}`
+      }).join(', ')
+      result += `(${argsStr})`
+    }
+
+    return result
+  }
+
+  generateVariableDefinition(variable) {
+    const name = variable.variable?.name?.value || variable.variable?.name || variable.name
+    const type = this.generateType(variable.type)
+    const defaultValue = variable.defaultValue
+    const directives = variable.directives || []
+
+    let varStr = `$${name}: ${type}`
+
+    if (defaultValue !== undefined) {
+      varStr += ` = ${this.generateValue(defaultValue)}`
+    }
+
+    if (directives.length > 0) {
+      varStr += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    return varStr
+  }
+
+  generateVariable(node) {
+    const name = node.name?.value || node.name
+    return `$${name}`
+  }
+
+  generateSelection(selection) {
+    const kind = selection.kind || selection.type
+
+    if (kind === 'Field') {
+      return this.generateFieldSelection(selection)
+    }
+
+    if (kind === 'FragmentSpread') {
+      const name = selection.name?.value || selection.name
+      const directives = selection.directives || []
+      let line = `...${name}`
+      if (directives.length > 0) {
+        line += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+      }
+      this.writeLine(line)
+      return
+    }
+
+    if (kind === 'InlineFragment') {
+      return this.generateInlineFragment(selection)
+    }
+
+    if (selection.name && selection.selectionSet) {
+      return this.generateFieldSelection(selection)
+    }
+
+    if (selection.typeCondition) {
+      return this.generateInlineFragment(selection)
+    }
+
+    const name = selection.name?.value || selection.name || selection
+    this.writeLine(String(name))
+  }
+
+  generateFieldSelection(field) {
+    const alias = field.alias?.value || field.alias
+    const name = field.name?.value || field.name
+    const args = field.arguments || field.args || []
+    const directives = field.directives || []
+    const selections = field.selectionSet?.selections || field.selections || []
+
+    let fieldLine = ''
+    
+    if (alias) {
+      fieldLine = `${alias}: ${name}`
+    } else {
+      fieldLine = name
+    }
+
+    if (args.length > 0) {
+      const argsStr = args.map(a => {
+        const argName = a.name?.value || a.name
+        const argValue = this.generateValue(a.value)
+        return `${argName}: ${argValue}`
+      }).join(', ')
+      fieldLine += `(${argsStr})`
+    }
+
+    if (directives.length > 0) {
+      fieldLine += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    if (selections.length > 0) {
+      this.writeLine(fieldLine + ' {')
+      this.indent++
+      for (const sel of selections) {
+        this.generateSelection(sel)
+      }
+      this.indent--
+      this.writeLine('}')
+    } else {
+      this.writeLine(fieldLine)
+    }
+  }
+
+  generateInlineFragment(fragment) {
+    const typeCondition = fragment.typeCondition?.name?.value || fragment.typeCondition
+    const directives = fragment.directives || []
+    const selections = fragment.selectionSet?.selections || fragment.selections || []
+
+    let line = '...'
+    if (typeCondition) {
+      line += ` on ${typeCondition}`
+    }
+
+    if (directives.length > 0) {
+      line += ' ' + directives.map(d => this.generateDirective(d)).join(' ')
+    }
+
+    this.writeLine(line + ' {')
+    this.indent++
+
+    for (const sel of selections) {
+      this.generateSelection(sel)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateSelectionSet(node) {
+    const selections = node.selections || []
+    
+    this.writeLine('{')
+    this.indent++
+
+    for (const sel of selections) {
+      this.generateSelection(sel)
+    }
+
+    this.indent--
+    this.writeLine('}')
+  }
+
+  generateValue(value) {
+    if (value === null || value === undefined) return 'null'
+    
+    if (typeof value === 'string') {
+      if (value.startsWith('$')) return value
+      if (value.startsWith('"') || value.match(/^[A-Z_]+$/)) return value
+      return `"${value.replace(/"/g, '\\"')}"`
+    }
+    
+    if (typeof value === 'number') return String(value)
+    if (typeof value === 'boolean') return value ? 'true' : 'false'
+
+    if (value.kind === 'Variable' || value.type === 'Variable') {
+      return this.generateVariable(value)
+    }
+
+    if (value.kind === 'IntValue') return value.value
+    if (value.kind === 'FloatValue') return value.value
+    if (value.kind === 'StringValue') return `"${value.value}"`
+    if (value.kind === 'BooleanValue') return value.value ? 'true' : 'false'
+    if (value.kind === 'NullValue') return 'null'
+    if (value.kind === 'EnumValue') return value.value
+
+    if (value.kind === 'ListValue' || Array.isArray(value.values || value)) {
+      const items = (value.values || value).map(v => this.generateValue(v))
+      return `[${items.join(', ')}]`
+    }
+
+    if (value.kind === 'ObjectValue' || value.fields) {
+      const fields = (value.fields || []).map(f => {
+        const fieldName = f.name?.value || f.name
+        const fieldValue = this.generateValue(f.value)
+        return `${fieldName}: ${fieldValue}`
+      })
+      return `{ ${fields.join(', ')} }`
+    }
+
+    if (value.value !== undefined) {
+      return this.generateValue(value.value)
+    }
+
+    return String(value)
+  }
+
+  writeDescription(description) {
+    if (!description) return
+
+    if (description.includes('\n')) {
+      this.writeLine('"""')
+      for (const line of description.split('\n')) {
+        this.writeLine(line)
+      }
+      this.writeLine('"""')
+    } else {
+      this.writeLine(`"${description}"`)
+    }
+  }
+
+  writeLine(text) {
+    this.output += this.getIndent() + text + '\n'
+  }
+
+  getIndent() {
+    return '  '.repeat(this.indent)
+  }
+}
+
+module.exports = {
+  GraphQLGenerator
+}