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

package/packages/cli/core/databases/sequelize.js

@@ -27,7 +27,7 @@ connectInProcess = async (database_config, headDbShow, cb) => {
         // check hash ?
         if(val.username && val.password) {
           if(val.username.length < 55 || val.password < 55) {
-            return cb("Error: No Hash access for connect to database.\n", null);
+            return cb("Error: Incorrect Hash access for connect to database.\n", null);
           }
           let accessDb = [];
           [val.username, val.password].map((e, k) => {
@@ -102,7 +102,7 @@ connectInProcess = async (database_config, headDbShow, cb) => {
             freezeTableName: ((val.define) ? ((val.define.freezeTableName === false) ? val.define.freezeTableName : true) : true),
             charset: ((val.define) ? ((val.define.charset) ? val.define.charset : "utf8") : "utf8"),
             dialectOptions: {
-              collate: ((val.define) ? ((val.define.dialectOptions) ? ((val.define.dialectOptions.timestamps) ? val.define.dialectOptions.timestamps : "utf8_general_ci") : "utf8_general_ci") : "utf8_general_ci"),
+              collate: ((val.define) ? ((val.define.dialectOptions) ? ((val.define.dialectOptions.collate) ? val.define.dialectOptions.collate : "utf8_general_ci") : "utf8_general_ci") : "utf8_general_ci"),
             },
             timestamps: ((val.define) ? ((val.define.timestamps) ? val.define.timestamps : false) : false),
           },
@@ -125,11 +125,19 @@ connectInProcess = async (database_config, headDbShow, cb) => {
   
           // JSON response
           query: {
-            raw: ((val.query) ? ((val.query.raw) ? val.query.raw : true) : true),
+            raw: ((val.query) ? ((val.query.raw) ? val.query.raw : false) : false),
             nest: ((val.query) ? ((val.query.nest) ? val.query.nest : true) : true),
           }
         });
-  
+
+        // Hook to set `SET NAMES xxx` (ONLY MySQL)
+        await sq.addHook('afterConnect', async (connection) => {
+          if(val.dialect == "mysql") {
+            let charset = ["SET NAMES", ((val.define) ? ((val.define.charset) ? val.define.charset : "utf8") : "utf8")].join(" ");
+            connection.query(charset);
+          }
+        });
+
         // show only one text db connnections
         if (headDbShow) {
           console.log(' Passed  Database is connected at:');
@@ -144,7 +152,7 @@ connectInProcess = async (database_config, headDbShow, cb) => {
           // shuout
           console.log('- [' + val.dialect + '] ' + val.name + ' -> ' + sq.config.database + ':' + sq.config.port + '');
         }
-  
+
         // connection
         await sq.authenticate()
           .then(() => {
@@ -161,7 +169,8 @@ connectInProcess = async (database_config, headDbShow, cb) => {
             }
           })
           .catch(err => {
-            console.error('Unable to connect to the database:', err);
+            console.log("Unable to connect to the database:", err);
+            cb(err, null);
           });
       });
     } else {

package/packages/cli/core/databases/test.js

@@ -2,6 +2,7 @@ const logUpdate = require("log-update");
 const emoji = require('node-emoji')
 const { DeHashIt, M, X } = require(__dirname + "/../helpers/math");
 const Sequelize = require('sequelize');
+const fs = require("fs");
 let testSql = {};
 
 function filterDbIsTrue(dbConfig, cb) {
@@ -25,42 +26,44 @@ function filterDbIsTrue(dbConfig, cb) {
   }
 }
 
-function testConnectInProcess (database_config, dbConnTotal, cb) {
+function testConnectInProcess(database_config, dbConnTotal, cb) {
   try {
+    // Recursive test connection
     let val = database_config.shift();
     if (val) {
-      initSequelize(val, async (err, sq) => {
+      initSequelize(val, true, async (err, sq) => {
         if (err) {
-          console.error(" Failed  Can't connect to connection name:", val.name, "\n", err);
-          cb(err, null, null);
-        }
-        // Test connection
-        await sq.authenticate()
-          .then(() => {
-            // Database some is true perfectly.
-            if (database_config.length == 0) {
-              if (sq) {
+          //console.log(" Failed  Can't connect to connection name:", val.name, "\n", err);
+          return cb(err, null, null);
+        } else {
+          // Test connection
+          await sq.authenticate()
+            .then(() => {
+              // Database some is true perfectly.
+              if (database_config.length == 0) {
+                if (sq) {
+                  testSql[ val.name ] = sq;
+                  //console.log("DB true, Perfectly.", val.name);
+                  return cb(null, true, testSql);
+                }
+              } else {
                 testSql[ val.name ] = sq;
-                //console.log("DB true, Perfectly.", val.name);
-                cb(null, true, testSql);
+                testConnectInProcess(database_config, dbConnTotal, cb);
               }
-            } else {
-              testSql[ val.name ] = sq;
-              testConnectInProcess(database_config, dbConnTotal, cb);
-            }
-          })
-          .catch(err => {
-            console.error(" Failed  Unable to connect to the database:", val.name, "\n", err);
-            cb(err, null, null);
-          });
+            })
+            .catch(err => {
+              console.log(" Failed  Unable to connect to the database:", val.name, "\n", err);
+              return cb(err, null, null);
+            });
+        }
       });
     } else if (!dbConnTotal) {
       // All Database is falsly perfectly.
       //console.log("DB all false, Perfectly.");
-      cb(null, true, testSql);
+      return cb(null, true, testSql);
     }
   } catch (error) {
-    cb(error, null, null);
+    return cb(error, null, null);
   }
 }
 
@@ -88,33 +91,69 @@ function logit(msg, next = false) {
   }
 }
 
-function initSequelize(val, cb) {
+function initSequelize(val, testConn = true, cb) {
   try {
     const promise = new Promise((resolve) => {
       // check hash ?
       if(val.username && val.password) {
         if(val.username.length < 55 || val.password < 55) {
-          return cb("ERROR: No Hash access for connect to database.\n", null);
+          return cb("ERR: Incorrect Hash access for connect to database, Please Hashing your access by command `beech hash:<your_access>`\n", null);
         }
         let accessDb = [];
-        [val.username, val.password].map((e, k) => {
-          DeHashIt(e.toString(), null, (17).toString().slice(0,-1).length, (err, d) => {
-            if(!err) {
-              accessDb.push(d.split("sh,")[1].split(M(X).toString().slice(0,2)+M(X).toString())[0].slice(0,-1));
+        [val.username, val.password].map(async (e, k) => {
+          await DeHashIt(e.toString(), null, (17).toString().slice(0,-1).length, async (err, d) => {
+            if(err) {
+              cb("ERR: Hash access error,", err);
+              throw err;
+            }
+            accessDb.push(d.split("sh,")[1].split(M(X).toString().slice(0,2)+M(X).toString())[0].slice(0,-1));
+            // Finally username & password
+            if(k+1==2) {
+              // Last push dialect connection
+              accessDb.push(val.dialect);
+              // resolve it
+              resolve(accessDb);
             }
           });
-          if(k+1==2) {
-            resolve(accessDb);
-          }
         });
       } else {
         resolve([null, null]);
       }
     });
     Promise.all([promise]).then(final => {
-      // stdout pre-flight connection
-      logit(`- [${val.dialect}] ${val.name}`);
-      logit(emoji.get('heavy_multiplication_x') + `  [${val.dialect}] ${val.name}`);
+      /**
+       * The final callback variable : [['hashed', 'hashed', 'dialect']]
+       * 
+       * final[0][0] : username hashed
+       * final[0][1] : password hashed
+       * final[0][2] : dialect
+       * 
+       */
+
+      // Check test connection for stdout pre-flight
+      if(testConn) {
+        // stdout pre-flight connection
+        logit(`- [${val.dialect}] ${val.name}`);
+        logit(emoji.get('heavy_multiplication_x') + `  [${val.dialect}] ${val.name}`);
+      }
+      fs.readFile("./global.config.js", 'utf8', (err, data) => {
+        if (err) {
+          console.log("\n Faltal  Can't read `global.config.js` file.\n", err);
+          return; // break;
+        } else {
+          let buffer = Buffer.from(data);
+          let buf2str = buffer.toString();
+          let buf2json = JSON.parse(JSON.stringify(buf2str));
+          let pool_base = /global.pool_base\s+=\s+(?:"|')([^"]+)(?:"|')(?:\r|\n|$|;|\r)/i.exec(buf2json);
+          if (pool_base) {
+            if(pool_base == "basic") {
+              if(final[0][2] != "mysql") {
+                return cb(`The Basic pool engine not support with: ${val.dialect}, Please use Sequelize engine.`, null);
+              }
+            }
+          }
+        }
+      });
       // create connection
       const sq = new Sequelize({
         dialect: val.dialect || "mysql",
@@ -157,7 +196,10 @@ function initSequelize(val, cb) {
           nest: ((val.query) ? ((val.query.nest) ? val.query.nest : true) : true),
         }
       });
-      logit(emoji.get('heavy_check_mark') + `  [${val.dialect}] ${val.name}`, true);
+      // Check test connection for stdout pre-flight (mark)
+      if(testConn) {
+        logit(emoji.get('heavy_check_mark') + `  [${val.dialect}] ${val.name}`, true);
+      }
       cb(false, sq);
     }).catch(err => {
       console.log(` Warning  Connection name \`${val.name}\``, err);
@@ -167,4 +209,48 @@ function initSequelize(val, cb) {
   }
 }
 
-module.exports = { filterDbIsTrue, testConnectInProcess, disConnectTestDB }
+function connectForGenerateModel(dbConnectName, tableName, databaseConfig, cb) {
+  /**
+   * Callback
+   * 
+   * err String : Error message
+   * tableSchema Object : Schema of table
+   * tableName String : table name
+   * 
+   */
+  const connectionChoose = databaseConfig.filter((e) => e.name == dbConnectName)[0];
+  initSequelize(connectionChoose, false, async (err, sq) => {
+    if (err) {
+      cb(err, null, null);
+    }
+    // Connection
+    await sq.authenticate()
+      .then(() => {
+        getTableSchema(sq, tableName, (errSchema, tableSchema) => {
+          if(errSchema) {
+            cb(errSchema, null, null);
+          } else {
+            // Closing database
+            sq.close();
+            // Callback
+            cb(null, tableSchema, tableName);
+          }
+        });
+      })
+      .catch(err => {
+        cb(err, null, null);
+      });
+  });
+}
+
+async function getTableSchema(sq, tableName, cb) {
+  try {
+    const queryInterface = sq.getQueryInterface();
+    const schema = await queryInterface.describeTable(tableName);
+    cb(null, schema);
+  } catch (error) {
+    cb("Fetching table schema " + error, null);
+  }
+}
+
+module.exports = { filterDbIsTrue, testConnectInProcess, disConnectTestDB, connectForGenerateModel }

package/packages/cli/core/generator/_models

@@ -1,29 +1,6 @@
 const { Schema } = require("beech-api");
 // {{modelNameUppercase}} structure
-const {{modelNameUppercase}} = Schema(sql.{{dbSelected}}).define("{{modelName}}", {
-  {{modelName}}_id: {
-    field: "id",
-    type: DataTypes.INTEGER,
-    autoIncrement: true,
-    primaryKey: true,
-  },
-  examField1: DataTypes.STRING,
-  examField3: DataTypes.DATE,
-  examField4: {
-    type: DataTypes.STRING,
-    allowNull: false,
-    // set(value) {
-    //   this.setDataValue("examField4", md5(value));
-    // },
-  },
-  createdAt: DataTypes.DATE,
-  updatedAt: DataTypes.DATE,
-  // Asign more DataTypes, Learn more: https://sequelize.org/docs/v6/core-concepts/model-basics/#data-types
-});
+{{modelStructure}}
+// Asign more DataTypes, Learn more: https://sequelize.org/docs/v6/core-concepts/model-basics/#data-types
 
-// Example basic function Get one data by id
-function exampleFindOne{{modelNameUppercase}}ById(id) {
-  return {{modelNameUppercase}}.findOne({ where: { id: id } });
-}
-
-module.exports = { {{modelNameUppercase}}, exampleFindOne{{modelNameUppercase}}ById };
+module.exports = { {{modelNameUppercase}} };

package/packages/cli/core/generator/_models_basic

@@ -1,14 +1,5 @@
 module.exports = {
 
-  // Example basic function return exam data
-  getData() {
-    return [
-      { "id": 1, "name": "Oggy" },
-      { "id": 2, "name": "Jack" },
-      { "id": 3, "name": "The Cockroaches Gang" }
-    ];
-  },
-
   // Example basic function get data from table {{modelName}}
   findAll() {
     return new Promise((resolve, reject) => {

package/packages/cli/core/generator/_package

@@ -13,9 +13,9 @@
     "test": "node ./node_modules/jest/bin/jest __tests__ -o --watch --config"
   },
   "dependencies": {
-    "beech-api": "~3.8.0"
+    "beech-api": "~3.9.0"
   },
   "devDependencies": {
-    "jest": "^28.1.3"
+    "jest": "^29.7.0"
   }
 }

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() {
@@ -190,21 +191,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 +426,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 +451,114 @@ class Generator {
     });
   }
 
-  generateModel(tmpModelsPath, dbSelected) {
+  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 +568,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 +805,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 +818,7 @@ class Generator {
               });
             }
           })
-        }, 1000);
+        }, 2000);
       } catch (error) {
         reject(error);
       }