nodefony 7.0.2 → 10.0.0-alpha.2

package/kernel/reader.es6

@@ -1,290 +0,0 @@
-const defaultSetting = {
-  parserXml: {
-    // explicitCharkey: true,
-    explicitArray: true,
-    explicitRoot: false,
-    mergeAttrs: true
-  },
-  readFile: {
-    encoding: "utf8"
-  },
-  twig: {
-    "twig options": {
-      async: false,
-      cache: true
-    },
-    views: null
-  },
-  parse: false
-};
-
-const load = function (name, pathFile) {
-  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");
-    return null;
-  }
-  const myName = Array.prototype.shift.call(arguments);
-  const file = Array.prototype.shift.call(arguments);
-  let txt = null;
-  try {
-    switch (ext) {
-    case ".xml":
-      txt = this.readFileSync(file);
-      Array.prototype.unshift.call(arguments, txt);
-      if (plug.xml) {
-        return plug.xml.apply(this, arguments);
-      }
-      return this.pluginConfig.xml.apply(this, arguments);
-
-      break;
-    case ".json":
-      txt = this.readFileSync(file);
-      Array.prototype.unshift.call(arguments, txt);
-      return plug.json.apply(this, arguments);
-    case ".yml":
-    case ".yaml":
-      txt = this.readFileSync(file);
-      Array.prototype.unshift.call(arguments, txt);
-      if (plug.yml) {
-        return plug.yml.apply(this, arguments);
-      }
-      return this.pluginConfig.yml.apply(this, arguments);
-
-      break;
-    case ".js":
-    case ".es6":
-    case ".mjs":
-    case ".es7":
-      Array.prototype.unshift.call(arguments, file);
-      switch (true) {
-      case new RegExp("^(.+)Controller.js$").test(basename):
-        if (plug.annotations) {
-          return plug.annotations.apply(this, arguments);
-        }
-        return this.pluginConfig.annotations.apply(this, arguments);
-
-        break;
-      default:
-        if (plug.javascript) {
-          return plug.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");
-    }
-  } catch (e) {
-    throw e;
-  }
-  return null;
-};
-
-/**
- *  Reader node js
- *
- *  @class Reader
- *  @constructor
- *
- *  @example
- *    var container = new nodefony.Container();
- *    var reader = new nodefony.Reader(container, settings);
- *
- */
-class Reader extends nodefony.Service {
-  constructor (container, localSettings) {
-    super("READER", container);
-    this.settings = nodefony.extend(true, {}, defaultSetting, localSettings);
-    this.plugins = {};
-    this.container = container;
-    this.xmlParser = new xmlParser(this.settings.parserXml);
-    this.engine = require("twig");
-    this.readConfig = this.loadPlugin("config", this.pluginConfig);
-    this.loader = this.container.get("autoLoader");
-    this.annotations = new nodefony.Annotations(container, this.notificationsCenter);
-  }
-
-  pluginConfig () {
-    const json = function (file, bundle, callback, parser) {
-      if (parser) {
-        file = this.render(file, parser.data, parser.options);
-      }
-      try {
-        const json = JSON.parse(file);
-        if (callback) {
-          callback(json);
-        }
-      } catch (e) {
-        throw e;
-      }
-    };
-    const yml = function (file, bundle, callback, parser) {
-      if (parser) {
-        file = this.render(file, parser.data, parser.options);
-      }
-      try {
-        const json = yaml.load(file);
-        if (callback) {
-          callback(json);
-        }
-      } catch (e) {
-        throw e;
-      }
-    };
-    const xml = function (file, bundle, callback, parser) {
-      if (parser) {
-        file = this.render(file, parser.data, parser.options);
-      }
-      this.xmlParser.parseString(file, (error, node) => {
-        if (error) {
-          throw error;
-        }
-        if (callback) {
-          callback(this.xmlToJson(node));
-        }
-      });
-    };
-
-    const javascript = function (file, bundle, parser, callback) {
-      if (typeof bundle === "function") {
-        callback = bundle;
-      }
-      if (typeof parser === "function") {
-        callback = parser;
-      }
-      try {
-        return callback(this.loader.load(file, true));
-      } catch (e) {
-        throw e;
-      }
-    };
-
-    const annotations = function (file) {
-      throw new Error(`Annotation is not defined for this file ${file}`);
-    };
-
-    return {
-      xml,
-      json,
-      yml,
-      javascript,
-      annotations
-    };
-  }
-
-  readFile (file, localSettings) {
-    if (!file) {
-      throw new Error("READE no file path in readFile");
-    }
-    return new Promise((resolve, reject) => {
-      try {
-        fs.readFile(file, nodefony.extend({}, this.settings.readFile, localSettings), (err, data) => {
-          if (err) {
-            return reject(err);
-          }
-          return resolve(data);
-        });
-      } catch (e) {
-        this.log(e, "ERROR");
-        return reject(e);
-      }
-    });
-  }
-
-  readFileSync (file, localSettings) {
-    try {
-      return fs.readFileSync(file, nodefony.extend({}, this.settings.readFile, localSettings));
-    } catch (e) {
-      this.log(e);
-      throw e;
-    }
-  }
-
-  /**
-   *  @method render
-   *
-   */
-  render (str, data) {
-    return this.engine.twig({
-      data: str
-    }).render(data);
-  }
-
-  /**
-   *  @method loadPlugin
-   *
-   */
-  loadPlugin (name, plugin) {
-    this.plugins[name] = plugin;
-    const context = this;
-    return function () {
-      Array.prototype.unshift.call(arguments, name);
-      return load.apply(context, arguments);
-    };
-  }
-
-  /**
-   *  @method xmlToJson
-   *
-   */
-  xmlToJson (node) {
-    const json = {};
-    if (node instanceof Array) {
-      for (let key = 0; key < node.length; key++) {
-        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 (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++) {
-                    if (json[node[key].id][param][elm].key && json[node[key].id][param][elm]._) {
-                      json[node[key].id][param][elm][json[node[key].id][param][elm].key] = json[node[key].id][param][elm]._;
-                      delete json[node[key].id][param][elm].key;
-                      delete json[node[key].id][param][elm]._;
-                    }
-                  }
-                } else {
-                  json[node[key].id][param] = this.xmlToJson(node[key][param]);
-                }
-              }
-            }
-          } else if (node[key].key && node[key]._) {
-            json[node[key].key] = node[key]._;
-          } else if (node[key].key && !node[key]._) {
-            for (param in node[key]) {
-              if (param !== "key") {
-                json[node[key].key] = {};
-                json[node[key].key][param] = this.xmlToJson(node[key][param]);
-              }
-            }
-          } else {
-            return node;
-          }
-        } else {
-          return node;
-        }
-      }
-      return json;
-    } else if (node instanceof Object) {
-      for (const mykey in node) {
-        json[mykey] = this.xmlToJson(node[mykey]);
-      }
-      return json;
-    }
-    return node;
-
-    return json;
-  }
-}
-
-Reader.prototype.pluginConfig = Reader.prototype.pluginConfig();
-
-nodefony.Reader = Reader;
-module.exports = Reader;

package/kernel/security/encoder.es6

@@ -1,17 +0,0 @@
-class Encoder {
-  constructor (name, options = {}) {
-    this.name = name;
-    this.settings = options;
-  }
-
-  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");
-  }
-}
-
-nodefony.Encoder = Encoder;
-module.exports = Encoder;

package/kernel/security/factories/factory.es6

@@ -1,111 +0,0 @@
-class Factory extends nodefony.Service {
-  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.provider = null;
-    this.kernel.once("onReady", () => {
-      // 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);
-        }
-      } else {
-        this.provider = this.security.provider;
-      }
-    });
-  }
-
-  logger (pci, severity, msgid, msg) {
-    if (!msgid) {
-      msgid = `\x1b[36mFACTORY ${this.name}\x1b[0m`;
-    }
-    return super.logger(pci, severity, msgid, msg);
-  }
-
-  handle (context) {
-    return this.authenticate(context)
-      .then((token) => token)
-      .catch((error) => {
-        throw error;
-      });
-  }
-
-  logout (context) {
-    if (context.session) {
-      this.log(`Factory ${this.name} :  invalide session`, "DEBUG");
-      return context.session.invalidate()
-        .then(() => context)
-        .catch((e) => {
-          throw e;
-        });
-    }
-    return new Promise((resolve) => {
-      resolve(context);
-    });
-  }
-
-  authenticate (context) {
-    return new Promise((resolve, reject) => {
-      this.log(`FACTORY AUTHENTICATION ${this.name}`, "DEBUG");
-      let token = null;
-      try {
-        token = this.createToken(context, this.provider);
-        if (!this.supportsToken(token)) {
-          reject(new nodefony.Error(`Factory ${this.name} Token Unauthorized !! `));
-        }
-        this.authenticateToken(token)
-          .then((Token) => {
-            token.setAuthenticated(true);
-            token.setFactory(this.name);
-            return resolve(Token);
-          })
-          .catch((e) => reject(e));
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
-
-  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*/) {
-    return true;
-  }
-
-  authenticateToken (token, provider) {
-    if (provider) {
-      return provider.authenticate(token);
-    }
-    if (!this.provider) {
-      return new Promise((resolve) => {
-        resolve(token);
-      });
-    }
-    return this.provider.authenticate(token);
-  }
-}
-
-nodefony.Factory = Factory;
-module.exports = Factory;

package/kernel/security/factories/passeportFactory.es6

@@ -1,61 +0,0 @@
-class passeportFactory extends nodefony.Factory {
-  constructor (name, security, settings) {
-    super(name, security, settings);
-
-    // this.passport = security.firewall.passport;
-    const passport = security.firewall.newPassport();
-    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")}
-            Secure Area  : ${clc.blue(security.name)}
-            Factory  : ${clc.blue(this.name)}
-            Settings : ${clc.blue(util.inspect(this.settings))}
-            `, "WARNING");
-        }
-        this.strategy = strategy;
-        if (this.strategy) {
-          this.passport.use(this.strategy);
-        }
-      })
-      .catch((e) => {
-        this.log(e, "ERROR");
-        throw e;
-      });
-  }
-
-  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) {
-    return new Promise((resolve, reject) => {
-      try {
-        this.passport.authenticate(this.name, {
-          session: false
-        })(context, (error, token) => {
-          if (error) {
-            return reject(error);
-          }
-          if (token) {
-            token.setAuthenticated(true);
-            token.setFactory(this.name);
-            this.log(`AUTHENTICATION ${token.getUsername()} SUCCESSFULLY`, "DEBUG");
-            return resolve(token);
-          }
-          return resolve(null);
-        });
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-}
-
-nodefony.passeportFactory = passeportFactory;
-module.exports = passeportFactory;

package/kernel/security/provider.es6

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

package/kernel/security/providers/chainProvider.es6

@@ -1,99 +0,0 @@
-module.exports = nodefony.registerProvider("chainProvider", () => {
-  class chainProvider extends nodefony.Provider {
-    constructor (manager, config) {
-      super("chainProvider", manager);
-      this.config = config;
-      this.providers = [];
-      this.provider = [];
-      this.nbProviders = 0;
-      this.kernel.on("onReady", () => {
-        if (this.config.providers) {
-          for (let i = 0; i < this.config.providers.length; i++) {
-            this.setProvider(this.config.providers[i]);
-          }
-        }
-      });
-    }
-
-    setProvider (name) {
-      const provider = this.manager.getProvider(name);
-      if (provider) {
-        this.providers.push(provider);
-        this.nbProviders++;
-      } else {
-        this.log(new Error(`In Chain Provider ${name} not exist `), "ERROR");
-      }
-    }
-
-    authenticateProviders (token, index = 1) {
-      return new Promise((resolve, reject) => {
-        if (this.nbProviders) {
-          try {
-            return this.providers[index - 1].authenticate(token)
-              .then((token) => {
-                this.provider.push(this.providers[index - 1]);
-                if (index === this.nbProviders) {
-                  return resolve(token);
-                }
-                return resolve(this.authenticateProviders(token, ++index));
-              })
-              .catch((e) => {
-                this.providers[index - 1].logger(e, "ERROR");
-                if (index === this.nbProviders) {
-                  return reject(e);
-                }
-                return resolve(this.authenticateProviders(token, ++index));
-              });
-          } catch (e) {
-            return reject(e);
-          }
-        } else {
-          return reject(null);
-        }
-      });
-    }
-
-    authenticate (token) {
-      return new Promise((resolve, reject) => this.authenticateProviders(token)
-        .then((token) => resolve(token))
-        .catch((e) => reject(e)));
-    }
-
-    loadUsersByUsername (username, index = 1) {
-      return new Promise((resolve, reject) => {
-        if (this.provider.length) {
-          try {
-            return this.provider[index - 1].loadUserByUsername(username)
-              .then((user) => resolve(user))
-              .catch((e) => {
-                this.providers[index - 1].logger(e, "ERROR");
-                if (index === this.provider.length) {
-                  return reject(e);
-                }
-                return resolve(this.loadUsersByUsername(username, ++index));
-              });
-          } catch (e) {
-            return reject(e);
-          }
-        } else {
-          return reject(new Error("No provider valid "));
-        }
-      });
-    }
-
-    loadUserByUsername (username) {
-      if (this.provider.length) {
-        return this.loadUsersByUsername(username);
-      }
-      return new Promise((resolve, reject) => reject(new Error("Chain Provider not ready")));
-    }
-
-    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,55 +0,0 @@
-module.exports = nodefony.registerProvider("memoryProvider", () => {
-  class memoryProvider extends nodefony.Provider {
-    constructor (security, config) {
-      super("memoryProvider", security);
-      this.config = config;
-      this.users = {};
-      if (this.config.users) {
-        for (const user in this.config.users) {
-          this.setUser(this.config.users[user]);
-        }
-      }
-    }
-
-    loadUserByUsername (username) {
-      return new Promise((resolve, reject) => {
-        if (username in this.users) {
-          return resolve(this.users[username]);
-        }
-        return reject(new Error(`Provider : ${this.name} loadUserByUsername user ${username} not Found `));
-      });
-    }
-
-    setUser (user) {
-      if (user.username) {
-        this.users[user.username] = new nodefony.User(
-          user.username,
-          user.password,
-          user.roles,
-          user.lang,
-          user.provider,
-          user.enabled,
-          user.userNonExpired,
-          user.credentialsNonExpired,
-          user.accountNonLocked,
-          user.name,
-          user.surname,
-          user.email,
-          user.gender,
-          user.url,
-          user.image
-        );
-      } else {
-        throw new Error("Bad user format memory");
-      }
-    }
-
-    refreshUser (user) {
-      if (user instanceof nodefony.User) {
-        return this.loadUserByUsername(user.getUsername());
-      }
-      throw new Error("refreshUser bad user type");
-    }
-  }
-  return memoryProvider;
-});