nodefony 7.0.0-beta.2 → 7.0.0-beta.21

package/kernel/reader.es6

@@ -1,15 +1,15 @@
-let defaultSetting = {
+const defaultSetting = {
   parserXml: {
-    //explicitCharkey: true,
+    // explicitCharkey: true,
     explicitArray: true,
     explicitRoot: false,
     mergeAttrs: true
   },
   readFile: {
-    encoding: 'utf8'
+    encoding: "utf8"
   },
   twig: {
-    'twig options': {
+    "twig options": {
       async: false,
       cache: true
     },
@@ -19,16 +19,16 @@ let defaultSetting = {
 };
 
 const load = function (name, pathFile) {
-  let mypath = pathFile;
-  let ext = path.extname(pathFile);
-  let basename = path.basename(pathFile);
-  let plug = this.plugins[name];
+  const mypath = pathFile;
+  const ext = path.extname(pathFile);
+  const basename = path.basename(pathFile);
+  const plug = this.plugins[name];
   if (!plug) {
-    this.log("DROP FILE : " + mypath + " NO PLUGIN FIND : " + name, "WARNING");
+    this.log(`DROP FILE : ${mypath} NO PLUGIN FIND : ${name}`, "WARNING");
     return null;
   }
-  let myName = Array.prototype.shift.call(arguments);
-  let file = Array.prototype.shift.call(arguments);
+  const myName = Array.prototype.shift.call(arguments);
+  const file = Array.prototype.shift.call(arguments);
   let txt = null;
   try {
     switch (ext) {
@@ -37,9 +37,9 @@ const load = function (name, pathFile) {
       Array.prototype.unshift.call(arguments, txt);
       if (plug.xml) {
         return plug.xml.apply(this, arguments);
-      } else {
-        return this.pluginConfig.xml.apply(this, arguments);
       }
+      return this.pluginConfig.xml.apply(this, arguments);
+
       break;
     case ".json":
       txt = this.readFileSync(file);
@@ -51,9 +51,9 @@ const load = function (name, pathFile) {
       Array.prototype.unshift.call(arguments, txt);
       if (plug.yml) {
         return plug.yml.apply(this, arguments);
-      } else {
-        return this.pluginConfig.yml.apply(this, arguments);
       }
+      return this.pluginConfig.yml.apply(this, arguments);
+
       break;
     case ".js":
     case ".es6":
@@ -64,20 +64,19 @@ const load = function (name, pathFile) {
       case new RegExp("^(.+)Controller.js$").test(basename):
         if (plug.annotations) {
           return plug.annotations.apply(this, arguments);
-        } else {
-          return this.pluginConfig.annotations.apply(this, arguments);
         }
+        return this.pluginConfig.annotations.apply(this, arguments);
+
         break;
       default:
         if (plug.javascript) {
           return plug.javascript.apply(this, arguments);
-        } else {
-          return this.pluginConfig.javascript.apply(this, arguments);
         }
+        return this.pluginConfig.javascript.apply(this, arguments);
       }
       break;
     default:
-      this.log("DROP FILE : " + mypath + " PLUGIN " + myName + " NO EXTENTION FIND : " + ext, "WARNING");
+      this.log(`DROP FILE : ${mypath} PLUGIN ${myName} NO EXTENTION FIND : ${ext}`, "WARNING");
     }
   } catch (e) {
     throw e;
@@ -97,8 +96,7 @@ const load = function (name, pathFile) {
  *
  */
 class Reader extends nodefony.Service {
-
-  constructor(container, localSettings) {
+  constructor (container, localSettings) {
     super("READER", container);
     this.settings = nodefony.extend(true, {}, defaultSetting, localSettings);
     this.plugins = {};
@@ -110,18 +108,18 @@ class Reader extends nodefony.Service {
     this.annotations = new nodefony.Annotations(container, this.notificationsCenter);
   }
 
-  pluginConfig() {
+  pluginConfig () {
     const json = function (file, bundle, callback, parser) {
       if (parser) {
         file = this.render(file, parser.data, parser.options);
       }
       try {
-        let json = JSON.parse(file);
+        const json = JSON.parse(file);
         if (callback) {
           callback(json);
         }
       } catch (e) {
-        throw (e);
+        throw e;
       }
     };
     const yml = function (file, bundle, callback, parser) {
@@ -129,12 +127,12 @@ class Reader extends nodefony.Service {
         file = this.render(file, parser.data, parser.options);
       }
       try {
-        let json = yaml.load(file);
+        const json = yaml.load(file);
         if (callback) {
           callback(json);
         }
       } catch (e) {
-        throw (e);
+        throw e;
       }
     };
     const xml = function (file, bundle, callback, parser) {
@@ -143,7 +141,7 @@ class Reader extends nodefony.Service {
       }
       this.xmlParser.parseString(file, (error, node) => {
         if (error) {
-          throw (error);
+          throw error;
         }
         if (callback) {
           callback(this.xmlToJson(node));
@@ -166,19 +164,19 @@ class Reader extends nodefony.Service {
     };
 
     const annotations = function (file) {
-      throw new Error("Annotation is not defined for this file " + file);
+      throw new Error(`Annotation is not defined for this file ${file}`);
     };
 
     return {
-      xml: xml,
-      json: json,
-      yml: yml,
-      javascript: javascript,
-      annotations: annotations
+      xml,
+      json,
+      yml,
+      javascript,
+      annotations
     };
   }
 
-  readFile(file, localSettings) {
+  readFile (file, localSettings) {
     if (!file) {
       throw new Error("READE no file path in readFile");
     }
@@ -197,7 +195,7 @@ class Reader extends nodefony.Service {
     });
   }
 
-  readFileSync(file, localSettings) {
+  readFileSync (file, localSettings) {
     try {
       return fs.readFileSync(file, nodefony.extend({}, this.settings.readFile, localSettings));
     } catch (e) {
@@ -210,7 +208,7 @@ class Reader extends nodefony.Service {
    *  @method render
    *
    */
-  render(str, data) {
+  render (str, data) {
     return this.engine.twig({
       data: str
     }).render(data);
@@ -220,9 +218,9 @@ class Reader extends nodefony.Service {
    *  @method loadPlugin
    *
    */
-  loadPlugin(name, plugin) {
+  loadPlugin (name, plugin) {
     this.plugins[name] = plugin;
-    let context = this;
+    const context = this;
     return function () {
       Array.prototype.unshift.call(arguments, name);
       return load.apply(context, arguments);
@@ -233,16 +231,16 @@ class Reader extends nodefony.Service {
    *  @method xmlToJson
    *
    */
-  xmlToJson(node) {
-    let json = {};
+  xmlToJson (node) {
+    const json = {};
     if (node instanceof Array) {
       for (let key = 0; key < node.length; key++) {
-        var param = null;
+        let param = null;
         if (node[key] instanceof Object) {
           if (node[key].id) {
             json[node[key].id] = {};
             for (param in node[key]) {
-              if (param !== 'id') {
+              if (param !== "id") {
                 if (node[key][param] instanceof Array) {
                   json[node[key].id][param] = node[key][param];
                   for (let elm = 0; elm < json[node[key].id][param].length; elm++) {
@@ -261,7 +259,7 @@ class Reader extends nodefony.Service {
             json[node[key].key] = node[key]._;
           } else if (node[key].key && !node[key]._) {
             for (param in node[key]) {
-              if (param !== 'key') {
+              if (param !== "key") {
                 json[node[key].key] = {};
                 json[node[key].key][param] = this.xmlToJson(node[key][param]);
               }
@@ -275,13 +273,13 @@ class Reader extends nodefony.Service {
       }
       return json;
     } else if (node instanceof Object) {
-      for (let mykey in node) {
+      for (const mykey in node) {
         json[mykey] = this.xmlToJson(node[mykey]);
       }
       return json;
-    } else {
-      return node;
     }
+    return node;
+
     return json;
   }
 }

package/kernel/security/encoder.es6

@@ -1,15 +1,17 @@
 class Encoder {
-  constructor(name, options = {}) {
+  constructor (name, options = {}) {
     this.name = name;
     this.settings = options;
   }
-  async encodePassword( /*raw, salt*/ ) {
-    throw new Error(`Encoder class must overload encodePassword method`);
+
+  async encodePassword (/* raw, salt*/) {
+    throw new Error("Encoder class must overload encodePassword method");
   }
-  async isPasswordValid( /*encoded, raw, salt*/ ) {
-    throw new Error(`Encoder class must overload isPasswordValid method`);
+
+  async isPasswordValid (/* encoded, raw, salt*/) {
+    throw new Error("Encoder class must overload isPasswordValid method");
   }
 }
 
 nodefony.Encoder = Encoder;
-module.exports = Encoder;
+module.exports = Encoder;

package/kernel/security/factories/factory.es6

@@ -1,18 +1,18 @@
 class Factory extends nodefony.Service {
-
-  constructor(name, security, settings = {}) {
+  constructor (name, security, settings = {}) {
     super(name, security.container, security.notificationsCenter);
     this.settings = settings || {};
     this.security = security;
-    this.providerName = this.settings.provider  || this.security.providerName;
+    this.providerName = this.settings.provider || this.security.providerName;
     this.provider = null;
     this.kernel.once("onReady", () => {
-      //console.log("onReady factory", this.name, this.providerName)
+      // console.log("onReady factory", this.name, this.providerName)
       if (!this.providerName) {
         if (this.providerName !== false) {
           this.providerName = this.security.providerName;
         }
       }
+      // eslint-disable-next-line no-negated-condition
       if (this.providerName !== this.security.providerName) {
         if (this.providerName) {
           this.provider = this.security.getProvider(this.providerName);
@@ -23,90 +23,87 @@ class Factory extends nodefony.Service {
     });
   }
 
-  logger(pci, severity, msgid, msg) {
+  logger (pci, severity, msgid, msg) {
     if (!msgid) {
       msgid = `\x1b[36mFACTORY ${this.name}\x1b[0m`;
     }
     return super.logger(pci, severity, msgid, msg);
   }
 
-  handle(context) {
+  handle (context) {
     return this.authenticate(context)
-      .then(token => {
-        return token;
-      })
-      .catch(error => {
+      .then((token) => token)
+      .catch((error) => {
         throw error;
       });
   }
 
-  logout(context) {
-    if ( context.session){
+  logout (context) {
+    if (context.session) {
       this.log(`Factory ${this.name} :  invalide session`, "DEBUG");
       return context.session.invalidate()
-        .then(() => {
-          return context ;
-        }).catch(e => {
-          throw e ;
+        .then(() => context)
+        .catch((e) => {
+          throw e;
         });
     }
     return new Promise((resolve) => {
-      return resolve(context);
+      resolve(context);
     });
   }
 
-  authenticate(context) {
+  authenticate (context) {
     return new Promise((resolve, reject) => {
-      this.log("FACTORY AUTHENTICATION " + this.name, "DEBUG");
+      this.log(`FACTORY AUTHENTICATION ${this.name}`, "DEBUG");
       let token = null;
       try {
         token = this.createToken(context, this.provider);
         if (!this.supportsToken(token)) {
-          return reject(new nodefony.Error("Factory " + this.name + " Token Unauthorized !! "));
+          reject(new nodefony.Error(`Factory ${this.name} Token Unauthorized !! `));
         }
-        return this.authenticateToken(token)
-          .then((token) => {
+        this.authenticateToken(token)
+          .then((Token) => {
             token.setAuthenticated(true);
             token.setFactory(this.name);
-            return resolve(token);
-          }).catch((e) => {
-            return reject(e);
-          });
+            return resolve(Token);
+          })
+          .catch((e) => reject(e));
       } catch (e) {
-        return reject(e);
+        reject(e);
       }
     });
   }
 
-  createToken(context = null, provider = null) {
+  createToken (context = null, provider = null) {
     let token = null;
     if (context.metaSecurity) {
       if (context.metaSecurity.token && context.metaSecurity.token.user) {
+        // eslint-disable-next-line new-cap
         token = new nodefony.security.tokens.userPassword(context.metaSecurity.token.user);
         token.unserialize(context.metaSecurity.token);
       }
     } else {
+      // eslint-disable-next-line new-cap
       token = new nodefony.security.tokens.userPassword();
     }
     token.setProvider(provider || this.provider);
     return token;
   }
 
-  supportsToken( /*token*/ ) {
+  supportsToken (/* token*/) {
     return true;
   }
 
-  authenticateToken(token, provider) {
+  authenticateToken (token, provider) {
     if (provider) {
       return provider.authenticate(token);
-    } else {
-      if (!this.provider) {
-        return new Promise((resolve) => {
-          return resolve(token);
-        });
-      }
-      return this.provider.authenticate(token);
     }
+    if (!this.provider) {
+      return new Promise((resolve) => {
+        resolve(token);
+      });
+    }
+    return this.provider.authenticate(token);
   }
 }
 

package/kernel/security/factories/passeportFactory.es6

@@ -1,18 +1,17 @@
 class passeportFactory extends nodefony.Factory {
-
-  constructor(name, security, settings) {
+  constructor (name, security, settings) {
     super(name, security, settings);
 
-    //this.passport = security.firewall.passport;
+    // this.passport = security.firewall.passport;
     const passport = security.firewall.newPassport();
-    this.passport = passport.framework(security.firewall.nodefonyPassport(security.firewall));
-    //console.log(this.passport)
+    this.passport = passport.framework(security.firewall.nodefonyPassport(security.firewall, passport));
 
     this.getStrategy(this.settings)
       .then((strategy) => {
+        // eslint-disable-next-line no-underscore-dangle
         if (this.name in this.passport._strategies) {
           this.log(`Passport Strategy ${this.name} Already Defined in firewall !!!
-            ${clc.green( "Only one Factory with passport strategy type must be use in firewall config")}
+            ${clc.green("Only one Factory with passport strategy type must be use in firewall config")}
             Secure Area  : ${clc.blue(security.name)}
             Factory  : ${clc.blue(this.name)}
             Settings : ${clc.blue(util.inspect(this.settings))}
@@ -22,23 +21,23 @@ class passeportFactory extends nodefony.Factory {
         if (this.strategy) {
           this.passport.use(this.strategy);
         }
-      }).catch((e) => {
+      })
+      .catch((e) => {
         this.log(e, "ERROR");
         throw e;
       });
   }
 
-  getStrategy( /*options*/ ) {
-    return new Promise((resolve, reject) => {
-      return reject(new Error("Passport Factory must redefine getStrategy method"));
-    });
+  getStrategy (/* options*/) {
+    // eslint-disable-next-line no-promise-executor-return
+    return new Promise((resolve, reject) => reject(new Error("Passport Factory must redefine getStrategy method")));
   }
 
-  authenticate(context) {
+  authenticate (context) {
     return new Promise((resolve, reject) => {
       try {
         this.passport.authenticate(this.name, {
-          session: false,
+          session: false
         })(context, (error, token) => {
           if (error) {
             return reject(error);
@@ -52,7 +51,7 @@ class passeportFactory extends nodefony.Factory {
           return resolve(null);
         });
       } catch (error) {
-        return reject(error);
+        reject(error);
       }
     });
   }

package/kernel/security/provider.es6

@@ -1,19 +1,18 @@
 class Provider extends nodefony.Service {
-
-  constructor(name, manager) {
+  constructor (name, manager) {
     super(name, manager.container);
     this.manager = manager;
     this.encoder = null;
   }
 
-  log(pci, severity, msgid, msg) {
+  log (pci, severity, msgid, msg) {
     if (!msgid) {
-      msgid = "PROVIDER " + this.name;
+      msgid = `PROVIDER ${this.name}`;
     }
     return super.log(pci, severity, msgid, msg);
   }
 
-  authenticate(token) {
+  authenticate (token) {
     return new Promise((resolve, reject) => {
       if (token && this.supports(token)) {
         return this.loadUserByUsername(token.getUsername())
@@ -28,30 +27,29 @@ class Provider extends nodefony.Service {
               return reject(new nodefony.Error(`user ${token.getUsername()} Incorrect password`, 401));
             }
             return reject(new nodefony.Error(`user ${token.getUsername()} not found `));
-          }).catch((error) => {
-            return reject(error);
-          });
+          })
+          .catch((error) => reject(error));
       }
-      return reject(new nodefony.Error("The token is not supported by this authentication provider " + this.name));
+      return reject(new nodefony.Error(`The token is not supported by this authentication provider ${this.name}`));
     });
   }
 
-  async loadUserByUsername( /*username*/ ) {
+  async loadUserByUsername (/* username*/) {
     throw new nodefony.Error(`Provider : ${this.name} loadUserByUsername method  not defined`);
   }
 
-  async isPasswordValid(raw, encoded) {
+  async isPasswordValid (raw, encoded) {
     return encoded === raw;
   }
 
-  async refreshUser(user) {
+  async refreshUser (user) {
     if (user instanceof nodefony.User) {
       return await this.loadUserByUsername(user.getUsername());
     }
     throw new nodefony.Error("refreshUser bad user type");
   }
 
-  supports( /*token*/ ) {
+  supports (/* token*/) {
     return true;
   }
 }

package/kernel/security/providers/chainProvider.es6

@@ -1,8 +1,6 @@
 module.exports = nodefony.registerProvider("chainProvider", () => {
-
   class chainProvider extends nodefony.Provider {
-
-    constructor(manager, config) {
+    constructor (manager, config) {
       super("chainProvider", manager);
       this.config = config;
       this.providers = [];
@@ -17,8 +15,8 @@ module.exports = nodefony.registerProvider("chainProvider", () => {
       });
     }
 
-    setProvider(name) {
-      let provider = this.manager.getProvider(name);
+    setProvider (name) {
+      const provider = this.manager.getProvider(name);
       if (provider) {
         this.providers.push(provider);
         this.nbProviders++;
@@ -27,7 +25,7 @@ module.exports = nodefony.registerProvider("chainProvider", () => {
       }
     }
 
-    authenticateProviders(token, index = 1) {
+    authenticateProviders (token, index = 1) {
       return new Promise((resolve, reject) => {
         if (this.nbProviders) {
           try {
@@ -55,26 +53,18 @@ module.exports = nodefony.registerProvider("chainProvider", () => {
       });
     }
 
-    authenticate(token) {
-      return new Promise((resolve, reject) => {
-        return this.authenticateProviders(token)
-          .then((token) => {
-            return resolve(token);
-          })
-          .catch((e) => {
-            return reject(e);
-          });
-      });
+    authenticate (token) {
+      return new Promise((resolve, reject) => this.authenticateProviders(token)
+        .then((token) => resolve(token))
+        .catch((e) => reject(e)));
     }
 
-    loadUsersByUsername(username, index = 1) {
+    loadUsersByUsername (username, index = 1) {
       return new Promise((resolve, reject) => {
         if (this.provider.length) {
           try {
             return this.provider[index - 1].loadUserByUsername(username)
-              .then((user) => {
-                return resolve(user);
-              })
+              .then((user) => resolve(user))
               .catch((e) => {
                 this.providers[index - 1].logger(e, "ERROR");
                 if (index === this.provider.length) {
@@ -88,27 +78,22 @@ module.exports = nodefony.registerProvider("chainProvider", () => {
         } else {
           return reject(new Error("No provider valid "));
         }
-
       });
     }
 
-    loadUserByUsername(username) {
+    loadUserByUsername (username) {
       if (this.provider.length) {
         return this.loadUsersByUsername(username);
-      } else {
-        return new Promise((resolve, reject) => {
-          return reject(new Error(`Chain Provider not ready`));
-        });
       }
+      return new Promise((resolve, reject) => reject(new Error("Chain Provider not ready")));
     }
 
-    refreshUser(user) {
+    refreshUser (user) {
       if (user instanceof nodefony.User) {
         return this.provider.loadUserByUsername(user.getUsername());
       }
       throw new Error("refreshUser bad user type");
     }
-
   }
   return chainProvider;
 });

package/kernel/security/providers/memoryProvider.es6

@@ -1,29 +1,26 @@
 module.exports = nodefony.registerProvider("memoryProvider", () => {
-
   class memoryProvider extends nodefony.Provider {
-
-    constructor(security, config) {
+    constructor (security, config) {
       super("memoryProvider", security);
       this.config = config;
       this.users = {};
       if (this.config.users) {
-        for (let user in this.config.users) {
+        for (const user in this.config.users) {
           this.setUser(this.config.users[user]);
         }
       }
     }
 
-    loadUserByUsername(username) {
+    loadUserByUsername (username) {
       return new Promise((resolve, reject) => {
         if (username in this.users) {
           return resolve(this.users[username]);
-        } else {
-          return reject(new Error(`Provider : ${this.name} loadUserByUsername user ${username} not Found `));
         }
+        return reject(new Error(`Provider : ${this.name} loadUserByUsername user ${username} not Found `));
       });
     }
 
-    setUser(user) {
+    setUser (user) {
       if (user.username) {
         this.users[user.username] = new nodefony.User(
           user.username,
@@ -45,10 +42,9 @@ module.exports = nodefony.registerProvider("memoryProvider", () => {
       } else {
         throw new Error("Bad user format memory");
       }
-
     }
 
-    refreshUser(user) {
+    refreshUser (user) {
       if (user instanceof nodefony.User) {
         return this.loadUserByUsername(user.getUsername());
       }
@@ -56,4 +52,4 @@ module.exports = nodefony.registerProvider("memoryProvider", () => {
     }
   }
   return memoryProvider;
-});
+});