@bee.js/node 0.0.47 → 0.0.49

package/lib/DBA/beeDBA.js

@@ -98,13 +98,12 @@ module.exports.actions = {
 
     MODEL_CREATE_CONSTRAINT: function (model, configsDB) {
       let q = beeORM.quote;
-      let SQL = "\n\n\n\n";
+      let SQL = "\n\n\n";
 
-      SQL += `/*----- Constraints for table ${q(model.table)} -----*/\n\n`;
-      SQL += `ALTER TABLE ${q(model.table)}\n`;
+      SQL += `/*----- Constraints for table ${q(model.table)} -----*/\n`;
 
       for (let field in model.relations)
-        SQL += `    ADD CONSTRAINT ${q(
+        SQL += `\n\n  ALTER TABLE ${q(model.table)}\n    ADD CONSTRAINT ${q(
           `FK_${model.relations[field].split(".")[0]}_X_${
             model.table
           }_${field}`.slice(0, 64)

package/lib/ORM/beeORM.js

@@ -1,320 +1,364 @@
-const mysql     = require('mysql2/promise'); //https://evertpot.com/executing-a-mysql-query-in-nodejs/
-const beeTools  = require('../../tools/beeTools');
+const mysql = require("mysql2/promise"); //https://evertpot.com/executing-a-mysql-query-in-nodejs/
+const beeTools = require("../../tools/beeTools");
 
-const escape = function(string) {
-    return string.replace(/[\0\x08\x09\x1a\n\r"'\\\%]/g, function (char) {
+const escape = function (string) {
+  return !string
+    ? string
+    : string.replace(/[\0\x08\x09\x1a\n\r"'\\\%]/g, function (char) {
         switch (char) {
-            case "\0":
-                return "\\0";
-            case "\x08":
-                return "\\b";
-            case "\x09":
-                return "\\t";
-            case "\x1a":
-                return "\\z";
-            case "\n":
-                return "\\n";
-            case "\r":
-                return "\\r";
-            case "\"":
-            case "'":
-            case "\\":
-            case "%":
-                return "\\"+char; // prepends a backslash to backslash, percent,
-                                  // and double/single quotes
-            default:
-                return char;
+          case "\0":
+            return "\\0";
+          case "\x08":
+            return "\\b";
+          case "\x09":
+            return "\\t";
+          case "\x1a":
+            return "\\z";
+          case "\n":
+            return "\\n";
+          case "\r":
+            return "\\r";
+          case '"':
+          case "'":
+          case "\\":
+          case "%":
+            return "\\" + char; // prepends a backslash to backslash, percent,
+          // and double/single quotes
+          default:
+            return char;
         }
-    });
-}
+      });
+};
+
+const parseArray = function (param) {
+  switch (typeof param) {
+    case "string":
+      return param.split(",").map((a) => a.trim());
+    case "object":
+      return Object.values(param);
+    default:
+      return param || [];
+  }
+};
+
+const quote = function (word, type = this.configs.databases.default.type) {
+  let escape;
+
+  switch (type) {
+    case "mysql":
+      escape = "``";
+      break;
+    case "mssql":
+      escape = "[]";
+      break;
+    default:
+      escape = type + type;
+      break;
+  }
+
+  return escape[0] + word + escape[1];
+};
+
+const stringBind = function (_string, params = {}) {
+  for (let param of Object.keys(params))
+    _string = _string.replace(":" + param, `'${params[param]}'`); // TODO fazer replace global (Expressao regular) quando a palavra a ser substituida for iniciada com o caractere :
+
+  return _string;
+};
+
+const modelSqlSelectFields = function (model, onlyFields = []) {
+  let fields = [];
+
+  model.fields
+    ? (fields = parseArray(model.fields))
+    : Object.keys(model.schema).map((field) => {
+        if (
+          model.schema[field].out === false ||
+          (onlyFields.length && !onlyFields.includes(field))
+        )
+          return;
+
+        switch (model.schema[field].type) {
+          case "uuid":
+          case "guid":
+            fields.push(`BIN_TO_UUID(${model.table}.${field}) as ${field}`);
+            break;
+          default:
+            fields.push(`${model.table}.${field}`);
+        }
+      });
+
+  return fields;
+};
+
+const modelSqlWhere = function (
+  model,
+  vals,
+  middlewareParams,
+  callsWhere = []
+) {
+  const q = quote;
+
+  let SQL = "";
+  let gWhere = model.globalWhere ? q(model.globalWhere, "()") : "";
+  let keys = parseArray(model.indexes.keys);
+
+  gWhere =
+    gWhere && middlewareParams ? stringBind(gWhere, middlewareParams) : "";
+
+  if (typeof vals !== "object") vals = [vals];
+
+  vals.map((val, i) =>
+    keys.map((k) => {
+      switch (
+        model.schema[k].type //TODO encapsule
+      ) {
+        case "guid":
+        case "uuid":
+          vals[i] = `UUID_TO_BIN('${val}')`;
+          break;
+        default:
+          vals[i] = `'${val}'`;
+      }
+    })
+  );
+
+  switch (vals.length) {
+    case 0:
+      SQL += gWhere ? ` WHERE ${gWhere}` : "";
+      break;
+    case 1:
+      SQL += ` WHERE ${model.table}.${keys[0]} = ${vals[0]} ${
+        gWhere ? "AND " + gWhere : ""
+      }`;
+      break;
+    default:
+      SQL +=
+        typeof vals == "object"
+          ? ` WHERE ${model.table}.${keys[0]} IN('${vals.join("','")}') ${
+              gWhere ? "AND " + gWhere : ""
+            }`
+          : ` WHERE ${model.table}.${keys[0]} IN(${vals}) ${
+              gWhere ? "AND " + gWhere : ""
+            }`;
+  }
+
+  if (callsWhere.length) SQL += `WHERE ${callsWhere.join(" AND ")}`;
+
+  return SQL;
+};
 
-const parseArray = function(param) {
-    switch(typeof(param)){
-        case 'string': return param.split(',').map((a)=>a.trim())
-        case 'object': return Object.values(param)
-        default: return param || []
+module.exports = {
+  escape,
+  quote,
+  stringBind,
+  parseArray,
+  modelSqlWhere,
+  modelSqlSelectFields,
+
+  createPool: function (configs) {
+    // TODO criar aviso de error para falta de configs.db. Criar no hive().create
+
+    // TODO pegar dinamicamnete database utilizada
+    let db = configs.databases.default;
+
+    switch (db.type) {
+      case "mssql": // TODO implementar na versao >=1.2
+        return false;
+      case "mongo": // TODO implementar na versao >=1.2
+        return false;
+      default:
+        return mysql.createPool({
+          host: db.host,
+          user: db.user,
+          password: db.pass,
+          database: db.name,
+          waitForConnections: db.waitForConnections || true,
+          connectionLimit: db.connectionLimit || 10,
+          queueLimit: db.queueLimit || 0,
+        });
     }
-}
+  },
+
+  sqlSelect: function (model, ids = [], params = {}) {
+    //console.log(ids)
+    let SQL = [];
+    let vals = Array.isArray(ids) ? ids : ids.toString().split(",");
+    let where = modelSqlWhere(
+      model,
+      vals,
+      params.middlewareParams,
+      params.where
+    );
+    let joins = params.joins && params.joins.length ? joins.join(" ") : "";
+    let order =
+      params.orderBy && params.orderBy.length
+        ? ` ORDER BY ${params.orderBy}`
+        : "";
+    let limit =
+      params.limit && params.limit.length ? ` LIMIT ${params.limit}` : "";
+    let fields = modelSqlSelectFields(model, params.fields);
+
+    SQL.push(`SELECT ${fields.join(", ")} `);
+    SQL.push(`FROM ${quote(model.table)} `);
+    SQL.push(joins);
+    SQL.push(where);
+    SQL.push(order);
+    SQL.push(limit);
+
+    return SQL;
+  },
+
+  sqlInsertUpdate(model, data, onlyFields = [], statement = "INSERT") {
+    const q = quote;
+
+    let result = {};
+    let fields = [];
+    let values = [];
+    let binds = [];
+    let insertValues = [];
+
+    data = data[0] ? data : [data];
+
+    Object.keys(data).map((key) => {
+      for (let field in model.schema) {
+        field = { ...model.schema[field], name: field };
+
+        if (field.dbControl) continue;
+        if (!field.ai && onlyFields.length && !onlyFields.includes(field.name))
+          continue;
+
+        let value = escape(data[key][field.name]);
+        let type = model.schema[field.name].type;
+
+        if (statement == "INSERT" && field.ai)
+          switch (type) {
+            case "guid":
+            case "uuid":
+              value = beeTools.guid().toString();
+              result.insertBin = beeTools.guidToBin(value);
+              result.insertUUID = value;
+              break;
+          }
 
-const quote = function(word, type = this.configs.databases.default.type) {
-    let escape;
+        if (value === undefined) continue;
 
-    switch (type) {
-        case 'mysql': 
-            escape = '``'
+        switch (type) {
+          case "guid":
+          case "uuid":
+            value = `UUID_TO_BIN('${value}')`; //TODO mssql
             break;
-        case 'mssql': 
-            escape = '[]'
+          case "binary":
+            value = value;
             break;
-        default:
-            escape = type + type
+          case "file":
+            binds.push(value);
+            value = "?";
             break;
-    }
+          case "date":
+          case "datetime":
+          case "time":
+          case "timestamp":
+            value = value ? q(value, "''") : "null";
+            break;
+          default:
+            value = q(value, "''");
+        }
 
-    return escape[0] + word + escape[1]
-}
-
-const stringBind = function(_string, params = {}) {
-    for(let param of Object.keys(params)) 
-        _string = _string.replace(':'+param, `'${params[param]}'`) // TODO fazer replace global (Expressao regular) quando a palavra a ser substituida for iniciada com o caractere :
-
-    return _string
-}
-
-const modelSqlSelectFields = function(model, onlyFields = []) {
-    let fields = []
-
-    model.fields
-    ? fields = parseArray(model.fields)
-    : Object.keys(model.schema)
-        .map((field)=> {
-
-            if(model.schema[field].out === false || (onlyFields.length && !onlyFields.includes(field)))
-                return; 
-            
-            switch(model.schema[field].type) {
-                case "uuid":
-                case "guid":
-                        fields.push(`BIN_TO_UUID(${model.table}.${field}) as ${field}`)
-                break
-                default: fields.push(`${model.table}.${field}`)
-            }
-        })
-
-    return fields
-}
-
-const modelSqlWhere = function(model, vals, middlewareParams, callsWhere = []) {
-    const q    = quote
-    
-    let SQL    = ''
-    let gWhere = model.globalWhere ? q(model.globalWhere, '()') : ''
-    let keys   = parseArray(model.indexes.keys)
-
-    gWhere = gWhere && middlewareParams
-             ? stringBind(gWhere, middlewareParams) 
-             : ''
-
-    if(typeof(vals) !== 'object') vals = [vals]
-
-    vals
-    .map((val, i)=> keys
-        .map((k)=> {
-            switch(model.schema[k].type){ //TODO encapsule
-                case "guid":
-                case "uuid":
-                    vals[i] = `UUID_TO_BIN('${val}')`
-                break
-                default:
-                    vals[i] = `'${val}'`
-            }
-        })
-    )
-
-    switch(vals.length) {
-        case 0 : SQL += gWhere 
-                        ? ` WHERE ${gWhere}`
-                        : ''
-        break
-        case 1 : SQL += ` WHERE ${model.table}.${keys[0]} = ${vals[0]} ${gWhere ? 'AND ' + gWhere : ''}`
-        break
-        default: SQL += typeof(vals) == 'object'
-                        ? ` WHERE ${model.table}.${keys[0]} IN('${vals.join("','")}') ${gWhere ? 'AND ' + gWhere : ''}`
-                        : ` WHERE ${model.table}.${keys[0]} IN(${vals}) ${gWhere ? 'AND ' + gWhere : ''}`
-    }
+        if (field.onInput) value = field.onInput + "(" + value + ")";
 
-    if(callsWhere.length)
-        SQL += `WHERE ${callsWhere.join(' AND ')}`
+        if (statement === "INSERT") {
+          if (key == 0) fields.push(q(field.name));
 
-    return SQL
-}
+          values.push(value);
+        } else {
+          values.push(q(field.name) + "=" + value);
+        }
+      }
+      if (statement === "INSERT") {
+        insertValues.push(values.join(","));
+        values = [];
+      }
+    });
 
-module.exports = {
+    let SQL =
+      statement === "INSERT"
+        ? `INSERT INTO ${model.table} (${fields.join(
+            ","
+          )}) VALUES (${insertValues.join("),(")})`
+        : `UPDATE ${model.table} SET ${values.join(",")}`;
 
-    escape,
-    quote,
-    stringBind,
-    parseArray,
-    modelSqlWhere,
-    modelSqlSelectFields,
-    
-    createPool: function(configs) {
-        // TODO criar aviso de error para falta de configs.db. Criar no hive().create
-        
-        // TODO pegar dinamicamnete database utilizada 
-        let db = configs.databases.default
-
-        switch(db.type) {
-            case 'mssql': // TODO implementar na versao >=1.2
-                return false
-            case 'mongo': // TODO implementar na versao >=1.2
-                return false 
-            default:
-                return mysql.createPool({
-                                host: db.host,
-                                user: db.user,
-                                password: db.pass,
-                                database: db.name,
-                                waitForConnections: db.waitForConnections || true,
-                                connectionLimit: db.connectionLimit || 10,
-                                queueLimit: db.queueLimit || 0
-                            });
-        }
-    },
-
-    sqlSelect: function(model, ids = [], params = {}) { //console.log(ids)
-        let SQL    = []
-        let vals   = Array.isArray(ids) ? ids : ids.toString().split(',')
-        let where  = modelSqlWhere(model, vals, params.middlewareParams, params.where)
-        let joins  = params.joins && params.joins.length ? joins.join(' ') : ''
-        let order  = params.orderBy && params.orderBy.length ? ` ORDER BY ${params.orderBy}` : ''
-        let limit  = params.limit && params.limit.length ? ` LIMIT ${params.limit}` : ''
-        let fields = modelSqlSelectFields(model, params.fields)
-
-        SQL.push(`SELECT ${fields.join(', ')} `)
-        SQL.push(`FROM ${quote(model.table)} `) 
-        SQL.push(joins)
-        SQL.push(where)
-        SQL.push(order)
-        SQL.push(limit)
-    
-        return SQL
-    },
-
-    sqlInsertUpdate(model, data, onlyFields = [], statement = 'INSERT') {
-        const q = quote
-
-        let result = {}
-        let fields = []
-        let values = []
-        let binds  = []
-        let insertValues = []
-
-        data = data[0] ? data : [data]
-        
-        Object
-        .keys(data)
-        .map((key) => {
-            for(let field in model.schema) {
-                
-                field = {...model.schema[field], name: field}
-
-                if(field.dbControl) continue
-                if(!field.ai && onlyFields.length && !onlyFields.includes(field.name)) continue
-                
-                let value = data[key][field.name]
-                let type  = model.schema[field.name].type
-
-                if(statement == "INSERT" && field.ai) 
-                    switch(type) {
-                        case "guid":
-                        case "uuid":
-                            value             = beeTools.guid().toString()
-                            result.insertBin  = beeTools.guidToBin(value)
-                            result.insertUUID = value
-                        break
-                    }   
-                
-                if(value === undefined) continue
-
-                switch(type) {
-                    case "guid":
-                    case "uuid":
-                        value = `UUID_TO_BIN('${value}')` //TODO mssql
-                    break
-                    case "binary":
-                        value = value
-                    break
-                    case "file":
-                        binds.push(value)
-                        value = "?"
-                    break
-                    case "date":
-                    case "datetime":
-                    case "time":
-                    case "timestamp":
-                        value = value ? q(value,"''") : "null"
-                    break
-                    default:
-                        value = q(value,"''")
-                }
-
-                if(field.onInput)
-                    value = field.onInput + '(' + value + ')'
-
-                if(statement === 'INSERT') {
-                    if(key == 0)
-                        fields.push(q(field.name))
-                    
-                    values.push(value)
-                } else {
-                    values.push(q(field.name) + '=' + value)
-                }
-            }
-            if(statement === 'INSERT') {
-                insertValues.push(values.join(","))
-                values = []
-            }
-        });
+    return { result, SQL, binds };
+  },
 
-        let SQL = statement === 'INSERT'
-                    ? `INSERT INTO ${model.table} (${fields.join(",")}) VALUES (${insertValues.join("),(")})`
-                    : `UPDATE ${model.table} SET ${values.join(',')}`
-
-        return { result, SQL, binds }
-    },
-
-    save: (model, key = null) => { //TODO, tirar daqui.
-        var fields = Object.keys(model.schema)
-        var body = []
-        
-        //key = 1 //test
-    
-        for (let i = 0; i <= req.body.length-1; i++) {
-          var values = []
-          
-          for(field of fields) {
-            let out   = model.schema[field].out || a
-            let value = (req.body[i] || req.body)[out]
-    
-            //TODO inserir validacoes
-
-            value = ["guid","binary"].includes(model.schema[field].type) 
-            ? value
-            : q(value,"''")
-    
-            values.push({field:field, out: out, value: value})
-          }
-          body.push(values)
-        }
-    
-        if (key!==null) {
-            body = body[0].filter((a)=>a.value).map((a)=> a = a.field + `=${a.value}` ).join()
-            db.query(`UPDATE ${model.table} SET ${body} WHERE ${model.fieldKey} = ${key}`)
-        }else{
-            body = body.map((a)=> a.map((a)=>`${a.value}`)).join("),(")
-            db.query(`INSERT INTO ${model.table} (${Object.keys(model.schema)}) VALUES(${body})`)
-        }
-      },
+  save: (model, key = null) => {
+    //TODO, tirar daqui.
+    var fields = Object.keys(model.schema);
+    var body = [];
+
+    //key = 1 //test
 
-    sqlUpdate: (model, keys) => { //TODO
-        return db.query(`UPDATE ${model.table} SET TODO WHERE ${table.fieldKey} = (${key})`)
-    },
-    
-    sqlDelete: (model, keys) => { //TODO
-        return db.query(`DELETE FROM ${model.table} WHERE ${table.fieldKey} = (${key})`)
-    },
+    for (let i = 0; i <= req.body.length - 1; i++) {
+      var values = [];
 
-    forceData(data, req = {}) {
-        // TODO coocar funcao para pegar apenas campos do middlaware marcados para INSERT e UPDATE. 
-        // Se nao campos do tipo IDUser_Profile poderá ser forçado pelo middleware invés do post form.
+      for (field of fields) {
+        let out = model.schema[field].out || a;
+        let value = (req.body[i] || req.body)[out];
 
-        return Object.assign({}, data, req.token || {}, req.middleware || {})
-    },
+        //TODO inserir validacoes
 
-    formatOut(data, model) { //TODO 
-        if(!model) return data
+        value = ["guid", "binary"].includes(model.schema[field].type)
+          ? value
+          : q(value, "''");
+
+        values.push({ field: field, out: out, value: value });
+      }
+      body.push(values);
+    }
 
-        return data
+    if (key !== null) {
+      body = body[0]
+        .filter((a) => a.value)
+        .map((a) => (a = a.field + `=${a.value}`))
+        .join();
+      db.query(
+        `UPDATE ${model.table} SET ${body} WHERE ${model.fieldKey} = ${key}`
+      );
+    } else {
+      body = body.map((a) => a.map((a) => `${a.value}`)).join("),(");
+      db.query(
+        `INSERT INTO ${model.table} (${Object.keys(
+          model.schema
+        )}) VALUES(${body})`
+      );
     }
-}
+  },
+
+  sqlUpdate: (model, keys) => {
+    //TODO
+    return db.query(
+      `UPDATE ${model.table} SET TODO WHERE ${table.fieldKey} = (${key})`
+    );
+  },
+
+  sqlDelete: (model, keys) => {
+    //TODO
+    return db.query(
+      `DELETE FROM ${model.table} WHERE ${table.fieldKey} = (${key})`
+    );
+  },
+
+  forceData(data, req = {}) {
+    // TODO coocar funcao para pegar apenas campos do middlaware marcados para INSERT e UPDATE.
+    // Se nao campos do tipo IDUser_Profile poderá ser forçado pelo middleware invés do post form.
+
+    return Object.assign({}, data, req.token || {}, req.middleware || {});
+  },
+
+  formatOut(data, model) {
+    //TODO
+    if (!model) return data;
+
+    return data;
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bee.js/node",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "description": "A JavaScript framework for making Node.js API´s",
   "main": "index.js",
   "scripts": {