beech-api 3.8.0 → 3.9.0-beta.9-rc

package/packages/cli/core/generator/index.js

@@ -2,6 +2,7 @@
 const logUpdate = require("log-update");
 const inquirer = require('inquirer');
 const walk = require("walk");
+const { connectForGenerateModel } = require("../databases/test");
 
 class Generator {
   constructor() {
@@ -178,6 +179,18 @@ class Generator {
               resolve("\n Faltal  commnad it's not available.");
             }
           }
+        } else if (this.option == 'update') {
+          console.log('------------------------------');
+          if(this.argument == 'model') {
+            // this.special = model name
+            // if (!this.special) {
+            //   resolve("\n [103m [90m Warning  [0m [0m Please specify model name to update.");
+            // } else {
+            //   this.updateModel()
+            //     .then(res => resolve(res))
+            //     .catch(err => reject(err));
+            // }
+          }
         } else if (this.option == 'passport') {
           if (this.argument == "init") {
             this.makePassportInit()
@@ -190,21 +203,42 @@ class Generator {
           this.generateKeyConfigFile()
             .then(resGenKey => resolve(resGenKey))
             .catch(err => reject(err));
-        } else if (this.option && this.option.slice(0, 5) == 'hash:') {
+        } else if (this.option && this.option.slice(0, 5) == "hash:") {
+          const { HashIt, Z } = require(__dirname + "/../helpers/math");
           if(this.option.length > 5) {
-            const { HashIt, Z } = require(__dirname + "/../helpers/math");
             Z((err, ak) => {
               if(err) {
                 logUpdate(err);
               } else {
                 let txt = this.option.split(":");
                 HashIt(txt, ak, null, (5).toString().length, (hashed) => {
-                  logUpdate(hashed);
+                  logUpdate("\n" + hashed);
                 });
               }
             });
           } else {
-            resolve("\n Info.  No text to hash.");
+            inquirer.prompt([ {
+              type: "confirm",
+              name: "confirmHashNoText",
+              message: "No text to hash, Do you want to continue ?:",
+            } ]).then(confirm => {
+              if(confirm.confirmHashNoText) {
+                Z((err, ak) => {
+                  if(err) {
+                    logUpdate(err);
+                  } else {
+                    let txt = this.option.split(":");
+                    HashIt(txt, ak, null, (5).toString().length, (hashed) => {
+                      logUpdate("\n" + hashed);
+                    });
+                  }
+                });
+              } else {
+                // no text to hash say no.
+                resolve(": Say no.");
+              }
+            });
+
           }
         } else if (this.option == "skd") {
           if (this.argument == "init") {
@@ -404,12 +438,12 @@ class Generator {
                     // check pool_base
                     if (pool_base[ 1 ] == "basic") {
                       tmpModelsPath += '/_models_basic';
-                      this.generateModel(tmpModelsPath, dbSelected.selectDbConnect)
+                      this.generateModel(tmpModelsPath, dbSelected.selectDbConnect, appBuf2eval, pool_base[1])
                         .then(console.log)
                         .catch(console.log);
                     } else if (pool_base[ 1 ] == "sequelize") {
                       tmpModelsPath += '/_models';
-                      this.generateModel(tmpModelsPath, dbSelected.selectDbConnect)
+                      this.generateModel(tmpModelsPath, dbSelected.selectDbConnect, appBuf2eval, pool_base[1])
                         .then(console.log)
                         .catch(console.log);
                     } else {
@@ -429,35 +463,182 @@ class Generator {
     });
   }
 
-  generateModel(tmpModelsPath, dbSelected) {
+  updateModel() {
+    return new Promise((resolve, reject) => {
+      try {
+        // 1. อ่านการตั้งค่าจาก global.config และ app.config เหมือนตอนสร้าง Model
+        this.fs.readFile("./global.config.js", 'utf8', (err, globalData) => {
+          if (err) return resolve("\n [101m Faltal  [0m Can't read `global.config.js` file.");
+  
+          this.fs.readFile("./app.config.js", 'utf8', (appErr, appData) => {
+            if (appErr) return resolve("\n [101m Faltal  [0m Can't read `app.config.js` file.");
+  
+            let appBuf2eval = eval(appData);
+            let modelName = this.special; // <table_name>
+            let modelPath = `./src/models/${modelName.charAt(0).toUpperCase() + modelName.slice(1)}.js`;
+  
+            // ตรวจสอบว่ามีไฟล์ Model เดิมอยู่หรือไม่
+            if (!this.fs.existsSync(modelPath)) {
+              return resolve(`\n [103m [90m Warning  [0m [0m Model file \`${modelName}\` not found to update.`);
+            }
+  
+            // ให้ผู้ใช้เลือก Connection ที่ต้องการดึง Schema ใหม่
+            inquirer.prompt([{
+              type: "list",
+              name: "selectDbConnect",
+              message: " [93mSelect database connection to sync schema: [0m",
+              choices: appBuf2eval.database_config.map(e => e.name),
+            }]).then(dbSelected => {
+              
+              // 2. ดึง Schema ใหม่จาก DB
+              const { connectForGenerateModel } = require("../databases/test");
+              let newModelClassName = modelName.split("_").map(e => e.charAt(0).toUpperCase() + e.slice(1)).join("");
+  
+              connectForGenerateModel(dbSelected.selectDbConnect, modelName, appBuf2eval.database_config, (err, tableSchema, tableName) => {
+                if (err) return reject(err);
+  
+                // 3. แปลง Schema เป็น Code String
+                this.rawSchemaTable(dbSelected.selectDbConnect, newModelClassName, tableName, tableSchema, (SchemaErr, rawSchema) => {
+                  if (SchemaErr) return reject(SchemaErr);
+  
+                  // 4. อ่านไฟล์เดิมและทำการ Replace เฉพาะส่วน Schema
+                  this.fs.readFile(modelPath, 'utf8', (readErr, currentContent) => {
+                    if (readErr) return reject(readErr);
+  
+                    // ใช้ Regex เพื่อหาช่วงของ Schema(...).define(...) และเปลี่ยนเฉพาะข้างใน
+                    // โดยจะหาตั้งแต่ Schema(sql.db).define("table", { จนถึง });
+                    const regex = /const\s+\w+\s+=\s+Schema\(sql\.\w+\)\.define\([\s\S]*?\}\);/;
+                    
+                    if (regex.test(currentContent)) {
+                      let updatedContent = currentContent.replace(regex, rawSchema);
+  
+                      this.fs.writeFile(modelPath, updatedContent, 'utf8', (writeErr) => {
+                        if (writeErr) return reject(writeErr);
+                        resolve(`\n [102m [90m Passed  [0m [0m The model \`${modelName}\` schema has been updated.`);
+                      });
+                    } else {
+                      resolve("\n [101m Faltal  [0m Could not find Schema definition pattern in the file.");
+                    }
+                  });
+                });
+              });
+            });
+          });
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  generateModel(tmpModelsPath, dbSelected, appBuf2eval, pool_base) {
     return new Promise((resolve, reject) => {
       try {
+        // Show generating msg
+        const frames = [
+          '\n[-] Generating',
+          '\n[\\] Generating.',
+          '\n[|] Generating..',
+          '\n[/] Generating...'
+        ];
+        let i = 0;
+        var refreshGenerateIntervalId = null;
+        // Save model folder
         let modelPath = './src/models/';
-        // argument join `slash`
+        // Argument join `slash`
         let arg = this.argument.replace(/^\/+|\/+$/g, '');
         arg = arg.split('/');
         let models = arg.pop();
+        let oriModelsName = models.slice(0);
         models = models.charAt(0).toUpperCase() + models.slice(1);
         let newModel = models.split("_").map(e => e.charAt(0).toUpperCase() + e.slice(1)).join("");
         let subFolder = arg.join('/');
-        // models
+        // Declare models
         let fullModels = modelPath + subFolder.concat('/') + models.concat('.js');
 
-        // check file exists
+        /**
+         * All properties
+         * 
+         * @tmpModelPath String : path to keep generate model file
+         * @dbSelect String : database connection name
+         * @appBug2eval Object : database connection object
+         * @pool_base Object : pool base connection
+         * 
+         * @i Number : loop count running...
+         * @refreshGenerateIntervalId Object : for clear interval id
+         * 
+         * @arg String : argument from typing
+         * @models String : model name
+         * @oriModelsName String : original model name from typing
+         * @newModel String : model first upper case
+         * @subFolder String : agument sub folder
+         * @fullModels String : full model path and model file name
+         * 
+         */
+        // Check file exists
         if (!this.fs.existsSync(fullModels)) {
-          // generater model
-          this.makeFolder(modelPath + subFolder)
-            .then(this.copy.bind(this, tmpModelsPath, fullModels))
-            .then(this.modelContentReplace.bind(this, fullModels, {
-              'modelNameUppercase': newModel,
-              'modelName': models.toLowerCase(),
-              'dbSelected': dbSelected,
-            }))
-            .then(logUpdate("\n Processing  The model `" + models + "` it's generating..."))
-            .then(generated => logUpdate(generated))
-            .catch(err => {
-              throw err;
+          // Check pool base is basic|sequelize
+          if(pool_base == "basic") {
+            // Generate basic model
+            this.makeFolder(modelPath + subFolder)
+              .then(this.copy.bind(this, tmpModelsPath, fullModels))
+              .then(this.modelContentReplace.bind(this, fullModels, {
+                'modelName': oriModelsName,
+                'dbSelected': dbSelected,
+              }))
+              .then(
+                refreshGenerateIntervalId = setInterval(() => {
+                  const frame = frames[i = ++i % frames.length];
+                  logUpdate(`${frame}`);
+                }, 300)
+              )
+              .then(generated => {
+                logUpdate(generated);
+                clearInterval(refreshGenerateIntervalId);
+              })
+              .catch(err => {
+                throw err;
+              });
+          } else if(pool_base == "sequelize") {
+            // Gether table schema
+            connectForGenerateModel(dbSelected, oriModelsName, appBuf2eval.database_config, (err, tableSchema, tableName) => {
+              if(err) {
+                throw logUpdate("\n Faltal ", String(err), "\n");
+              } else {
+                // Raw model schema
+                this.rawSchemaTable(dbSelected, newModel, tableName, tableSchema, (SchemaErr, rawSchema) => {
+                  if(err) {
+                    throw logUpdate("\n Faltal  RAW Schema ERR:", String(SchemaErr), "\n");
+                  } else {
+                    // Generate sequelize model
+                    this.makeFolder(modelPath + subFolder)
+                    .then(this.copy.bind(this, tmpModelsPath, fullModels))
+                    .then(this.modelContentReplace.bind(this, fullModels, {
+                      'modelName': oriModelsName,
+                      'modelNameUppercase': newModel,
+                      'modelStructure': rawSchema,
+                    }))
+                    .then(
+                      refreshGenerateIntervalId = setInterval(() => {
+                        const frame = frames[i = ++i % frames.length];
+                        logUpdate(`${frame}`);
+                      }, 300)
+                    )
+                    .then(generated => {
+                      logUpdate(generated);
+                      clearInterval(refreshGenerateIntervalId);
+                    })
+                    .catch(err => {
+                      throw err;
+                    });
+                  }
+                });
+              }
             });
+          } else {
+            // Fallback (When Accident)
+            resolve("\n Faltal  The pool_base in `global.config.js` file does not match the specific.");
+          }
         } else {
           resolve("\n Warning  The model `" + models + "` it's duplicated.");
         }
@@ -467,6 +648,78 @@ class Generator {
     });
   }
 
+  rawSchemaTable(dbNameSelected, newModelName, tableName, modelSchema, cb) {
+    try {
+      // Function map type
+      const mapToSequelizeType = (rawType) => {
+        const type = rawType.toUpperCase();
+        // Assign all conditions
+        if (type.includes('INT')) return 'DataTypes.INTEGER';
+        if (type.includes('BIGINT')) return 'DataTypes.BIGINT';
+        if (type.includes('FLOAT')) return 'DataTypes.FLOAT';
+        if (type.includes('DOUBLE')) return 'DataTypes.DOUBLE';
+        if (type.includes('DECIMAL')) return 'DataTypes.DECIMAL';
+        if (type.includes('BOOLEAN') || type === 'TINYINT(1)') return 'DataTypes.BOOLEAN';
+        if (type.includes('CHAR')) {
+          const match = type.match(/\((\d+)\)/);
+          const length = match ? match[1] : '255';
+          return `DataTypes.STRING(${length})`;
+        }
+        if (type.includes('VARCHAR')) {
+          const match = type.match(/\((\d+)\)/);
+          const length = match ? match[1] : '255';
+          return `DataTypes.STRING(${length})`;
+        }
+        if (type.includes('TEXT')) return 'DataTypes.TEXT';
+        if (type.includes('DATE')) return 'DataTypes.DATE';
+        if (type.includes('TIME')) return 'DataTypes.TIME';
+        if (type.includes('JSON')) return 'DataTypes.JSON';
+        if (type.includes('UUID')) return 'DataTypes.UUID';
+        if (type.includes('BLOB')) return 'DataTypes.BLOB';
+        if (type.includes('ENUM')) return 'DataTypes.ENUM'; // Needs manual values
+        if (type.includes('GEOMETRY')) return 'DataTypes.GEOMETRY';
+        // Fallback
+        return `DataTypes.STRING`;
+      };
+      // Looping key fields
+      const fields = Object.entries(modelSchema).map(([name, props]) => {
+        // Declare line
+        const lines = [];
+        // Push line and assign space for beautiful
+        lines.push(`    type: ${mapToSequelizeType(props.type)},`);
+        lines.push(`    allowNull: ${props.allowNull},`);
+        // Check is primary key
+        if (props.primaryKey) lines.push(`    primaryKey: true,`);
+        if (props.autoIncrement) lines.push(`    autoIncrement: true,`);
+        //if (props.comment) lines.push(`    comment: '${props.comment}',`);
+
+        // Handle defaultValue
+        if (props.defaultValue !== null && props.defaultValue !== undefined) {
+          const defaultVal = String(props.defaultValue).toUpperCase();
+          if (
+            defaultVal === 'CURRENT_TIMESTAMP' ||
+            defaultVal === 'NOW()' ||
+            defaultVal.includes('CURRENT_TIMESTAMP')
+          ) {
+            lines.push(`    defaultValue: DataTypes.NOW,`);
+          } else if (defaultVal === 'UUID()' || defaultVal === 'uuid()' || defaultVal === 'UUID') {
+            lines.push(`    defaultValue: DataTypes.UUIDV4,`);
+          } else if (typeof props.defaultValue === 'string') {
+            lines.push(`    defaultValue: '${props.defaultValue}',`);
+          } else {
+            lines.push(`    defaultValue: ${props.defaultValue},`);
+          }
+        }
+        // Finally
+        return `  ${name}: {\n${lines.join('\n')}\n  }`;
+      });
+      // Callback
+      cb(null, `const ${newModelName} = Schema(sql.${dbNameSelected}).define("${tableName}", {\n${fields.join(',\n')}\n});`);
+    } catch (error) {
+      cb(error, null);
+    }
+  }
+
   makeHelper() {
     return new Promise((resolve, reject) => {
       try {
@@ -632,6 +885,7 @@ class Generator {
               text = text.replace(new RegExp('{{dbSelected}}', 'g'), textCondition.dbSelected);
               // check add model name text uppercase
               if (Object.keys(textCondition).length > 1) {
+                text = text.replace(new RegExp('{{modelStructure}}', 'g'), textCondition.modelStructure);
                 text = text.replace(new RegExp('{{modelNameUppercase}}', 'g'), textCondition.modelNameUppercase);
               }
               // writing the file
@@ -644,7 +898,7 @@ class Generator {
               });
             }
           })
-        }, 1000);
+        }, 2000);
       } catch (error) {
         reject(error);
       }

package/packages/cli/core/helpers/2fa.js

@@ -1,5 +1,9 @@
+const fs = require("fs");
 const { FindOne } = require("../../../lib/src/user");
 const { findPassportPk } = require("./poolEntity");
+const passport_config_file = appRoot + "/passport.config.js";
+const md5 = require("md5");
+const secret = require("../../../lib/src/salt").salt;
 
 function TwoFactor(user, reqBody, guard_field, cb) {
   try {
@@ -8,6 +12,22 @@ function TwoFactor(user, reqBody, guard_field, cb) {
         cb(true, err);
       } else {
         if(userId.length) {
+          if (fs.existsSync(passport_config_file)) {
+            passport_config = require(passport_config_file);
+          } else {
+            cb(true, {
+              code: 500,
+              status: "INTERNAL_SERVER_ERR",
+              error: {
+                code: 404,
+                status: "ERROR_FILE_NOT_EXISTS",
+                message: "The file passport.config.js not exists!",
+              }
+            });
+            return;
+          }
+          let usrField = passport_config.model.username_field || "username";
+          let pwdField = passport_config.model.password_field || "password"
           // filter without base user, pass
           let without_base = Object.keys(reqBody).map((k) => {
             return guard_field.filter((e) => e == k)[0];
@@ -19,7 +39,8 @@ function TwoFactor(user, reqBody, guard_field, cb) {
           // check length match ?
           if(x.length == guard_field.length) {
             let z = {};
-            z[userId[0]] = user.id;
+            z[usrField] = reqBody[usrField];
+            z[pwdField] = md5(reqBody[pwdField] + secret);
             x.map((guard) => {
               z[guard] = reqBody[guard];
             });

package/packages/cli/core/helpers/math.js

@@ -34,7 +34,19 @@ function getAppKey(cb) {
 
 function HashIt(txt, app_key, iteration = 10000, len = 10, cb) {
   const crypIt = new Cryptr(secret.toString().concat(app_key.toString()), { encoding: "base64url", pbkdf2Iterations: iteration, saltLength: len, });
-  cb(crypIt.encrypt(txt.concat(md5(secret).toString().slice(0,len+1))));
+  let result = "";
+  let loop = 0;
+  const maxLoop = 10;
+  do {
+    const payload = txt.concat(md5(secret).toString().slice(0, len + 1));
+    result = crypIt.encrypt(payload);
+    loop++;
+    if (loop >= maxLoop) {
+      console.log("\n FAIL  Hash loop limit exceeded, Try again.");
+      return;
+    }
+  } while (/[+-]/.test(result)); // reject -, +
+  cb(result);
 }
 
 function DeHashIt(txtHashed, iteration = 10000, len = 10, cb) {
@@ -43,7 +55,7 @@ function DeHashIt(txtHashed, iteration = 10000, len = 10, cb) {
       if(err) {
         cb(err, null);
       } else {
-        const crypIt = new Cryptr(secret.toString().concat(app_key.toString()), { encoding: "base64url", pbkdf2Iterations: iteration, saltLength: len, });
+        const crypIt = new Cryptr(secret.toString().concat(app_key.toString()), { encoding: "base64", pbkdf2Iterations: iteration, saltLength: len, });
         let decryped = crypIt.decrypt(txtHashed);
         cb(false, decryped.concat(md5(secret).toString()));
       }

package/packages/cli/core/helpers/poolEntity.js

@@ -1,34 +1,60 @@
-function findPassportPk(pool_base, pool, passportTable, passportConfigField, cb) {
+async function findPassportPk(pool_base, pool, passportTable, passportConfigField, cb) {
   try {
-    if(passportConfigField.length) {
-      cb(null, passportConfigField);
-    } else {
-      if(pool_base == "basic") {
-        // pool base is Basic
-        pool.query("SHOW KEYS FROM " + passportTable + " WHERE Key_name = 'PRIMARY'", (err, pk) => {
-          if(err) {
-            throw "Authentication table: " + err;
+    let finalPassportField = [];
+    // Push and Replace it
+    const pushOrReplace = (arr, value) => {
+      arr = arr.filter(v => !value.includes(v));
+      arr = [...value, ...arr];
+      return arr;
+    }
+    // Check pool engine
+    if(pool_base == "basic") {
+      // pool base is Basic
+      pool.query("SHOW KEYS FROM " + passportTable + " WHERE Key_name = 'PRIMARY'", (err, pk) => {
+        if(err) {
+          throw "Authentication table: " + err;
+        } else {
+          if(passportConfigField.length) {
+            finalPassportField = pushOrReplace(passportConfigField, [pk[0].Column_name]);
+            cb(null, finalPassportField);
           } else {
             cb(null, [pk[0].Column_name]);
           }
-        });
-      } else if (pool_base == "sequelize") {
-        // pool base is Sequelize
-        pool.query("SHOW KEYS FROM " + passportTable + " WHERE Key_name = 'PRIMARY'", { type: QueryTypes.SELECT }).then((pk) => {
-          cb(null, [pk[0].Column_name]);
-        }).catch((err) => {
-          throw "Authentication table: " + err;
-        });
-      } else {
-        throw "The Base pool error. UNKNOWN pool_base = '"+ pool_base +"'";
+        }
+      });
+    } else if (pool_base == "sequelize") {
+      // pool base is Sequelize
+      // Find table primaryKey
+      try {
+        const tableInfo = await pool.getQueryInterface().describeTable(String(passportTable));
+        const primaryKeys = Object.entries(tableInfo).filter(([columnName, columnInfo]) => columnInfo.primaryKey).map(([columnName]) => columnName);
+        if(primaryKeys.length) {
+          if(passportConfigField.length) {
+            finalPassportField = pushOrReplace(passportConfigField, primaryKeys);
+            cb(null, finalPassportField);
+          } else {
+            cb(null, primaryKeys);
+          }
+        } else {
+          if(passportConfigField.length) {
+            finalPassportField = pushOrReplace(passportConfigField, [Object.keys(tableInfo)[0]]);
+            cb(null, finalPassportField);
+          } else {
+            cb(null, [Object.keys(tableInfo)[0]]);
+          }
+        }
+      } catch (error) {
+        throw `Query Interface ${error}`;
       }
+    } else {
+      throw "The Base pool error. UNKNOWN pool_base = '"+ pool_base +"'";
     }
   } catch (error) {
     cb(error, null);
   }
 }
 
-function checkAuthFields(pool_base, pool, passportTable, passportConfigField, cb) {
+async function checkAuthFields(pool_base, pool, passportTable, passportConfigField, cb) {
   try {
     if(passportConfigField.length) {
       if(pool_base == "basic") {
@@ -42,18 +68,36 @@ function checkAuthFields(pool_base, pool, passportTable, passportConfigField, cb
         });
       } else if (pool_base == "sequelize") {
         // pool base is Sequelize
-        pool.query("SELECT "+ passportConfigField.join(",") +" FROM " + passportTable + " LIMIT 1", { type: QueryTypes.SELECT }).then((result) => {
-          cb(null, [result]);
-        }).catch((err) => {
-          cb(`Authentication table: '${passportTable}' ${err}`, null);
-        });
+        // Check assing fields exists
+        const checkColumnsExist = async (tableName, fields = []) => {
+          const queryInterface = pool.getQueryInterface();
+          try {
+            const tableDescription = await queryInterface.describeTable(tableName);
+            const result = {};
+            for (const column of fields) {
+              result[column] = tableDescription.hasOwnProperty(column);
+            }
+            return result;
+          } catch (error) {
+            throw `Query Interface ${error}`;
+          }
+        }
+        const openFields = await checkColumnsExist(passportTable, passportConfigField);
+        const assignFieldsIsWhitelist = Object.values(openFields).includes(false) ? false : true;
+        if(assignFieldsIsWhitelist) {
+          cb(null, openFields);
+        } else {
+          cb(`Authentication table fields error: '${passportTable}' => [${passportConfigField}]`, null);
+        }
       } else {
         cb("The Base pool error. UNKNOWN pool_base = '"+ pool_base +"'", null);
       }
+    } else {
+      cb(null, []);
     }
   } catch (error) {
     cb(error, null);
   }
 }
 
-module.exports = { findPassportPk, checkAuthFields }
+module.exports = { findPassportPk, checkAuthFields };