ether-code 0.1.0

package/generators/node-generator.js

@@ -0,0 +1,467 @@
+const fs = require('fs')
+const { JSGenerator } = require('./js-generator')
+
+class NodeGenerator extends JSGenerator {
+  constructor(i18nPath = null) {
+    super(i18nPath)
+    this.extendMaps()
+  }
+
+  extendMaps() {
+    const nodeTranslations = {
+      'requiert': 'require',
+      'module': 'module',
+      'exports': 'exports',
+      'exporter': 'module.exports',
+      'processus': 'process',
+      'global': 'global',
+      'nom fichier': '__filename',
+      'nom dossier': '__dirname',
+      'tampon': 'Buffer',
+      'chemin': 'path',
+      'système fichiers': 'fs',
+      'http': 'http',
+      'https': 'https',
+      'url': 'url',
+      'chaîne requête': 'querystring',
+      'événements': 'events',
+      'flux': 'stream',
+      'utilitaires': 'util',
+      'os': 'os',
+      'crypto': 'crypto',
+      'enfant processus': 'child_process',
+      'cluster': 'cluster',
+      'net': 'net',
+      'dns': 'dns',
+      'zlib': 'zlib',
+      'créer serveur': 'createServer',
+      'écouter': 'listen',
+      'requête': 'request',
+      'réponse': 'response',
+      'entêtes': 'headers',
+      'méthode': 'method',
+      'url requête': 'url',
+      'écrire tête': 'writeHead',
+      'terminer': 'end',
+      'sur': 'on',
+      'émettre': 'emit',
+      'une fois': 'once',
+      'retirer écouteur': 'removeListener',
+      'lire fichier': 'readFile',
+      'lire fichier sync': 'readFileSync',
+      'écrire fichier': 'writeFile',
+      'écrire fichier sync': 'writeFileSync',
+      'ajouter fichier': 'appendFile',
+      'supprimer fichier': 'unlink',
+      'renommer': 'rename',
+      'existe': 'existsSync',
+      'statistiques': 'stat',
+      'créer dossier': 'mkdir',
+      'lire dossier': 'readdir',
+      'supprimer dossier': 'rmdir',
+      'joindre': 'join',
+      'joindre chemin': 'join',
+      'de': 'from',
+      'temporiser': 'setTimeout',
+      'intervalle': 'setInterval',
+      'promettifier': 'promisify',
+      'résoudre': 'resolve',
+      'base': 'basename',
+      'dossier': 'dirname',
+      'extension': 'extname',
+      'analyser': 'parse',
+      'formater': 'format',
+      'normaliser': 'normalize',
+      'arguments': 'argv',
+      'environnement': 'env',
+      'sortie': 'exit',
+      'répertoire travail': 'cwd',
+      'changer dossier': 'chdir',
+      'mémoire': 'memoryUsage',
+      'temps fonctionnement': 'uptime',
+      'prochain tick': 'nextTick',
+      'plateforme': 'platform',
+      'architecture': 'arch',
+      'cpus': 'cpus',
+      'mémoire totale': 'totalmem',
+      'mémoire libre': 'freemem',
+      'dossier maison': 'homedir',
+      'dossier temp': 'tmpdir',
+      'nom hote': 'hostname',
+      'exécuter': 'exec',
+      'spawn': 'spawn',
+      'fork': 'fork',
+      'pid': 'pid',
+      'tuer': 'kill',
+      'connecter': 'connect',
+      'socket': 'Socket',
+      'serveur': 'Server',
+      'chercher': 'lookup',
+      'résoudre dns': 'resolve',
+      'compresser': 'gzip',
+      'decompresser': 'gunzip',
+      'degonfler': 'deflate',
+      'gonfler': 'inflate',
+      'hash': 'createHash',
+      'hmac': 'createHmac',
+      'chiffrer': 'createCipher',
+      'déchiffrer': 'createDecipher',
+      'aléatoire octets': 'randomBytes',
+      'promisifier': 'promisify',
+      'inspecter': 'inspect',
+      'hériter': 'inherits',
+      'formater chaîne': 'format',
+      'deboguer': 'debuglog',
+      'express': 'express',
+      'application': 'app',
+      'routeur': 'Router',
+      'utiliser': 'use',
+      'obtenir route': 'get',
+      'poster route': 'post',
+      'mettre route': 'put',
+      'supprimer route': 'delete',
+      'patch route': 'patch',
+      'middleware': 'middleware',
+      'corps': 'body',
+      'params': 'params',
+      'requête query': 'query',
+      'cookies': 'cookies',
+      'session': 'session',
+      'json': 'json',
+      'statique': 'static',
+      'envoyer': 'send',
+      'rendu': 'render',
+      'rediriger': 'redirect',
+      'statut': 'status',
+      'telecharger': 'download',
+      'fichier envoyer': 'sendFile',
+      'mongoose': 'mongoose',
+      'connecter db': 'connect',
+      'schema': 'Schema',
+      'modele': 'model',
+      'trouver': 'find',
+      'trouver un': 'findOne',
+      'trouver par id': 'findById',
+      'créer': 'create',
+      'mettre a jour un': 'updateOne',
+      'supprimer un': 'deleteOne',
+      'sauvegarder': 'save',
+      'peupler': 'populate',
+      'trier': 'sort',
+      'limiter': 'limit',
+      'sauter': 'skip',
+      'compter documents': 'countDocuments'
+    }
+
+    for (const [fr, node] of Object.entries(nodeTranslations)) {
+      this.keywordMap[fr] = node
+    }
+  }
+
+  generate(ast) {
+    this.output = ''
+    this.indent = 0
+
+    if (Array.isArray(ast)) {
+      for (const node of ast) {
+        const result = this.generateNode(node)
+        if (result !== undefined && result !== '' && this.output === '') {
+          return result
+        }
+      }
+    } else if (ast && ast.type) {
+      const result = this.generateNode(ast)
+      if (result !== undefined && result !== '' && this.output === '') {
+        return result
+      }
+    } else if (ast && ast.body) {
+      for (const node of ast.body) {
+        const result = this.generateNode(node)
+        if (result !== undefined && result !== '' && this.output === '') {
+          return result
+        }
+      }
+    }
+
+    return this.output.trim()
+  }
+
+  generateNode(node) {
+    if (!node) return ''
+
+    switch (node.type) {
+      case 'RequireStatement':
+        return this.generateRequire(node)
+      case 'ModuleExports':
+      case 'ModuleExportsStatement':
+        return this.generateModuleExports(node)
+      case 'ExportsStatement':
+        return this.generateExportsStatement(node)
+      case 'ServerCreation':
+        return this.generateServerCreation(node)
+      case 'RouteHandler':
+        return this.generateRouteHandler(node)
+      case 'MiddlewareUse':
+        return this.generateMiddlewareUse(node)
+      case 'FileOperation':
+        return this.generateFileOperation(node)
+      case 'EventListener':
+        return this.generateEventListener(node)
+      case 'StreamOperation':
+        return this.generateStreamOperation(node)
+      default:
+        return super.generateNode(node)
+    }
+  }
+
+  generateRequire(node) {
+    const module = node.source || node.module
+    const modulePath = typeof module === 'string' ? module : this.generateNode(module)
+    
+    const id = node.id || node.variable || node.name
+    
+    if (id?.type === 'ObjectPattern') {
+      const props = (id.properties || []).map(p => {
+        const key = p.key?.name || p.key
+        return this.translate(key)
+      }).join(', ')
+      this.writeLine(`const { ${props} } = require('${modulePath}');`)
+    } else if (node.destructure && node.destructure.length > 0) {
+      const props = node.destructure.map(p => this.translate(p)).join(', ')
+      this.writeLine(`const { ${props} } = require('${modulePath}');`)
+    } else if (id) {
+      const varName = typeof id === 'string' ? id : (id.name || this.generateNode(id))
+      this.writeLine(`const ${this.translate(varName)} = require('${modulePath}');`)
+    } else {
+      this.writeLine(`require('${modulePath}');`)
+    }
+  }
+
+  generateModuleExports(node) {
+    const exports = node.exports || node.default
+    
+    if (exports?.type === 'ObjectExpression') {
+      const props = (exports.properties || []).map(p => {
+        const key = p.key?.name || p.key
+        if (p.shorthand) {
+          return this.translate(key)
+        }
+        const value = this.generateNode(p.value)
+        return `${this.translate(key)}: ${value}`
+      })
+      this.writeLine(`module.exports = { ${props.join(', ')} };`)
+    } else if (exports) {
+      const value = this.generateNode(exports)
+      this.writeLine(`module.exports = ${value};`)
+    } else if (node.named && Object.keys(node.named).length > 0) {
+      const exportsList = Object.entries(node.named).map(([key, value]) => {
+        const translatedKey = this.translate(key)
+        const translatedValue = this.generateNode(value)
+        return translatedKey === translatedValue ? translatedKey : `${translatedKey}: ${translatedValue}`
+      })
+      this.writeLine(`module.exports = { ${exportsList.join(', ')} };`)
+    }
+  }
+
+  generateExportsStatement(node) {
+    const name = this.translate(node.name)
+    const value = this.generateNode(node.value)
+    this.writeLine(`exports.${name} = ${value};`)
+  }
+
+  generateServerCreation(node) {
+    const framework = node.framework || 'http'
+    
+    if (framework === 'express') {
+      this.writeLine("const express = require('express');")
+      this.writeLine('const app = express();')
+      this.writeLine('')
+      
+      if (node.middleware) {
+        for (const mw of node.middleware) {
+          this.generateMiddlewareUse(mw)
+        }
+        this.writeLine('')
+      }
+      
+      if (node.routes) {
+        for (const route of node.routes) {
+          this.generateRouteHandler(route)
+        }
+        this.writeLine('')
+      }
+      
+      const port = node.port || 3000
+      this.writeLine(`app.listen(${port}, () => {`)
+      this.indent++
+      this.writeLine(`console.log('Serveur démarré sur le port ${port}');`)
+      this.indent--
+      this.writeLine('});')
+    } else {
+      this.writeLine("const http = require('http');")
+      this.writeLine('')
+      this.writeLine('const server = http.createServer((req, res) => {')
+      this.indent++
+      
+      if (node.handler) {
+        this.generateNode(node.handler)
+      } else {
+        this.writeLine("res.writeHead(200, { 'Content-Type': 'text/plain' });")
+        this.writeLine("res.end('Hello World');")
+      }
+      
+      this.indent--
+      this.writeLine('});')
+      this.writeLine('')
+      
+      const port = node.port || 3000
+      this.writeLine(`server.listen(${port}, () => {`)
+      this.indent++
+      this.writeLine(`console.log('Serveur démarré sur le port ${port}');`)
+      this.indent--
+      this.writeLine('});')
+    }
+  }
+
+  generateRouteHandler(node) {
+    const method = this.translate(node.method || 'get').toLowerCase()
+    const path = node.path || '/'
+    const async = node.async ? 'async ' : ''
+    
+    this.writeLine(`app.${method}('${path}', ${async}(req, res) => {`)
+    this.indent++
+    
+    if (node.body) {
+      if (Array.isArray(node.body)) {
+        for (const stmt of node.body) {
+          this.generateNode(stmt)
+        }
+      } else {
+        this.generateNode(node.body)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('});')
+  }
+
+  generateMiddlewareUse(node) {
+    if (typeof node === 'string') {
+      this.writeLine(`app.use(${this.translate(node)});`)
+      return
+    }
+    
+    const middleware = node.middleware || node.name
+    
+    if (node.path) {
+      this.writeLine(`app.use('${node.path}', ${this.translate(middleware)});`)
+    } else if (node.call) {
+      const args = (node.arguments || []).map(a => this.generateNode(a)).join(', ')
+      this.writeLine(`app.use(${this.translate(middleware)}(${args}));`)
+    } else {
+      this.writeLine(`app.use(${this.translate(middleware)});`)
+    }
+  }
+
+  generateFileOperation(node) {
+    const operation = this.translate(node.operation)
+    const path = this.generateNode(node.path)
+    
+    switch (node.operation) {
+      case 'lire':
+      case 'read':
+        if (node.sync) {
+          this.writeLine(`const ${node.variable || 'data'} = fs.readFileSync(${path}, 'utf-8');`)
+        } else {
+          this.writeLine(`fs.readFile(${path}, 'utf-8', (err, data) => {`)
+          this.indent++
+          if (node.callback) {
+            this.generateNode(node.callback)
+          }
+          this.indent--
+          this.writeLine('});')
+        }
+        break
+        
+      case 'écrire':
+      case 'write':
+        const content = this.generateNode(node.content)
+        if (node.sync) {
+          this.writeLine(`fs.writeFileSync(${path}, ${content});`)
+        } else {
+          this.writeLine(`fs.writeFile(${path}, ${content}, (err) => {`)
+          this.indent++
+          if (node.callback) {
+            this.generateNode(node.callback)
+          }
+          this.indent--
+          this.writeLine('});')
+        }
+        break
+        
+      case 'supprimer':
+      case 'delete':
+        this.writeLine(`fs.unlink(${path}, (err) => {`)
+        this.indent++
+        if (node.callback) {
+          this.generateNode(node.callback)
+        }
+        this.indent--
+        this.writeLine('});')
+        break
+        
+      case 'existe':
+      case 'exists':
+        this.writeLine(`const ${node.variable || 'exists'} = fs.existsSync(${path});`)
+        break
+    }
+  }
+
+  generateEventListener(node) {
+    const emitter = this.generateNode(node.emitter || { name: 'emitter' })
+    const event = typeof node.event === 'string' ? `'${node.event}'` : this.generateNode(node.event)
+    const method = node.once ? 'once' : 'on'
+    
+    this.writeLine(`${emitter}.${method}(${event}, (${node.params || ''}) => {`)
+    this.indent++
+    
+    if (node.body) {
+      if (Array.isArray(node.body)) {
+        for (const stmt of node.body) {
+          this.generateNode(stmt)
+        }
+      } else {
+        this.generateNode(node.body)
+      }
+    }
+    
+    this.indent--
+    this.writeLine('});')
+  }
+
+  generateStreamOperation(node) {
+    const source = this.generateNode(node.source)
+    const destination = node.destination ? this.generateNode(node.destination) : null
+    
+    switch (node.operation) {
+      case 'pipe':
+      case 'canaliser':
+        this.writeLine(`${source}.pipe(${destination});`)
+        break
+        
+      case 'lire flux':
+      case 'createReadStream':
+        this.writeLine(`const ${node.variable || 'readStream'} = fs.createReadStream(${source});`)
+        break
+        
+      case 'écrire flux':
+      case 'createWriteStream':
+        this.writeLine(`const ${node.variable || 'writeStream'} = fs.createWriteStream(${source});`)
+        break
+    }
+  }
+}
+
+module.exports = {
+  NodeGenerator
+}