tspace-mysql 1.0.0

package/License

@@ -0,0 +1,19 @@
+Copyright (c) 2021 Thanathip Srisawatpattana
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

package/README.md

@@ -0,0 +1,375 @@
+# tspace-mysql
+
+[![NPM version](https://img.shields.io/npm/v/tspace-mysql.svg)](https://www.npmjs.com)
+[![NPM downloads](https://img.shields.io/npm/dm/tspace-mysql.svg)](https://www.npmjs.com)
+
+Query builder object relation mapping
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+npm install tspace-mysql --save
+
+```
+## Setup
+.env
+```js
+DB_HOST = localhost
+DB_PORT = 3306
+DB_USERNAME = root
+DB_PASSWORD = password
+DB_DATABASE = database
+```
+## Getting Started
+queries data
+```js
+import { DB } from 'tspace-mysql'
+(async () => {
+    await new DB().raw('SELECT * FROM users')
+    await new DB().table('users').findMany()
+    await new DB().table('users').select('id').where('id',1).findOne()
+    await new DB().table('users').select('id').whereIn('id',[1,2,3]).findMany()
+})()
+```
+create data
+
+```js
+import { DB } from 'tspace-mysql'
+(async () => {
+    *ex pattern 1
+    const user = await new DB().table('users').create({
+          name : 'tspace',
+          email : 'tspace@gmail.com'
+      }).save()
+      
+      console.log(user)
+
+     *ex pattern 2
+     const u = new DB().table('users')
+         u.name = 'tspace'
+         u.email = 'tspace@gmail.com'
+         await u.save()
+      const { result : user } = u 
+      /* or const user = await u.save() */
+      console.log(user)
+})()  
+```
+
+update data
+```js
+import { DB } from 'tspace-mysql'
+(async () => {
+     *ex pattern 1
+     const user = await new DB().table('users').update({
+          name : 'tspace',
+          email : 'tspace@gmail.com'
+      })
+      .where('id',1)
+      .save()
+      
+      console.log(user)
+
+    *ex pattern 2
+     const u = new DB().table('users').where('id',1)
+         u.name = 'tspace'
+         u.email = 'tspace@gmail.com'
+         await u.save()
+     const { result : user } = u 
+    /* or const user = await u.save() */
+     console.log(user)
+})()
+```    
+delete data
+```js
+import { DB } from 'tspace-mysql'
+(async () => {
+     await new User().where('id',1).delete()
+})()
+``` 
+
+## Transactions & Rollback
+```js
+import { DB } from 'tspace-mysql'
+(async () => {
+   const transaction = await new DB().beginTransaction()
+   try {
+      const user = await new User().create({
+          name : 'tspace',
+          email : 'tspace@gmail.com'
+      })
+      .save(transaction)
+      
+       const posts = await new Post().createMultiple([
+            {   
+                user_id : user.id,
+                title : 'tspace post'
+            },
+            {   
+                user_id : user.id,
+                title : 'tspace post second'
+            }
+       ])
+      .save(transaction)
+      
+      throw new Error('try to transaction')
+      
+   } catch (err) {
+       const rollback = await transaction.rollback()
+       console.log(rollback ,'rollback !')
+   }
+})()
+```
+     
+## Model Conventions
+basic model class and discuss some relations:
+
+```js
+import { Model } from 'tspace-mysql'
+import Post from '../Post'
+import Comment from '../Comment'
+import User from '../User'
+
+Folder directory example
+- App
+  - Model
+    Post.ts
+    User.ts
+    Comment.ts
+    
+(async () => {
+    const users = await new User()
+        .with('posts','comments') /* relations -> hasMany: posts & comments  */
+        .withQuery('posts', (query) => query.with('user'))   /* relation -> belongsTo: post by user  */
+        .withQuery('comments', (query) => query.with('user','post'))   /* relation -> belongsTo: comment by user? & comment in post? */
+        .findMany()
+        
+    console.log(users)    
+})()
+```
+*User.ts
+```js
+import { Model } from 'tspace-mysql'
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({name : 'posts', model: Post })
+        this.hasMany({name : 'comments', model: Comment })
+    }
+} 
+export default User
+```
+
+*Post.ts
+```js
+import { Model } from 'tspace-mysql'
+
+class Post extends Model {
+    constructor(){
+        super()
+        this.belongsTo({name : 'user', model: User })
+        this.hasMany({ name : 'comments' , model : Comment })
+    }
+} 
+export default Post
+```
+
+*Comment.ts
+```js
+import { Model } from 'tspace-mysql'
+
+class Comment extends Model {
+    constructor(){
+        super()
+        this.belongsTo({name : 'user', model: User })
+        this.belongsTo({name : 'post', model: Post })
+    }
+} 
+export default Comment
+```
+
+## Method chaining
+method chaining for queries
+```js
+where(column , operator , value)   
+whereSensitive(column , operator , value) 
+whereId(id)  
+whereUser(userId)  
+whereEmail(value)  
+orWhere(column , operator , value)   
+whereIn(column , [])
+whereNotIn(column , [])
+whereNull(column)
+whereNotNull(column)
+whereBetween (column , [value1 , value2])
+whereSubQuery(colmn , rawSQL)
+
+select(column1 ,column2 ,...N)
+except(column1 ,column2 ,...N)
+only(column1 ,column2 ,...N)
+hidden(column1 ,column2 ,...N)
+join (primary key , table.foreign key) 
+rightJoin (primary key , table.foreign key) 
+leftJoin (primary key , table.foreign key) 
+limit (limit)
+orderBy (column ,'ASC' || 'DSCE')
+having (condition)
+latest (column)
+oldest (column)
+groupBy (column)
+
+insert(objects)
+create(objects)
+createMultiple(array objects)
+update (objects)
+insertNotExists(objects)
+createNotExists(objects)
+updateOrInsert (objects)
+updateOrCreate (objects)
+/** 
+ * relationship
+ * 
+ * @Relation setup name in model
+*/
+with(name1 , name2,...nameN)
+withExists(name1 , name2,...nameN) 
+withQuery('relation registry',(callback queries))
+
+/**
+ * queries statements
+ * 
+ *  @exec statements
+*/
+findMany()
+findOne()
+find(id)
+first()
+get()
+delelte()
+exists ()
+onlyTrashed()
+toSQL()
+toString()
+toJSON()
+toArray(column)
+count(column)
+sum(column)
+avg(column)
+max(column)
+min(column)
+pagination({ limit , page })
+save() /*for action statements insert update or delete */
+```
+
+## Cli
+npm install tspace-mysql -g
+```js
+
+tspace-mysql make:model <folder/name model> --m  --f=... --name=.... --js
+* optional
+    --m  /* created table for migrate in <FOLDER/migrations> */
+    --f=folder/...folder /* created table for migrate in <CUSTOM FOLDER> default  <FOLDER/migrations> */ 
+    --js /* extension .js default .ts */
+    --name=NAME /* class name default <NAME> in input cli */
+
+tspace-mysql make:table <folder> --name=....
+* required
+    --name=TABLE_NAME  /* created table for migrate in <folder> */
+* optional
+    --js /* extension .js default .ts */
+    
+ tspace-mysql migrate <folder> --js
+ * optional
+    --js /* extension .js default .ts */
+```
+
+tspace-mysql make:model App/Models/User --m
+```js
+/* Ex folder 
+- node_modules
+- App
+  - Models
+     User.ts
+*/
+
+/* in App/Models/User.ts */
+import { Model } from 'tspace-mysql'
+class User extends Model{
+  constructor(){
+    super()
+    this.useDebug()  /* default false *debug sql */
+    this.useTimestamp() /* default false * case created_at & updated_at*/
+    this.useSoftDelete()  /*  default false * case where deleted_at is null  */
+    this.useTable('users') /*  default users   */
+    this.usePattern('camelCase') /*  default snake_case  */
+    this.useUUID()
+  }
+}
+export default User
+```
+tspace-mysql make:table App/Models/Migrations --name=users
+```js
+/* Ex folder 
+- node_modules
+- App
+  - Models
+    - migrations
+      create_users_table.ts
+    User.ts
+*/
+/* in App/Models/Migrations/create_users_table.ts */
+import { Schema , Blueprint , DB } from 'tspace-mysql'
+(async () => {
+    await new Schema().table('users',{ 
+        id :  new Blueprint().int().notNull().primary().autoIncrement(),
+        name : new Blueprint().varchar(120).default('my name'),
+        email : new Blueprint().varchar(255).unique(),
+        email_verify : new Blueprint().tinyInt(),
+        password : new Blueprint().varchar(255),
+    })
+    /**
+     * 
+     *  @Faker data
+     *  await new DB().table('users').faker(5)
+    */
+})()
+```
+tspace-mysql migrate App/Models/Migrations
+/* migrate all table in folder into database */
+```js
+* Blueprint method
+/**
+ * 
+ * @Types
+ * 
+*/
+int ()
+tinyInt (number) 
+bigInt (number)
+double ()
+float ()
+varchar (number)
+char (number)
+longText()
+mediumText()
+tinyText()
+text()
+enum(...n)
+date()
+dateTime()
+timestamp ()
+/**
+ * 
+ * @Attrbuites
+ * 
+*/
+unsigned ()
+unique ()
+null ()
+notNull ()
+primary() 
+default (string) 
+defaultTimestamp () 
+autoIncrement () 
+```

package/dist/cli/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var make_1 = __importDefault(require("./models/make"));
+var make_2 = __importDefault(require("./tables/make"));
+var make_3 = __importDefault(require("./migrate/make"));
+var commands = {
+    'make:model': make_1.default,
+    'make:table': make_2.default,
+    'migrate': make_3.default
+};
+try {
+    var name = (_c = (_b = (_a = process.argv.slice(2)) === null || _a === void 0 ? void 0 : _a.find(function (data) { return data === null || data === void 0 ? void 0 : data.includes('--name='); })) === null || _b === void 0 ? void 0 : _b.replace('--name=', '')) !== null && _c !== void 0 ? _c : null;
+    var migrate = (_e = (_d = process.argv.slice(2)) === null || _d === void 0 ? void 0 : _d.includes('--m')) !== null && _e !== void 0 ? _e : false;
+    var migrateFolder = (_h = (_g = (_f = process.argv.slice(2)) === null || _f === void 0 ? void 0 : _f.find(function (data) { return data === null || data === void 0 ? void 0 : data.includes('--f='); })) === null || _g === void 0 ? void 0 : _g.replace('--f=', '/')) !== null && _h !== void 0 ? _h : null;
+    var path = (_j = process.argv.slice(3)) === null || _j === void 0 ? void 0 : _j.shift();
+    var type = ((_l = (_k = process.argv.slice(2)) === null || _k === void 0 ? void 0 : _k.includes('--js')) !== null && _l !== void 0 ? _l : false) ? '.js' : '.ts';
+    var cmd = {
+        name: name,
+        path: path,
+        migrate: migrate,
+        migrateFolder: migrateFolder,
+        type: type,
+        cwd: process.cwd(),
+        fs: fs_1.default,
+        npm: 'tspace-mysql'
+    };
+    commands[process.argv[2]](cmd);
+}
+catch (err) {
+    console.log("\n    use make:model <folder/...folder/model name> --m\n    use make:table <folder/folder/...folder> --name=<name>\n    use migrate <folder/folder/...folder> \n");
+}

package/dist/cli/migrate/make.js

@@ -0,0 +1,62 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var child_process_1 = require("child_process");
+exports.default = (function (_ref) {
+    var e_1, _a;
+    var _b, _c, _d;
+    var path = _ref.path, type = _ref.type, cwd = _ref.cwd, fs = _ref.fs;
+    var split = path.split('/') || path;
+    var f = split.join('/');
+    try {
+        fs.accessSync(cwd + ("/" + f), fs.F_OK, {
+            recursive: true
+        });
+    }
+    catch (e) {
+        fs.mkdirSync(cwd + ("/" + f), {
+            recursive: true
+        });
+    }
+    try {
+        var dir = cwd + "/" + f;
+        var files = (_b = fs.readdirSync(dir)) !== null && _b !== void 0 ? _b : [];
+        if (!(files === null || files === void 0 ? void 0 : files.length))
+            console.log('this folder is empty');
+        var cmd = type === '.js' ? 'node' : 'ts-node';
+        try {
+            for (var files_1 = __values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                var t = files_1_1.value;
+                var run = (0, child_process_1.exec)(cmd + " " + dir + "/" + t);
+                (_c = run === null || run === void 0 ? void 0 : run.stdout) === null || _c === void 0 ? void 0 : _c.on('data', function (data) {
+                    if (data)
+                        console.log(data);
+                });
+                (_d = run === null || run === void 0 ? void 0 : run.stderr) === null || _d === void 0 ? void 0 : _d.on('data', function (err) {
+                    if (err)
+                        console.error(err);
+                });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (files_1_1 && !files_1_1.done && (_a = files_1.return)) _a.call(files_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    catch (err) {
+        console.log(err.message);
+    }
+});

package/dist/cli/models/make.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var model_1 = __importDefault(require("./model"));
+var table_1 = __importDefault(require("../tables/table"));
+var utils_1 = __importDefault(require("../../lib/utils"));
+exports.default = (function (_ref) {
+    var path = _ref.path, migrate = _ref.migrate, migrateFolder = _ref.migrateFolder, type = _ref.type, name = _ref.name, cwd = _ref.cwd, fs = _ref.fs, npm = _ref.npm;
+    var split = path.split('/') || path;
+    var model = split.pop();
+    var f = split.join('/');
+    try {
+        fs.accessSync(cwd + ("/" + f), fs.F_OK, {
+            recursive: true
+        });
+    }
+    catch (e) {
+        fs.mkdirSync(cwd + ("/" + f), {
+            recursive: true
+        });
+    }
+    var folder = cwd + "/" + f + "/" + model + type;
+    var data = (0, model_1.default)(name || model, npm);
+    fs.writeFile(folder, data, function (err) {
+        if (err)
+            throw err.message;
+    });
+    console.log("Model : '" + model + "' created successfully");
+    if (migrate) {
+        var tableName = utils_1.default.tableName(name || model);
+        var folder_1 = migrateFolder !== null && migrateFolder !== void 0 ? migrateFolder : "/" + f + "/Migrations";
+        try {
+            fs.accessSync(cwd + folder_1, fs.F_OK, {
+                recursive: true
+            });
+        }
+        catch (e) {
+            fs.mkdirSync(cwd + folder_1, {
+                recursive: true
+            });
+        }
+        var folderMigrate = cwd + "/" + folder_1 + "/create_" + tableName + "_table" + type;
+        var table = (0, table_1.default)(tableName, npm);
+        fs.writeFile(folderMigrate, table, function (err) {
+            if (err)
+                throw err;
+        });
+        console.log("Migration : '" + tableName + "' created successfully");
+    }
+});

package/dist/cli/models/model.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Model = function (model, npm) {
+    return "import { Model } from '" + npm + "'\nclass " + model + " extends Model {\n  constructor(){\n    super()\n    this.useTimestamp()\n  }\n}\nexport { " + model + " }\nexport default " + model + "\n";
+};
+exports.default = Model;

package/dist/cli/tables/make.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var table_1 = __importDefault(require("./table"));
+exports.default = (function (_ref) {
+    var path = _ref.path, name = _ref.name, type = _ref.type, cwd = _ref.cwd, fs = _ref.fs, npm = _ref.npm;
+    var split = path.split('/') || path;
+    var f = split.join('/');
+    if (name == null)
+        console.log("use " + npm + " make:table FOLDER/FOLDER --name=tableName");
+    else {
+        try {
+            fs.accessSync(cwd + ("/" + f), fs.F_OK, {
+                recursive: true
+            });
+        }
+        catch (e) {
+            fs.mkdirSync(cwd + ("/" + f), {
+                recursive: true
+            });
+        }
+        var folderMigrate = cwd + "/" + f + "/create_" + name + "_table" + type;
+        var table = (0, table_1.default)(name, npm);
+        fs.writeFile(folderMigrate, table, function (err) {
+            if (err)
+                console.log(err.message);
+        });
+        console.log("Migration : " + name + " created successfully");
+    }
+});

package/dist/cli/tables/table.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Table = function (model, npm) {
+    return "import { Schema , Blueprint , DB } from '" + npm + "'\n(async () => {\n    await new Schema().table('" + model + "',{ \n        id :  new Blueprint().int().notNull().primary().autoIncrement(),\n        name : new Blueprint().varchar(120).default('my name'),\n        email : new Blueprint().varchar(120).unique(),\n        email_verify : new Blueprint().tinyInt(),\n        password : new Blueprint().varchar(120),\n        birthdate : new Blueprint().date()\n    })\n\n    /**\n     * \n     *  @Faker data\n     *  await new DB().table('" + model + "').faker(5)\n    */\n})()\n";
+};
+exports.default = Table;

package/dist/lib/config/env.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+var dotenv_1 = __importDefault(require("dotenv"));
+var path_1 = __importDefault(require("path"));
+var NODE_ENV = (_a = process.env) === null || _a === void 0 ? void 0 : _a.NODE_ENV;
+var pathEnv = path_1.default.join(path_1.default.resolve(), ".env." + NODE_ENV);
+if (NODE_ENV == null)
+    pathEnv = path_1.default.join(path_1.default.resolve(), ".env");
+dotenv_1.default.config({ path: pathEnv });
+var env = Object.freeze({
+    DB_HOST: process.env.DB_HOST,
+    DB_PORT: process.env.DB_PORT,
+    DB_USERNAME: process.env.DB_USERNAME,
+    DB_PASSWORD: process.env.DB_PASSWORD,
+    DB_DATABASE: process.env.DB_DATABASE
+});
+exports.default = env;

package/dist/lib/connections/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("util");
+var mysql_1 = require("mysql");
+var options_1 = __importDefault(require("./options"));
+var pool = (0, mysql_1.createPool)(options_1.default);
+var optionIsNull = Object === null || Object === void 0 ? void 0 : Object.entries(options_1.default).some(function (_a) {
+    var _b = __read(_a, 2), _ = _b[0], option = _b[1];
+    return option == null;
+});
+var messsage = optionIsNull ?
+    "Can't get optionuration in environment !" :
+    "Connection lost to database !";
+pool.getConnection(function (err, connection) {
+    if (err) {
+        console.log("\u001B[1m\u001B[31m\n    " + messsage + " \u001B[0m\n    ------------------------------- \u001B[33m\n        DB_HOST     : " + (options_1.default === null || options_1.default === void 0 ? void 0 : options_1.default.host) + "         \n        DB_PORT     : " + (options_1.default === null || options_1.default === void 0 ? void 0 : options_1.default.port) + "        \n        DB_USERNAME : " + options_1.default.user + "           \n        DB_PASSWORD : " + options_1.default.password + "   \n        DB_DATABASE : " + options_1.default.database + " \u001B[0m  \n    -------------------------------\n    ");
+    }
+    if (connection)
+        connection.release();
+    return;
+});
+pool.query = (0, util_1.promisify)(pool.query);
+exports.default = pool;

package/dist/lib/connections/options.js

@@ -0,0 +1,32 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var env_1 = __importDefault(require("../config/env"));
+var defaultOptions = {
+    connectionLimit: 10,
+    dateStrings: true,
+    waitForConnections: false,
+    charset: 'utf8mb4'
+};
+var options = {
+    host: env_1.default.DB_HOST,
+    database: env_1.default.DB_DATABASE,
+    port: env_1.default.DB_PORT,
+    user: env_1.default.DB_USERNAME,
+    password: env_1.default.DB_PASSWORD
+};
+var configs = __assign(__assign({}, defaultOptions), options);
+exports.default = configs;