tspace-mysql 1.1.7 → 1.1.9

package/README.md

@@ -15,7 +15,7 @@ npm install tspace-mysql --save
 ```
 ## Basic Usage
 - [Configuration](#configuration)
-- [Running Queries](#running-queryies)
+- [Running Queries](#running-queries)
 - [Database Transactions](#database-transactions)
 - [Connection](#connection)
 - [Backup](#backup)
@@ -26,6 +26,7 @@ npm install tspace-mysql --save
   - [One To Many](#one-to-many)
   - [Belongs To](#belongs-to)
   - [Many To Many](#many-to-many)
+  - [Relation in Relation](#relation-in-relation)
 - [Query Builder](#query-builder)
 - [Cli](#cli)
   - [Make Model](#make-model)
@@ -36,11 +37,20 @@ npm install tspace-mysql --save
 ## Configuration
 Created your environment variables is to use a .env file, you may establish a connection is this:
 ```js
-DB_HOST = localhost
-DB_PORT = 3306
+DB_HOST     = localhost
+DB_PORT     = 3306
 DB_USERNAME = root
 DB_PASSWORD = password
 DB_DATABASE = database
+
+/** default
+    DB_CONNECTION_LIMIT = 30
+    DB_CONNECTION_ERROR = true
+    DB_QUEUE_LIMIT      = 25
+    DB_TIMEOUT          = 30000
+    DB_DATE_STRINGS     = true
+*/
+
 ```
 ## Running Queries
 Once you have configured your database connection, you may run queries is this :
@@ -54,6 +64,16 @@ Once you have configured your database connection, you may run queries is this :
 | 2           | tspace2      | tspace2@gmail.com          |
 +-------------+--------------+----------------------------+
 
+
++-------------+--------------+----------------------------+
+|                     table posts                         |
++-------------+--------------+----------------------------+
+| id          | user_id      | title                      |
+|-------------|--------------|----------------------------|
+| 1           | 1            | posts tspace               |
+| 2           | 2            | posts tspace2              |
++-------------+--------------+----------------------------+
+
 import { DB } from 'tspace-mysql'
 (async () => {
     await new DB('users').findMany() // SELECT * FROM users => Array
@@ -66,14 +86,51 @@ const selectQuery = await new DB('users').select('id','username').findOne()
     // selectQuery => { id : 1, username : 'tspace'}
 const selectQueries = await new DB('users').select('id','username').findMany() 
     // selectQueries => [{ id : 1, username : 'tspace' } , { id : 2, username : 'tspace2'}]
+
+/**
+ * @example except
+ */
+await new DB('users').except('id','username').findOne() 
 ```
+
+Running A OrderBy & GroupBy Query
+```js
+await new DB('users').orderBy('id','asc').findOne()
+await new DB('users').orderBy('id','desc').findOne()
+await new DB('users').oldest('id').findOne()
+await new DB('users').latest('id').findOne()
+
+await new DB('users').groupBy('id').findOne()
+await new DB('users').groupBy('id','usernamename').findOne()
+```
+
+Running A Join Query
+```js
+await new DB('posts').join('posts.user_id' , 'users.id').findOne()
+await new DB('posts').leftJoin('posts.user_id' , 'users.id').findOne()
+await new DB('posts').rightJoin('posts.user_id' , 'users.id').findOne()
+```
+
 Running A Where Query
 ```js
 const user = await new DB('users').where('id',1).findOne()
     // user => { id : 1 , username : 'tspace', email : 'tspace@gmail.com'}
 const users = await new DB('users').where('id','!=',1).findMany()
     // users => [{ id : 2 , username : 'tspace2' , email : 'tspace2@gmail.com' }]
+
+const whereIn = await new DB('users').whereIn('id',[1,2]).findMany()
+const whereBetween = await new DB('users').whereBetween('id',[1,2]).findMany()
+const whereSubQuery = await new DB('users').whereSubQuery('id','select id from users').findMany()
+// await new DB('users').whereSubQuery('id',new DB('users').select('id').toString()).findMany()
+const whereNull = await new DB('users').whereNull('username').findOne()
 ```
+
+Running A Hook Query
+```js
+const hookResult = (result) => console.log(result)
+const user = await new DB('users').where('id',1).hook(hookResult).findOne()
+```
+
 Running A Insert Query
 ```js
 const user = await new DB('users')
@@ -91,6 +148,33 @@ const reposity = new DB('users')
     await reposity.save()
 const { result } = reposity
     // result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
+
+const users = await new DB('users')
+    .createMultiple([
+        {
+            name :'tspace4',
+            email : 'tspace4@gmail.com'
+        },
+        {
+            name :'tspace5',
+            email : 'tspace5@gmail.com'
+        },
+        {
+            name :'tspace6',
+            email : 'tspace6@gmail.com'
+        },
+    ]).save()
+
+const users = await new DB('users')
+    .where('name','tspace4')
+    .where('email','tspace4@gmail.com')
+    .createNotExists({
+            name :'tspace4',
+            email : 'tspace4@gmail.com'
+    })
+    .save()
+    // if has exists return null, if not exists created new data
+
 ```
 Running A Update Query
 ```js
@@ -110,7 +194,19 @@ const reposity = new DB('users').where('id',1)
     await reposity.save()
 const { result } = reposity
     // result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
-```    
+```
+
+Running A  Update Or Created Query
+```js
+const user = await new DB('users')
+    .where('id',1)
+    .updateOrCreate({
+          name : 'tspace1**',
+          email : 'tspace1@gmail.com'
+    }).save()
+    // user =>  { username : 'tspace1**', email : 'tspace1@gmail.com' } 
+```  
+
 Running A Delete Query
 ```js
 const deleted = await new DB('users').where('id',1).delete()
@@ -118,7 +214,7 @@ const deleted = await new DB('users').where('id',1).delete()
 ``` 
 ## Database Transactions 
 
-Within a database transaction, you may use the:
+Within a Database Transaction, you may use the:
 
 ```js
 const connection = await new DB().beginTransaction()
@@ -157,16 +253,9 @@ try {
             title : `tspace-post3`
         }
     ])
-    /**
-     *
-     * bind method for make sure this connection has same transaction in connection
-     * @params {Function} connection 
-     */
-    .bind(connection)
+    .bind(connection) // don't forget this
     .save()
 
-    // throw new Error('try error')
-
     /**
      *
      * @commit commit transaction to database
@@ -187,14 +276,16 @@ try {
 ## Connection
 When establishing a connection, you may establish options is this:
 ```js
+const connection = await new DB().getConnection({
+    host: 'localhost',
+    port : 3306,
+    database: 'database'
+    username: 'username',
+    password: 'password',
+})
+
 const users = await new DB('users')
-    .connection({
-       host: 'localhost',
-       port : 3306,
-       database: 'database'
-       username: 'username',
-       password: 'password',
-    })
+    .bind(connection)
     .findMany()
 // users => [{ .... }]
 ```
@@ -265,7 +356,17 @@ import { Model } from 'tspace-mysql'
 class User extends Model {
   constructor(){
     super()
-    this.useTimestamp()
+    this.useTimestamp() /** created_at , updated_at
+    /**
+     * 
+     * @Custom 
+     * 
+     * this.useTimestamp({
+     *    createdAt : 'created_at',
+     *    updatedAt : 'updated_at'
+     * }) 
+     */
+
     /*
      * the "snake case", plural name of the class will be used as the table name 
      * 
@@ -289,7 +390,7 @@ import Phone  from '../Phone'
 class User extends Model {
     constructor(){
         super()
-        this.useTimestamp()
+        this.useTimestamp() 
         /**
          *
          * @hasOne Get the phone associated with the user.
@@ -298,13 +399,12 @@ class User extends Model {
         this.hasOne({ name : 'phone' , model : Phone })
     }
     /**
-     * @hasOneQuery Get the phone associated with the user. using function callback
+     * Mark a method for relationship 
+     * @hasOne Get the phone associated with the user. using function callback
      * @function 
      */
     phone (callback ?: Function) {
-        return  this.hasOneQuery({ model : Phone }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return this.hasOneBuilder({ name : 'phone' , model : Phone } , callback)
     }
 }
 export default User
@@ -335,13 +435,12 @@ class Post extends Model {
         this.hasMany({ name : 'comments' , model : Comment })
     }
     /**
+     * 
      * @hasManyQuery Get the comments for the post. using function callback
      * @function 
      */
     comments (callback ?: Function) {
-        return  this.hasManyQuery({ model : Comment }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return  this.hasManyBuilder({ name : 'comments' , model : Comment } , callback)
     }
 }
 export default Post
@@ -372,13 +471,12 @@ class Phone extends Model {
         this.belognsTo({ name : 'user' , model : User })
     }
     /**
+     * 
      * @belongsToQuery Get the user that owns the phone.. using function callback
      * @function 
      */
     user (callback ?: Function) {
-        return  this.belongsToQuery({ model : User }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return this.belongsToBuilder({ name : 'user' , model : User }, callback)
     }
 }
 export default Phone
@@ -413,9 +511,7 @@ class User extends Model {
      * @function 
      */
     roles (callback ?: Function) {
-        return  this.belongsToManyQuery({ model : Role }, (query) => {
-            return callback ? callback(query) : query
-        })
+        return this.belognsToManyBuilder({ model : Role } , callback)
     }
 }
 export default User
@@ -428,6 +524,52 @@ const user = await new User().relations('roles').findOne()
 const userUsingFunction = await new User().roles().findOne()
 // user?.roles => [{...}]
 ```
+
+## Relation in Relation
+Relationships can deep relations. 
+let's example a deep in relations :
+```js
+import { Model } from 'tspace-mysql'
+
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'posts' , model : Post })
+    }
+}
++--------------------------------------------------------------------------+
+class Post extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'comments' , model : Comment })
+        this.belongsTo({ name : 'user' , model : User })
+    }
+}
++--------------------------------------------------------------------------+
+class Comment extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'users' , model : User })
+        this.belongsTo({ name : 'post' , model : Post })
+    }
+}
++--------------------------------------------------------------------------+
+await new User().relations('posts')
+    .relationQuery('posts', (query : Post) => { // relationQuery return a callback query in model registry
+        return query.relations('comments','user')
+        .relationQuery('comments', (query : Comment) => {
+            return query.relations('user','post')
+        })
+        .relationQuery('user', (query : User) => {
+            return query.relations('posts').relationQuery('posts',(query : Post)=> {
+                return query.relations('comments','user')
+                // relation n to ...n
+            })
+        })
+    })
+    .findMany()
+```
+
 ## Query Builder
 Methods builder for queries
 ```js
@@ -436,13 +578,20 @@ 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])
+whereQuery(callback)
+whereRaw(sql)
+whereExists(sql)
 whereSubQuery(colmn , rawSQL)
+whereNotSubQuery(colmn , rawSQL)
+orWhere(column , operator , value)   
+orWhereRaw(sql)
+orWhereIn(column , [])
+orWhereSubQuery(colmn , rawSQL)
 select(column1 ,column2 ,...N)
 except(column1 ,column2 ,...N)
 only(column1 ,column2 ,...N)
@@ -451,8 +600,8 @@ 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)
+orderBy (column ,'ASC' || 'DSCE')
 latest (column)
 oldest (column)
 groupBy (column)
@@ -464,6 +613,7 @@ updateOrCreate (objects)
 connection(options)
 backup({ database , connection })
 backupToFile({ filePath, database , connection })
+hook((result) => ...) // callback result to function
 
 /** 
  * registry relation in your models
@@ -510,9 +660,14 @@ save() /*for action statements insert update or delete */
 ```
 
 ## Cli
-To get started, let's install npm install tspace-mysql -g
+To get started, let's install tspace-mysql
 you may use a basic cli :
 
+```sh
+npm install tspace-mysql -g
+
+```
+
 ## Make Model
 Command will be placed Model in the specific directory
 ```js
@@ -638,12 +793,12 @@ timestamp ()
  * @Attrbuites
  * 
 */
-unsigned ()
-unique ()
-null ()
-notNull ()
+unsigned()
+unique()
+null()
+notNull()
 primary() 
-default (string) 
-defaultTimestamp () 
-autoIncrement () 
+default(string) 
+defaultTimestamp() 
+autoIncrement() 
 ```

package/dist/cli/generate/make.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (cmd: {
+    [x: string]: any;
+}) => void;
+export default _default;

package/dist/cli/generate/make.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = __importDefault(require("../models/model"));
+const pluralize_1 = __importDefault(require("pluralize"));
+const lib_1 = require("../../lib");
+exports.default = (cmd) => {
+    const { dir, cwd, type, fs, npm } = cmd;
+    if (dir) {
+        try {
+            fs.accessSync(cwd + `/${dir}`, fs.F_OK, {
+                recursive: true
+            });
+        }
+        catch (e) {
+            fs.mkdirSync(cwd + `/${dir}`, {
+                recursive: true
+            });
+        }
+    }
+    const snake2Pascal = (data) => {
+        let str = data.split('_');
+        for (let i = 0; i < str.length; i++) {
+            str[i] = str[i].slice(0, 1).toUpperCase() + str[i].slice(1, str[i].length);
+        }
+        return str.join('');
+    };
+    new lib_1.DB().rawQuery('SHOW TABLES')
+        .then(tables => {
+        var _a;
+        for (let i = 0; i < tables.length; i++) {
+            const table = String((_a = Object.values(tables[i])) === null || _a === void 0 ? void 0 : _a.shift());
+            const model = snake2Pascal(pluralize_1.default.singular(table));
+            const data = (0, model_1.default)(model, npm);
+            fs.writeFile(`${dir}/${model}.${type !== null && type !== void 0 ? type : 'ts'}`, data, (err) => {
+                if (err)
+                    throw err;
+            });
+            console.log(`Model : '${model}' created successfully`);
+        }
+        console.log('\nGenerate Models has completed');
+    })
+        .catch(err => console.log(err));
+};

package/dist/cli/index.js

@@ -3,30 +3,36 @@
 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, _m, _o;
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const make_1 = __importDefault(require("./models/make"));
 const make_2 = __importDefault(require("./tables/make"));
 const make_3 = __importDefault(require("./migrate/make"));
+const make_4 = __importDefault(require("./generate/make"));
+const query_1 = __importDefault(require("./query"));
 const commands = {
+    'query': query_1.default,
     'make:model': make_1.default,
     'make:table': make_2.default,
     'make:migration': make_2.default,
-    'migrate': make_3.default
+    'migrate': make_3.default,
+    'generate:models': make_4.default
 };
 try {
-    const name = process.argv.slice(2)?.find(data => {
-        return data?.includes('--name=');
-    })?.replace('--name=', '') ?? null;
-    const migrate = process.argv.slice(2)?.includes('--m') ?? false;
-    const dir = process.argv.slice(2)?.find(data => {
-        return data?.includes('--dir=');
-    })?.replace('--dir=', '/') ?? null;
-    let type = process.argv.slice(2)?.find(data => {
-        return data?.includes('--type=');
-    })?.replace('--type=', '.') ?? '.ts';
+    const name = (_c = (_b = (_a = process.argv.slice(2)) === null || _a === void 0 ? void 0 : _a.find(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;
+    const sql = (_d = process.argv.slice(3)[0]) !== null && _d !== void 0 ? _d : '';
+    const migrate = (_f = (_e = process.argv.slice(2)) === null || _e === void 0 ? void 0 : _e.includes('--m')) !== null && _f !== void 0 ? _f : false;
+    const dir = (_j = (_h = (_g = process.argv.slice(2)) === null || _g === void 0 ? void 0 : _g.find(data => {
+        return data === null || data === void 0 ? void 0 : data.includes('--dir=');
+    })) === null || _h === void 0 ? void 0 : _h.replace('--dir=', '/')) !== null && _j !== void 0 ? _j : null;
+    let type = (_m = (_l = (_k = process.argv.slice(2)) === null || _k === void 0 ? void 0 : _k.find(data => {
+        return data === null || data === void 0 ? void 0 : data.includes('--type=');
+    })) === null || _l === void 0 ? void 0 : _l.replace('--type=', '.')) !== null && _m !== void 0 ? _m : '.ts';
     type = ['.js', '.ts'].includes(type) ? type : '.ts';
-    const file = process.argv.slice(3)?.shift() ?? '';
+    const file = (_o = process.argv.slice(3)[0]) !== null && _o !== void 0 ? _o : '';
     const cmd = {
         name,
         file,
@@ -35,10 +41,11 @@ try {
         type,
         cwd: process.cwd(),
         fs: fs_1.default,
+        sql,
         npm: 'tspace-mysql'
     };
     commands[process.argv[2]](cmd);
 }
 catch (err) {
-    console.log(`readme https://www.npmjs.com/package/tspace-mysql`);
+    console.log(`Readme https://www.npmjs.com/package/tspace-mysql`);
 }

package/dist/cli/migrate/make.js

@@ -2,22 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 exports.default = (formCommand) => {
+    var _a, _b, _c;
     const { type, dir, cwd, fs } = formCommand;
     try {
         if (dir == null)
             throw new Error('Not found directory');
         const path = `${cwd}/${dir}`;
-        const files = fs.readdirSync(path) ?? [];
-        if (!files?.length)
+        const files = (_a = fs.readdirSync(path)) !== null && _a !== void 0 ? _a : [];
+        if (!(files === null || files === void 0 ? void 0 : files.length))
             console.log('this folder is empty');
         const cmd = type === '.js' ? 'node' : 'ts-node';
         for (const _file of files) {
             const run = (0, child_process_1.exec)(`${cmd} ${path}/${_file}`);
-            run?.stdout?.on('data', (data) => {
+            (_b = run === null || run === void 0 ? void 0 : run.stdout) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
                 if (data)
                     console.log(data);
             });
-            run?.stderr?.on('data', (err) => {
+            (_c = run === null || run === void 0 ? void 0 : run.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (err) => {
                 if (err)
                     console.error(err);
             });

package/dist/cli/models/make.d.ts

@@ -1,4 +1,4 @@
-declare const _default: (formCommand: {
+declare const _default: (cmd: {
     [x: string]: any;
 }) => void;
 export default _default;

package/dist/cli/models/make.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const model_1 = __importDefault(require("./model"));
 const table_1 = __importDefault(require("../tables/table"));
 const pluralize_1 = __importDefault(require("pluralize"));
-exports.default = (formCommand) => {
-    const { file, migrate, dir, type, cwd, fs, npm } = formCommand;
+exports.default = (cmd) => {
+    const { file, migrate, dir, type, cwd, fs, npm } = cmd;
     if (dir) {
         try {
             fs.accessSync(cwd + `/${dir}`, fs.F_OK, {

package/dist/cli/models/model.js

@@ -14,10 +14,9 @@ class ${model} extends Model {
      * this.usePrimaryKey('id') // => runing a uuid (universally unique identifier) when insert new data
      * this.useTimestamp({ createdAt : 'created_at' , updatedAt : 'updated_at' }) // runing a timestamp when insert or update
      * this.useSoftDelete()
-     * this.useDisableSoftDeleteInRelations()
-     * this.useTable('Users')
-     * this.useTableSingular()
-     * this.useTablePlural()
+     * this.useTable('users')
+     * this.useTableSingular() // 'user'
+     * this.useTablePlural() // 'users'
      * this.usePattern('snake_case')   
      * this.useUUID('uuid')
      * this.useRegistry()

package/dist/cli/query/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (cmd: {
+    [x: string]: any;
+}) => void;
+export default _default;

package/dist/cli/query/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lib_1 = require("../../lib");
+exports.default = (cmd) => {
+    const { sql } = cmd;
+    new lib_1.DB().rawQuery(sql).then(result => console.log(result));
+};

package/dist/lib/connection/index.d.ts

@@ -1,48 +1,30 @@
-export interface PoolCallback {
-    query: (sql: string, callback: (err: any, result: any) => void) => void;
-    release: () => void;
-}
-export interface ConnectionTransaction {
-    query: (sql: string) => Promise<any[]>;
-    startTransaction: () => Promise<any[]>;
-    commit: () => Promise<any[]>;
-    rollback: () => Promise<any[]>;
-}
-export interface Connection {
-    query: (sql: string) => Promise<any[]>;
-    connection: () => Promise<ConnectionTransaction>;
-}
-export interface Options {
-    [key: string]: any;
-    connectionLimit?: number;
-    dateStrings?: boolean;
-    waitForConnections?: boolean;
-    charset?: string;
-    host: string;
-    port: number;
-    database: string;
-    user: string;
-    password: string;
-}
+import { Connection, Options } from '../tspace/Interface';
 export declare class PoolConnection {
     private OPTIONS;
-    constructor(options?: Options);
     /**
      *
-     * Set a options connection pool
-     * @return {this} this
+     * @Init a options connection pool
      */
-    options(options: Options): this;
+    constructor(options?: Options);
     /**
      *
-     * Get a connection pool
+     * Get a connection to database
      * @return {Connection} Connection
+     * @property {Function} Connection.query
+     * @property {Function} Connection.connection
      */
     connection(): Connection;
     private _defaultOptions;
-    private _getJsonOptions;
+    private _loadOptions;
     private _messageError;
 }
-declare const Pool: Connection;
-export { Pool };
-export default Pool;
+/**
+ *
+ * Connection to database when service is started
+ * @return {Connection} Connection
+ * @property {Function} Connection.query
+ * @property {Function} Connection.connection
+ */
+declare const pool: Connection;
+export { pool as Pool };
+export default pool;