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

package/kernel/security/providers/providerManager.es6

@@ -1,53 +1,50 @@
 class providerManager extends nodefony.Service {
-
-  constructor(firewall, providers = []) {
+  constructor (firewall, providers = []) {
     super("providerManager", firewall.container);
     this.providers = providers || [];
     this.nbProviders = 0;
   }
 
-  getProvider(name) {
+  getProvider (name) {
     if (this.providers[name]) {
       return this.providers[name];
     }
     throw new Error(`Provider : ${name} nor found`);
   }
 
-  getProviders(name) {
+  getProviders (name) {
     if (name) {
       return this.getProvider(name);
     }
     return this.providers;
   }
 
-  addConfiguration(name, config) {
+  addConfiguration (name, config) {
     if (name in this.providers) {
       this.log(`Provider ${name} already exist`, "WARNING");
       return null;
     }
     if (config) {
-      this.kernel.prependOnceListener("onBoot", async() => {
+      this.kernel.prependOnceListener("onBoot", async () => {
         switch (true) {
-        case !!config.entity:
+        case Boolean(config.entity):
           if (config.class) {
             if (config.class in nodefony.security.providers) {
               this.providers[name] = new nodefony.security.providers[config.class](name, this, config.entity);
             } else {
               this.log(new Error(`provider class not exist : ${config.class}`), "ERROR");
             }
-          } else {
-            if ( nodefony.security.providers.userProvider ){
-              this.providers[name] = new nodefony.security.providers.userProvider(name, this, config.entity);
-            }
+          } else if (nodefony.security.providers.userProvider) {
+            this.providers[name] = new nodefony.security.providers.userProvider(name, this, config.entity);
           }
           break;
-        case !!config.chain:
+        case Boolean(config.chain):
           this.providers[name] = new nodefony.security.providers.chainProvider(this, config.chain);
           break;
-        case !!config.memory:
+        case Boolean(config.memory):
           this.providers[name] = new nodefony.security.providers.memoryProvider(this, config.memory);
           break;
-        case !!config.anonymous:
+        case Boolean(config.anonymous):
           if (config.anonymous.provider) {
             if (this.providers[config.anonymous.provider]) {
               this.providers[name] = this.providers[config.anonymous.provider];

package/kernel/security/providers/userEntityProvider.es6

@@ -1,6 +1,5 @@
 class userEntityProvider extends nodefony.Provider {
-
-  constructor(name, manager, config) {
+  constructor (name, manager, config) {
     super(name, manager);
     this.entityName = config.name || "user";
     this.userProperty = config.property || "username";
@@ -14,16 +13,16 @@ class userEntityProvider extends nodefony.Provider {
     });
   }
 
-  getEntity(name) {
+  getEntity (name) {
     if (name) {
       return this.orm.getEntity(name);
     }
     return this.orm.getEntity(this.entityName);
   }
 
-  async encodePassword(raw, salt) {
+  async encodePassword (raw, salt) {
     try {
-      let ret = this.entity.hasEncoder();
+      const ret = this.entity.hasEncoder();
       if (ret) {
         return await this.encoder.encodePassword(raw, salt);
       }
@@ -33,11 +32,11 @@ class userEntityProvider extends nodefony.Provider {
     }
   }
 
-  async isPasswordValid(raw, encoded) {
+  async isPasswordValid (raw, encoded) {
     try {
-      let ret = this.entity.hasEncoder();
+      const ret = this.entity.hasEncoder();
       if (ret) {
-        this.log(`Check Password Valid `, "DEBUG", `ENCODER ${this.encoder.name}`);
+        this.log("Check Password Valid ", "DEBUG", `ENCODER ${this.encoder.name}`);
         return await this.encoder.isPasswordValid(raw, encoded);
       }
       return await super.isPasswordValid(raw, encoded);

package/kernel/security/role.es6

@@ -1,12 +1,12 @@
 class Role {
-  constructor(role) {
+  constructor (role) {
     this.role = role;
   }
 
-  getRole() {
+  getRole () {
     return this.role;
   }
 }
 
 nodefony.Role = Role;
-module.exports = Role;
+module.exports = Role;

package/kernel/security/secureArea.es6

@@ -1,15 +1,14 @@
-module.exports = nodefony.register("SecuredArea", function () {
-
+/* eslint-disable max-lines-per-function */
+module.exports = nodefony.register("SecuredArea", () => {
   // context security
   class securedArea extends nodefony.Service {
-
-    constructor(name, firewall) {
+    constructor (name, firewall) {
       super(name, firewall.container, firewall.notificationsCenter);
       this.firewall = firewall;
       this.router = this.get("router");
       this.sessionContext = "default";
       this.cors = null;
-      this.pattern = /.*/;
+      this.pattern = /.*/u;
       this.factories = [];
       this.nbFactories = 0;
       this.provider = null;
@@ -26,37 +25,33 @@ module.exports = nodefony.register("SecuredArea", function () {
           if (this.providerName) {
             if (this.providerName in this.firewall.providerManager.providers) {
               this.provider = this.firewall.providerManager.getProvider(this.providerName);
-            } else {
-              if (this.anonymous) {
-                this.providerName = "anonymous";
-                this.provider = this.firewall.providerManager.getProvider("anonymous");
-              } else {
-                throw new Error(`Provider : ${this.providerName} not found in firewall ${this.name}`);
-              }
-            }
-          } else {
-            if (this.anonymous) {
+            } else if (this.anonymous) {
               this.providerName = "anonymous";
               this.provider = this.firewall.providerManager.getProvider("anonymous");
             } else {
-              //this.providerName = null; //"nodefony";
-              //this.provider = this.firewall.providerManager.getProvider("nodefony");
+              throw new Error(`Provider : ${this.providerName} not found in firewall ${this.name}`);
             }
+          } else if (this.anonymous) {
+            this.providerName = "anonymous";
+            this.provider = this.firewall.providerManager.getProvider("anonymous");
+          } else {
+            // this.providerName = null; //"nodefony";
+            // this.provider = this.firewall.providerManager.getProvider("nodefony");
           }
         } catch (e) {
-          this.log(this.name + "  " + e, "ERROR");
+          this.log(`${this.name}  ${e}`, "ERROR");
         }
       });
     }
 
-    log(pci, severity, msgid, msg) {
+    log (pci, severity, msgid, msg) {
       if (!msgid) {
-        msgid = "\x1b[36mSECURE AREA \x1b[31m" + this.name + " \x1b[0m";
+        msgid = `\x1b[36mSECURE AREA \x1b[31m${this.name} \x1b[0m`;
       }
       return super.log(pci, severity, msgid, msg);
     }
 
-    handleCrossDomain(context) {
+    handleCrossDomain (context) {
       let redirect = false;
       if (context.security.redirect_Https &&
         context.protocol === "https" &&
@@ -66,19 +61,22 @@ module.exports = nodefony.register("SecuredArea", function () {
       if (context.crossDomain) {
         if (this.cors) {
           return this.cors.match(context, redirect);
-        } else {
-          if (redirect) {
-            return null;
-          }
-          return 401;
         }
+        if (redirect) {
+          return null;
+        }
+        if (context.originUrl.href === "*") {
+          return 200;
+        }
+        return 401;
       }
     }
 
-    handleError(context, e) {
+    // eslint-disable-next-line complexity
+    handleError (context, e) {
       let securityError = null;
       switch (true) {
-      case (e instanceof nodefony.securityError):
+      case e instanceof nodefony.securityError:
         securityError = e;
         break;
       default:
@@ -88,7 +86,7 @@ module.exports = nodefony.register("SecuredArea", function () {
         securityError.code = 401;
       }
       if (this.kernel.debug) {
-        //this.log(securityError, "ERROR");
+        // this.log(securityError, "ERROR");
       }
       switch (context.type) {
       case "HTTP":
@@ -101,12 +99,12 @@ module.exports = nodefony.register("SecuredArea", function () {
         }
         if (this.formLogin) {
           if (context.session) {
-            let area = context.session.getMetaBag("area");
+            const area = context.session.getMetaBag("area");
             if (area && area !== this.name) {
               context.session.clearFlashBag("default_target_path");
             }
             context.session.setMetaBag("area", this.name);
-            let target_path = context.session.getFlashBag("default_target_path");
+            const target_path = context.session.getFlashBag("default_target_path");
             if (!target_path && context.method === "GET") {
               context.session.setFlashBag("default_target_path", context.request.url.pathname);
             }
@@ -115,7 +113,7 @@ module.exports = nodefony.register("SecuredArea", function () {
             }
           }
 
-          /*if (context.session &&
+          /* if (context.session &&
             (context.request.url.pathname !== this.formLogin) &&
             (context.request.url.pathname !== this.checkLogin)
           ) {
@@ -141,10 +139,11 @@ module.exports = nodefony.register("SecuredArea", function () {
             if (context.isJson) {
               return securityError;
             }
-            //return this.redirect(context, this.formLogin);
+            // return this.redirect(context, this.formLogin);
             context.resolver = this.overrideURL(context, this.formLogin);
             return context;
           } catch (e) {
+            // eslint-disable-next-line new-cap
             return new nodefony.securityError(e, 500, this, context);
           }
         } else {
@@ -153,22 +152,20 @@ module.exports = nodefony.register("SecuredArea", function () {
           }
           return securityError;
         }
-        break;
       case "WEBSOCKET":
       case "WEBSOCKET SECURE":
         return securityError;
+      default:
       }
     }
 
-    handleFactories(context, index = 1) {
+    handleFactories (context, index = 1) {
       return new Promise((resolve, reject) => {
         if (this.nbFactories) {
           try {
             this.log(`Try Authentication Factory ${this.factories[index - 1].name}`, "DEBUG");
             return this.factories[index - 1].handle(context)
-              .then((token) => {
-                return resolve(token);
-              })
+              .then((token) => resolve(token))
               .catch((e) => {
                 this.factories[index - 1].log(e, "DEBUG");
                 if (index === this.nbFactories) {
@@ -185,108 +182,105 @@ module.exports = nodefony.register("SecuredArea", function () {
       });
     }
 
-    handle(context) {
-      return new Promise((resolve, reject) => {
-        return this.handleFactories(context)
-          .then((token) => {
-            let target = this.defaultTarget;
-            try {
-              if (token) {
-                context.user = token.user;
-                context.token = token;
-              } else {
-                if (context.session) {
-                  context.session.setMetaBag("security", {
-                    firewall: this.name,
-                    token: null
-                  });
-                  if (context.user && context.user.lang) {
-                    context.session.set("lang", context.user.lang);
-                  } else {
-                    if( ! context.session.get("lang") ){
-                      context.session.set("lang", context.translation.defaultLocale);
-                    }
-                  }
-                }
-                return resolve(context);
-              }
+    handle (context) {
+      // eslint-disable-next-line no-promise-executor-return
+      return new Promise((resolve, reject) => this.handleFactories(context)
+        .then((token) => {
+          let target = this.defaultTarget;
+          try {
+            if (token) {
+              context.user = token.user;
+              context.token = token;
+            } else {
               if (context.session) {
-                //context.session.migrate();
                 context.session.setMetaBag("security", {
                   firewall: this.name,
-                  token: token ? token.serialize() : null
+                  token: null
                 });
                 if (context.user && context.user.lang) {
                   context.session.set("lang", context.user.lang);
-                } else {
+                } else if (!context.session.get("lang")) {
                   context.session.set("lang", context.translation.defaultLocale);
                 }
-                if (!this.alwaysUseDefaultTarget) {
-                  target = context.session.getFlashBag("default_target_path") || this.defaultTarget;
-                } else {
-                  target = this.defaultTarget;
-                }
-                context.session.clearFlashBag("default_target_path");
-              }
-            } catch (e) {
-              let res = this.handleError(context, e);
-              if (res instanceof Error) {
-                return reject(res);
-              }
-              return resolve(res);
-            }
-            if (this.checkLogin) {
-              try {
-                delete context.resolver;
-                context.checkLogin = true;
-                context.resolver = this.overrideURL(context, this.checkLogin, target);
-                //context.resolver = this.router.resolveName(context, this.checkLogin);
-                return resolve(context);
-              } catch (e) {
-                throw e;
               }
-            }
-            if (!target) {
               return resolve(context);
             }
-            if (context.isJson) {
-              context.resolver = this.overrideURL(context, target);
-              return resolve(context);
-            } else {
-              return resolve(this.redirect(context, target));
-            }
-            return resolve(context);
-          })
-          .catch((error) => {
-            if (!error) {
-              error = new Error("");
+            if (context.session) {
+              // context.session.migrate();
+              context.session.setMetaBag("security", {
+                firewall: this.name,
+                token: token ? token.serialize() : null
+              });
+              if (context.user && context.user.lang) {
+                context.session.set("lang", context.user.lang);
+              } else {
+                context.session.set("lang", context.translation.defaultLocale);
+              }
+              if (!this.alwaysUseDefaultTarget) {
+                target = context.session.getFlashBag("default_target_path") || this.defaultTarget;
+              } else {
+                target = this.defaultTarget;
+              }
+              context.session.clearFlashBag("default_target_path");
             }
-            let res = this.handleError(context, error);
+          } catch (e) {
+            const res = this.handleError(context, e);
             if (res instanceof Error) {
               return reject(res);
             }
             return resolve(res);
-          });
-      });
+          }
+          if (this.checkLogin) {
+            try {
+              delete context.resolver;
+              context.checkLogin = true;
+              context.resolver = this.overrideURL(context, this.checkLogin, target);
+              // context.resolver = this.router.resolveName(context, this.checkLogin);
+              return resolve(context);
+            } catch (e) {
+              throw e;
+            }
+          }
+          if (!target) {
+            return resolve(context);
+          }
+          if (context.isJson) {
+            context.resolver = this.overrideURL(context, target);
+            return resolve(context);
+          }
+          return resolve(this.redirect(context, target));
+          // return resolve(context);
+        })
+        .catch((error) => {
+          if (!error) {
+            error = new Error("");
+          }
+          const res = this.handleError(context, error);
+          if (res instanceof Error) {
+            return reject(res);
+          }
+          return resolve(res);
+        }));
     }
 
-    logout(context) {
+    logout (context) {
       return new Promise(async (resolve, reject) => {
-        let res = [];
-        this.log("Logout factories","DEBUG");
-        for await (let factorie of this.factories) {
-          this.log(`Logout factory : ${factorie}`,"DEBUG")
+        const res = [];
+        this.log("Logout factories", "DEBUG");
+        for await (const factorie of this.factories) {
+          this.log(`Logout factory : ${factorie}`, "DEBUG");
           res.push(await factorie.logout(context));
         }
         if (context.session) {
-          this.log(`Invalidate session Security : ${context.session.id}`,"DEBUG")
+          this.log(`Invalidate session Security : ${context.session.id}`, "DEBUG");
           return context.session.invalidate()
             .then(() => {
               if (this.formLogin) {
                 return resolve(this.redirect(context, this.formLogin));
               }
               return resolve(context);
-            }).catch(e => {
+            })
+            .catch((e) => {
               this.log(e, "ERROR");
               return reject(e);
             });
@@ -296,7 +290,7 @@ module.exports = nodefony.register("SecuredArea", function () {
     }
 
     // Factory
-    setFactory(auth, options) {
+    setFactory (auth, options) {
       if (auth) {
         if (auth in nodefony.security.factories) {
           let index = null;
@@ -308,20 +302,18 @@ module.exports = nodefony.register("SecuredArea", function () {
             index = 0;
           }
           this.nbFactories++;
-          this.log("FACTORY " + auth + " registered ", "DEBUG");
+          this.log(`FACTORY ${auth} registered `, "DEBUG");
           return this.factories[index];
-        } else {
-          this.log("FACTORY :" + auth + "NOT registered ", "ERROR");
-          throw new Error("FACTORY :" + auth + "NOT registered ");
         }
+        this.log(`FACTORY :${auth}NOT registered `, "ERROR");
+        throw new Error(`FACTORY :${auth} NOT registered `);
       }
+      throw new Error(`FACTORY :${auth} bad args`);
     }
 
-    getFactory(name) {
+    getFactory (name) {
       if (name) {
-        let index = this.factories.findIndex((factory) => {
-          return factory.name === name;
-        });
+        const index = this.factories.findIndex((factory) => factory.name === name);
         if (index >= 0) {
           return this.factories[index];
         }
@@ -330,70 +322,72 @@ module.exports = nodefony.register("SecuredArea", function () {
       return null;
     }
 
-    setProvider(provider) {
+    setProvider (provider) {
       if (provider) {
         this.provider = provider;
         this.providerName = provider.name;
       }
     }
 
-    setProviderName(name) {
+    setProviderName (name) {
       this.providerName = name;
     }
 
-    getProvider() {
+    getProvider () {
       return this.provider;
     }
 
-    setStateLess(state) {
+    setStateLess (state) {
       if (state === null) {
-        return this.stateLess = true;
+        this.stateLess = true;
+        return true;
       }
-      return this.stateLess = state || false;
+      this.stateLess = state || false;
+      return state || false;
     }
 
-    overrideURL(context, myUrl, target = null) {
-      try{
+    overrideURL (context, myUrl, target = null) {
+      try {
         if (myUrl) {
           context.request.url = url.parse(url.resolve(context.request.url, myUrl));
         }
-        let resolver = this.router.resolve(context);
+        const resolver = this.router.resolve(context);
         if (target) {
           resolver.variables.push(target);
         }
         return resolver;
-      }catch(e){
-        if (e instanceof nodefony.Resolver ){
-          if ( e.exception){
-            throw e.exception ;
+      } catch (e) {
+        if (e instanceof nodefony.Resolver) {
+          if (e.exception) {
+            throw e.exception;
           }
         }
-        throw e ;
+        throw e;
       }
     }
 
-    redirectHttps(context) {
+    redirectHttps (context) {
       // no cache
       context.redirectHttps(301);
       return context;
     }
 
-    redirect(context, url) {
+    redirect (context, url) {
       if (url) {
         // no cache
         return context.redirect(url, 302, true);
-        //return context;
+        // return context;
       }
       return context.redirect(context.request.url, 302, true);
-      //return context;
+      // return context;
     }
 
-    match(context) {
-      let url = context.request.url ? context.request.url.pathname : (context.request.resourceURL ? context.request.resourceURL.pathname : null);
+    match (context) {
+      const url = context.request.url ? context.request.url.pathname : context.request.resourceURL ? context.request.resourceURL.pathname : null;
       return this.pattern.exec(url);
     }
 
-    setPattern(pattern) {
+    setPattern (pattern) {
       if (pattern instanceof RegExp) {
         this.pattern = pattern;
         this.stringPattern = pattern.toString();
@@ -404,32 +398,32 @@ module.exports = nodefony.register("SecuredArea", function () {
       return this.pattern;
     }
 
-    setCors(crossSettings) {
+    setCors (crossSettings) {
       this.cors = this.firewall.corsManager.createCors(crossSettings);
       return this.cors;
     }
 
-    setFormLogin(route) {
+    setFormLogin (route) {
       this.formLogin = route;
     }
 
-    setCheckLogin(route) {
+    setCheckLogin (route) {
       this.checkLogin = route;
     }
 
-    setDefaultTarget(route) {
+    setDefaultTarget (route) {
       this.defaultTarget = route;
     }
 
-    setAlwaysUseDefaultTarget(data) {
+    setAlwaysUseDefaultTarget (data) {
       this.alwaysUseDefaultTarget = data;
     }
 
-    setContextSession(context) {
+    setContextSession (context) {
       this.sessionContext = context;
     }
 
-    setRedirectHttps(value) {
+    setRedirectHttps (value) {
       this.redirect_Https = value || false;
     }
   }