diff --git a/knexfile.js b/knexfile.js
index b606d9653eb736b7ee0bee608e57339ad7e171f1..70b1ff709561dd50ca16efabf56d785fc7e6d94c 100644
--- a/knexfile.js
+++ b/knexfile.js
@@ -1,6 +1,9 @@
 /**
- * @file knexfile est un fichier de configuration requis par le module knexjs. Il permet de spécifier le mode de communication avec la BDD, et comprend identifiants et mots de passe.
- * @author Will Jallet
+ * @file Fichier de configuration Knex. Il spécifie la base de donnée à laquelle se connecter, son adresse, le nom 
+ * d'un utilisateur sur le serveur qui a les droits appropriés, et son mot de passe.
+ * 
+ * Le fichier précise également où stocker les fichiers de migrations Knex ainsi que les _seeds_.
+ * @author manifold
  * */
 
 const path = require('path');
diff --git a/src/admin_view/admin_router.js b/src/admin_view/admin_router.js
index 503d8dd5cffc33ed42923e3cd7e962244d3c6dd8..5583cfac38e44a843d15f1e73838fcc9b62d332c 100644
--- a/src/admin_view/admin_router.js
+++ b/src/admin_view/admin_router.js
@@ -1,5 +1,9 @@
 /**
- * @file
+ * @file Ce fichier définit le routage d'URL au sein de l'interface du _backend_.
+ * 
+ * Il définit la page de connexion `/`, le panneau administrateur `/admin` et l'API REST (`/db/:table?`)
+ * permettant de consulter la base de donnée interne à Sigma, via des requêtes construites avec Knex.
+ * @author manifold
  */
 import express from 'express';
 import knex from '../../db/knex_router';
diff --git a/src/graphql/db_utils.js b/src/graphql/db_utils.js
index 3c563028cf22168da048891d4720e728112bb7a8..79d8d10252cc3d7e2bcef78845f7377f4fc6198c 100644
--- a/src/graphql/db_utils.js
+++ b/src/graphql/db_utils.js
@@ -1,5 +1,6 @@
 /**
- * @summary Fonctions pour interagir avec la BDD sigma et le LDAP.
+ * @file Fonctions pour interagir avec la BDD sigma et le LDAP.
+ * @author akka vodol
  */
 import knex from '../../db/knex_router';
 import { renseignerSurUtilisateur, repliquerTOLdesIds, listerGroupes, listerMembres, listerAdministrateurs } from '../ldap/ldap_data';
@@ -9,6 +10,7 @@ export { renseignerSurUtilisateur, repliquerTOLdesIds };
 
 /**
  * @summary Renvoie tous les utilisateurs ayant des droits d'administrateur sur un groupe.
+ * @function
  * @desc Les utilisateurs qui ont un droit d'administrateur sur un groupe sont ses administrateurs et les utilisateurs ayant droit d'admin sur son parent
  * @arg {String} uid - L'uid du groupe dont on veut les administrateurs. 
  * @return {Promise} Retour de requête knex. Promise qui renvera une liste de tous les utilisateurs ayant droit d'admin sur le groupe
@@ -18,9 +20,9 @@ export const getUsersWithAdminRights = (user, groupUID) => {
         if (typeof adminList == "undefined")
             return undefined;
         else
-            return knex('groups').select('parentuid').where('uid', groupUID).then(reqResult => {
-                if (reqResult[0].parentuid)
-                    return getUsersWithAdminRights(user, reqResult[0].parentuid).then(parentAdmins => {
+            return knex('groups').select('parentuid').where('uid', groupUID).then(req => {
+                if (req[0].parentuid)
+                    return getUsersWithAdminRights(user, req[0].parentuid).then(parentAdmins => {
                         return adminList.concat(parentAdmins);
                     });
                 else
diff --git a/src/graphql/schema.js b/src/graphql/schema.js
index f366c0a30f08520921b856e741a425e2292d27af..9e11beabfa0285db9cc38c63ff96e69178f4956a 100644
--- a/src/graphql/schema.js
+++ b/src/graphql/schema.js
@@ -5,7 +5,7 @@
 import { makeExecutableSchema } from 'graphql-tools';
 import { request } from 'https';
 import { assertBinaryExpression } from 'babel-types';
-
+import knex from '../../db/knex_router';
 import typeDefs from './typeDefs';
 
 import * as resolverFuncs from './db_utils';
@@ -54,7 +54,7 @@ const resolvers = {
         },
 
         allPosts: (obj, args, context) => {
-            
+            return knex.select().from('posts');
         },
 
         searchTOL: (obj, args, context) => {
diff --git a/src/graphql/typeDefs.js b/src/graphql/typeDefs.js
index 89778ba3371af1ad528ab271ae77d55202ab0530..5413d10d2f1a85f527632bb016af365bb645e5b7 100644
--- a/src/graphql/typeDefs.js
+++ b/src/graphql/typeDefs.js
@@ -107,32 +107,50 @@ const User = `
 const Group = `
     # Groupes associatifs
     type Group {
+        # Identifiant unique du groupe
         uid: ID
+        # Nom du groupe
         name: String
+        # Site du groupe
         website: String
+        # Jour et heure de création du groupe
         createdAt: String!
         updatedAt: String!
         description: String
+        # École d'origine du groupe
         school: String
+        # Groupe parent
         parent: Group
     }
 `;
 
 const Post = `
     # Publications
-    interface Post {
+    type Post {
         id: ID!
         title: String!
         createdAt: String!
         updatedAt: String!
         # Auteurs de la publication
-        author: [Group]
+        authors: [Group]
         description: String
     }
 `;
 
+const Announcements = `
+    type Announcement implements Post {
+        id: ID!
+        title: String!
+        createdAt: String!
+        updatedAt: String!
+        authors: [Group]
+        description: String
+        views: Int
+    }
+`;
+
 const Events = `
-    # Événements
+    # Événements organisés par un ou plusieurs groupes.
     type Event implements Post {
         id: ID!
         # Intitulé de l'événement
@@ -144,14 +162,15 @@ const Events = `
         startTime: String!
         endTime: String!
         # Organisateurs
-        author: [Group]
-        # Personnes qui y participent
+        authors: [Group]
+        # Personnes qui participent à l'événement.
         participants: [User]
         description: String
     }
 `;
 
 const Requests = `
+    # Demandes effectuées au groupe.
     type Requests {
         userJoin: [userJoinGroup]
         eventJoin: [groupJoinEvent]
@@ -162,6 +181,7 @@ const Requests = `
         user: User
     }
 
+    # Demande 
     type groupJoinEvent {
         event: Event
         groupWantingToJoin: Group
@@ -176,5 +196,4 @@ const Requests = `
 `;
 
 const typeDefs = [RootTypes, Group, User, Post, Events, subMutations, subQueries, Requests];
-
-export default typeDefs;
\ No newline at end of file
+export default typeDefs;
diff --git a/src/index.js b/src/index.js
index 7b1ad75197684ea89f7dfad01a1522b7e10bd1dc..48992cbe68c8b9b2bbcfee99377e07fd57ee1870 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,5 +1,6 @@
 /**
- * @file Point d'entrée de webpack
+ * @file Lance le serveur configuré dans {@link server.js} en y ajoutant le routeur d'URL.
+ * @author manifold
  */
 import server from './server';
 import colors from 'colors';
diff --git a/src/ldap/ldap_auth.js b/src/ldap/ldap_auth.js
deleted file mode 100644
index 6c4effd01581516d9fdd2f55e661112fce0ad4a5..0000000000000000000000000000000000000000
--- a/src/ldap/ldap_auth.js
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * @file Ce fichier gère les authentifications avec le LDAP précisé dans config.json à l'aide de passport-ldapauth.
- * @author Wang
- */
-import passport from 'passport';
-import LdapStrategy from 'passport-ldapauth';
-import session from 'express-session';
-import fs from 'fs';
-import path from 'path';
-
-let configPath = path.resolve('./','ldap_config.json');
-let config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-
-passport.use(new LdapStrategy({
-    server: {
-        url: config.ldap.server,
-        searchBase: config.ldap.searchBase,
-        searchFilter: config.ldap.searchFilter
-    }
-}
-));
-
-function setupLdapAuth(server) {
-    
-    // Define new login strategy
-    server.use(session({ 
-        secret: config.sessionSecret,
-        //store: a modifier avant de lancer en prod
-        //voir les autres options
-        resave: true,
-        saveUninitialized: false
-    }));
-    server.use(passport.initialize());
-    server.use(passport.session());
-
-    passport.serializeUser(function(user, done) {
-        done(null, user);
-    });
-
-    passport.deserializeUser(function(user, done) {
-        done(null, user);
-    });
-}
-
-export default setupLdapAuth;
diff --git a/src/ldap/ldap_data.js b/src/ldap/ldap_data.js
index b33dff8510264e64471c5e0dc1923422f90549d9..a16121ac409b7b59a10be116215bdf03d32d2ca7 100644
--- a/src/ldap/ldap_data.js
+++ b/src/ldap/ldap_data.js
@@ -33,7 +33,8 @@ var client = ldap.createClient({ url: config.ldap.server});
 
 /**
  * @summary Fonction qui sert à s'identifier sur le LDAP. Renvoit rien.
- * @desc Assez important en terme de sécurité, de gestion de conflit, et de droit d'accès. Méthode ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode bind).
+ * @desc Assez important en terme de sécurité, de gestion de conflit, et de droit d'accès. Méthode ldapjs 
+ * (voir [`Client API`](http://ldapjs.org/client.html) méthode bind).
  * @arg {Object} user - Utilisateur de la forme suivante :
  * @arg {string} user[uid] - User identifier
  * @arg {string} user[password] - Mot de passe
@@ -45,13 +46,20 @@ function connecterLDAP(user) {
 
 /**
  * @summary Fonction qui interroge le LDAP selon un protocole spécifié en argument et renvoit les valeurs trouvées.
- * @desc Cette fonction appelle {@link bind} pour authentifier l'utilisateur pour authentifier l'utilisateur puis rompts la connexion. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `rechercherLDAP(user, ...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @desc Cette fonction appelle {@link bind} pour authentifier l'utilisateur pour authentifier l'utilisateur
+ * puis rompt la connexion. Cette fonction utilise une Promise pour être asynchrone ; elle renvoie la promesse 
+ * d'une réponse puis traite la demande avec [`ldapjs`](http://ldapjs.org) 
+ * (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant 
+ * un schéma `rechercherLDAP(user, ...).then((res) => { truc avec res });`. Cette fonction fait une demande 
+ * au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met 
+ * dans une liste, et renvoit la liste à l'issue (event end).
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} base - DN de l'emplacement de la requête
  * @arg {string} filter - Filtre logique de la recherche (format [`RFC2254`](https://tools.ietf.org/search/rfc2254)) déjà passé au ldapEscape
  * @arg {string} filter_dic[key] - Vraie valeur pertinente de la recherche
  * @arg {string[]} attributes - Liste des attributs qui figureront dans le résultat final
- * @return {Promise(Object[])} Résultats de la recherche ; soit une liste de valeurs d'attributs, soit une liste de dictionnaires si on veut plus d'un attribut (les clés du dictionnaire sont celles du LDAP) 
+ * @return {Promise(Object[])} Résultats de la recherche ; soit une liste de valeurs d'attributs, 
+ * soit une liste de dictionnaires si on veut plus d'un attribut (les clés du dictionnaire sont celles du LDAP) 
  */
 function rechercherLDAP(user, base, filter, attributes) {
     return new Promise(function(resolve, reject) {
@@ -146,53 +154,62 @@ function ajouterLDAP(user, dn, vals) {
 
 /**
  * @summary Fonction qui interroge le LDAP et retrouve les groupes dont un individu est membre.
- * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json, entrée lg. Il faut l'appeler selon un schéma `listGroups(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json, entrée lg. 
+ * Il faut l'appeler selon un schéma 
+ * `listGroups(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} uid - Identifiant de l'individu à interroger (le plus souvent prenom.nom, parfois l'année, supposé valide)
  * @return {Promise(string[])} Liste des uid de groupes (noms flat des groupes) où l'id fourni est membre
  */
 function listerGroupes(user, uid) {
     return new Promise(function(resolve, reject) {
-        rechercherLDAP(user,config.key_id+"="+uid+","+config.dn_users, ldapEscape.filter(config.lg.filtre, { id : uid }), config.lg.attributs).then(res => resolve(res[0]));
+        rechercherLDAP(user,config.key_id+"="+uid+","+config.dn_users, ldapEscape.filter(config.lg.filtre, { id : uid }), config.lg.attributs)
+            .then(res => resolve(res[0]));
     });
 }
 
 /**
  * @summary Fonction qui interroge le LDAP et retrouve la liste des membres d'un groupe.
- * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listMembers(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json.
+ * Il faut l'appeler selon un schéma `listMembers(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
  * @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
  */
 function listerMembres(user, gid) {
     return new Promise(function(resolve, reject) {
-        rechercherLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.lm.filtre, { id: gid }), config.lm.attributs).then(res => resolve(res[0]));
+        rechercherLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.lm.filtre, { id: gid }), config.lm.attributs)
+            .then(res => resolve(res[0]));
     });
 }
 
 /**
  * @summary Fonction qui interroge le LDAP et retrouve la liste des admins d'un groupe.
- * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `listAdmins(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. 
+ * Il faut l'appeler selon un schéma `listAdmins(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} gid - Identifiant du groupe à interroger (le plus souvent nom du groupe en minuscule)
  * @return {Promise(string[])} Liste des uid des membres où l'id fournie est membre (noms flat des groupes)
  */
 function listerAdministrateurs(user, gid) {
     return new Promise(function(resolve, reject) {
-        rechercherLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.la.filtre, { id: gid }), config.la.attributs).then(res => resolve(res[0]));
+        rechercherLDAP(user, config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.la.filtre, { id: gid }), config.la.attributs)
+            .then(res => resolve(res[0]));
     });
 }
  
 /**
  * @summary Fonction qui interroge le LDAP au sujet d'un uid particulier et qui renvoit toutes ses infos.
- * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. Il faut l'appeler selon un schéma `rens(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
+ * @desc Cette fonction utilise {@link rechercherLDAP} avec un dictionnaire prédéfini dans config.json. 
+ * Il faut l'appeler selon un schéma `rens(...).then((res) => { truc avec res });`. Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} uid - Identifiant de l'utilisateur
  * @return {Promise(Object[])} Informations recueillies ; renvoie une liste de dictionnaire avec les mêmes clés que dans le TOL, voir config.json.
  */
 function renseignerSurUtilisateur(user, uid) {
     return new Promise(function(resolve, reject) {
-        rechercherLDAP(user, config.key_id+"="+uid+","+config.dn_users, ldapEscape.filter(config.rs.filtre, { id: uid }), config.rs.attributs).then(res => resolve(res));
+        rechercherLDAP(user, config.key_id+"="+uid+","+config.dn_users, ldapEscape.filter(config.rs.filtre, { id: uid }), config.rs.attributs)
+            .then(res => resolve(res));
     });
 }
 
@@ -201,8 +218,14 @@ function renseignerSurUtilisateur(user, uid) {
 //------------------------------------------------------------------------------------------------------------------------
 
 /**
- * @summary Fonction qui interroge le LDAP et retrouve les groupes (voir LDAP) qui ressemblent à l'input. Etape 0 vers un vrai TOL (Trombino On Line).
- * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `trouverGroupe(user, input).then((res) => { truc avec res });`. Cette fonction utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. Elle utilise LDAPEscape pour éviter les injections.
+ * @summary Fonction qui interroge le LDAP et retrouve les groupes (voir LDAP) qui ressemblent à l'input. 
+ * Etape 0 vers un vrai TOL (Trombino On Line).
+ * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. 
+ * Accepte des champs exacts ou incomplets mais pas approximatifs et ne gère pas l'auto-complete. 
+ * Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis 
+ * traite la demande. Il faut l'appeler suivant un schéma `trouverGroupe(user, input).then((res) => { truc avec res });`. 
+ * Cette fonction utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. 
+ * Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} input - String entré par l'utilisateur qui ressemble au nom du groupe.
  * @return {Promise(string[])} Liste des uid de groupes dont le nom ressemble à l'input
@@ -224,8 +247,14 @@ function trouverGroupes(user, input) {
 }
 
 /**
- * @summary Fonction qui interroge le LDAP et retrouve le groupe qui ressemblent à l'input et qui correspond. Etape 0 vers un vrai TOL (Trombino On Line).
- * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `trouverGroupe(user, input).then((res) => { truc avec res });`. Cette fonction utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. Elle utilise LDAPEscape pour éviter les injections.
+ * @summary Fonction qui interroge le LDAP et retrouve le groupe qui ressemblent à l'input et qui correspond. 
+ * Etape 0 vers un vrai TOL (Trombino On Line).
+ * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. Accepte des 
+ * champs exacts ou incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise 
+ * une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut 
+ * l'appeler suivant un schéma `trouverGroupe(user, input).then((res) => { truc avec res });`. Cette fonction 
+ * utilise aussi config.json. MEF Timeout pour des recherches trop vagues. Renvoit une liste d'uid. Elle utilise 
+ * LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} input - String entré par l'utilisateur qui ressemble au nom du groupe.
  * @arg {string} type - String aux valeurs prédéfinies dans ldap_config.
@@ -238,9 +267,10 @@ function trouverGroupesParTypes(user, input, type) {
             let gidtyList = [];
             gidList.forEach(gid => {
                 // Nouvelle recherche à partir des résultats de la première
-                rechercherLDAP(config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.tgty.filter, { ty: type }), config.key_id).then(res => {
-                    if (res.length!=0) { gidtyList.push(res); }
-                });
+                rechercherLDAP(config.key_id+"="+gid+","+config.dn_groups, ldapEscape.filter(config.tgty.filter, { ty: type }), config.key_id)
+                    .then(res => {
+                        if (res.length!=0) { gidtyList.push(res); }
+                    });
             });
             resolve(gidtyList);
         });
@@ -248,8 +278,15 @@ function trouverGroupesParTypes(user, input, type) {
 }
 
 /**
- * @summary Fonction qui interroge le LDAP et retrouve certains attributs des paxs validant les critères de recherche. Première étape vers vrai TOL (Trombino On Line).
- * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets pour la plupart des champs mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`.Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire. Elle utilise LDAPEscape pour éviter les injections.
+ * @summary Fonction qui interroge le LDAP et retrouve certains attributs des paxs validant les critères de 
+ * recherche. Première étape vers vrai TOL (Trombino On Line).
+ * @desc Cette fonction utilise {@link rechercherLDAP} mais avec un filtre généré à la volée. Accepte des champs 
+ * exacts ou incomplets pour la plupart des champs mais pas approximatifs et ne gère pas l'auto-complete. Cette 
+ * fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. 
+ * Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`.Cette fonction fait une demande 
+ * au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) 
+ * le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoie 
+ * aussi une liste de dictionnaire. Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {Object} data - Dictionnaire contenant les données nécessaires à la recherche  avec des champs lisibles (voir config).
  * @arg {string} data[key] - La plupart des champs sont directement des string.
@@ -284,8 +321,15 @@ function repliquerTOLModulable(user, data, return_values) {
 }
 
 /**
- * @summary Fonction qui interroge le LDAP et retrouve les uid des paxs validant les critères de recherche. Première étape vers vrai TOL (Trombino On Line).
- * @desc Cette fonction utilise {@link repliquerTOLModulable} mais avec un filtre généré à la volée. Accepte des champs exacts ou incomplets pour la plupart des champs mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`.Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire. Elle utilise LDAPEscape pour éviter les injections.
+ * @summary Fonction qui interroge le LDAP et retrouve les uid des paxs validant les critères de recherche. 
+ * Première étape vers vrai TOL (Trombino On Line).
+ * @desc Cette fonction utilise {@link repliquerTOLModulable} mais avec un filtre généré à la volée. Accepte 
+ * des champs exacts ou incomplets pour la plupart des champs mais pas approximatifs et ne gère pas l'auto-complétion. 
+ * Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la 
+ * demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`.Cette fonction fait une 
+ * demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat 
+ * (event `SearchEntry`) le met dans une liste, et renvoit la liste à l'issue (event `end`). MEF Timeout pour des recherches trop vagues. 
+ * Renvoie aussi une liste de dictionnaire. Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {Object} data - Dictionnaire contenant les données nécessaires à la recherche  avec des champs lisibles (voir config).
  * @arg {string} data[key] - La plupart des champs sont directement des string.
@@ -300,8 +344,18 @@ function repliquerTOLdesIds(user, data) {
 }
 
 /**
- * @summary Fonction qui interroge le LDAP et retrouve les paxs validant les critères de recherche. Bien mais vite inutilisable car demande trop au LDAP et renvoie des erreurs de type size limit. Préférer idTOL puis stalk au cas par cas.
- * @desc Cette fonction utilise {@link repliquerTOLModulable} avec un filtre généré à la volée. Accepte des champs incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`. Aucun bind n'est nécessaire donc pas d'identifiant ou de mot de passe à passer. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire. Utilise aussi requeteLDAP. Elle utilise LDAPEscape pour éviter les injections.
+ * @summary Fonction qui interroge le LDAP et retrouve les paxs validant les critères de recherche. 
+ * Bien mais vite inutilisable car demande trop au LDAP et renvoie des erreurs de type size limit. 
+ * Préférer idTOL puis stalk au cas par cas.
+ * @desc Cette fonction utilise {@link repliquerTOLModulable} avec un filtre généré à la volée. Accepte 
+ * des champs incomplets mais pas approximatifs et ne gère pas l'auto-complete. Cette fonction utilise 
+ * une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande. Il 
+ * faut l'appeler suivant un schéma `TOL(uid).then((res) => { truc avec res });`. Aucun bind n'est 
+ * nécessaire donc pas d'identifiant ou de mot de passe à passer. Cette fonction fait une demande au 
+ * LDAP qu'elle filtre selon un schéma généré à la volée à partir de config.json et à chaque résultat 
+ * (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end). MEF Timeout 
+ * pour des recherches trop vagues. Renvoit aussi une liste de dictionnaire. Utilise aussi requeteLDAP. 
+ * Elle utilise LDAPEscape pour éviter les injections.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} c0 - Prénom
  * @arg {string} c1 - Nom
@@ -330,7 +384,11 @@ function repliquerTOL(user, data) {
 
 /**
  * @summary Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeurs en argument.
- * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode add). Il faut l'appeler suivant un schéma `creerUtilisateur(...).then((res) => { truc avec res });`. Cette fonction fait une utilisation massive d'eval pour anonymiser son code ; c'est mal et cela suppose que beaucoup de soins ont été pris lors de l'escape de ses paramètres.
+ * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une 
+ * réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode add). 
+ * Il faut l'appeler suivant un schéma `creerUtilisateur(...).then((res) => { truc avec res });`. Cette fonction 
+ * fait une utilisation massive d'eval pour anonymiser son code ; c'est mal et cela suppose que beaucoup de soins 
+ * ont été pris lors de l'escape de ses paramètres.
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {Object} data - Dictionnaire des informations utilisateurs (voir détail des champs dans config.json)
  * @return {boolean} `true` si la modification s'est bien déroulée, false sinon
@@ -354,7 +412,11 @@ function repliquerTOL(user, data) {
 
 /**
  * @summary TBC Fonction qui va plonger dans le LDAP et modifier un certain jeu de valeur en argument.
- * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse 
+ * puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). 
+ * Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction 
+ * fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat 
+ * (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} gid - Identifiant du group
  * @arg {string} nom - Nom commun du group
@@ -380,7 +442,11 @@ function creerGroupeLDAP(user, gid, nom, status, admins, members) {
 
 /**
  * @summary TBC Fonction qui va modifier un certain jeu de valeur en argument dans le LDAP.
- * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
+ * @desc Cette fonction utilise une Promise pour être asynchrone ; elle renvoit la promesse d'une 
+ * réponse puis traite la demande avec ldapjs (voir [`Client API`](http://ldapjs.org/client.html) méthode search). 
+ * Il faut l'appeler suivant un schéma `modifierLDAP(...).then((res) => { truc avec res });`. Cette fonction 
+ * fait une demande au LDAP qu'elle filtre selon un schéma prédéfini dans `dic` et à chaque résultat 
+ * (event SearchEntry) le met dans une liste, et renvoit la liste à l'issue (event end).
  * @arg {Object} user - Utilisateur de la forme nécessaire à {@link connecterLDAP}
  * @arg {string} gid - Identifiant du group
  * @arg {string} nom - Nom commun du group
diff --git a/src/server.js b/src/server.js
index db12f1e4d82ca1c04fcc44bd5e368788ad8590e3..7ead8aa8f0c9e41a5f6f7475084a52de6454704d 100644
--- a/src/server.js
+++ b/src/server.js
@@ -1,5 +1,9 @@
 /** 
- * @file Cree le serveur express avec tous les middleware qui vont bien
+ * @file Initialise et configure le serveur Express sur lequel tourne le back.
+ * 
+ * La configuration inclut tout le _middleware_ définissant les API et les services
+ * nécessaire utilisés, comme `express-session`, GraphiQL, GraphQL Voyager.
+ * @author manifold
 */
 import express from 'express';
 import schema from './graphql/schema';