tspace-mysql 1.3.3 → 1.3.5

package/README.md

@@ -26,7 +26,8 @@ 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)
+  - [Deeply Nested Relations](#deeply-nested-relations)
+  - [Relation Exists](#relation-exists)
   - [Built in Relation Functions](#built-in-relation-functions)
 - [Query Builder](#query-builder)
 - [Cli](#cli)
@@ -38,7 +39,7 @@ npm install tspace-mysql --save
 - [Blueprint](#blueprint)
 
 ## Configuration
-Created your environment variables is to use a .env file, you may establish a connection is this:
+Created your environment variables is to use a '.env' file, you may establish a connection is this:
 ```js
 DB_HOST     = localhost
 DB_PORT     = 3306
@@ -54,6 +55,22 @@ DB_DATABASE = database
  *  DB_TIMEOUT          = 60000
  *  DB_DATE_STRINGS     = true
 */
+```
+Or you can created file name 'db.tspace' to use a connection  this:
+```js
+source db {
+    host               = localhost
+    port               = 3306
+    database           = npm
+    user               = root
+    password           = 
+    connectionLimit    = 10 
+    dateStrings        = true
+    connectTimeout     = 60000
+    waitForConnections = true
+    queueLimit         = 0
+    charset            = utf8mb4
+}
 
 ```
 ## Running Queries
@@ -112,9 +129,9 @@ 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()
+await new DB('posts').join('posts.user_id' , 'users.id').findMany()
+await new DB('posts').leftJoin('posts.user_id' , 'users.id').findMany()
+await new DB('posts').rightJoin('posts.user_id' , 'users.id').findMany()
 ```
 
 Running A Where Query
@@ -386,22 +403,32 @@ class User extends Model {
      *    createdAt : 'created_at',
      *    updatedAt : 'updated_at'
      * }) // runing a timestamp when insert or update
-     * this.useSoftDelete()
+     * this.useSoftDelete('deletedAt') // => default target to colmun deleted_at 
      * this.useTable('users')
-     * this.useTableSingular() // 'user'
-     * this.useTablePlural() // 'users'
-     * this.usePattern('snake_case')   
+     * this.useTableSingular() // => 'user'
+     * this.useTablePlural() // => 'users'
+     * this.usePattern('snake_case') // => default 'snake_case'   
      * this.useUUID('uuid') // => runing a uuid (universally unique identifier) when insert new data
-     * this.useRegistry()
-     * this.useLoadRelationInRegistry()
-     * this.useBuiltInRelationFunctions()
+     * this.useRegistry() // => build-in functions registry
+     * this.useLoadRelationsInRegistry() // => auto generated results from relationship to results
+     * this.useBuiltInRelationFunctions() // => build-in functions relationships to results
      * this.useSchema({
      *   id : Number,
      *   username : String
      *   created_at : Date,
      *   updated_at : Date,
-     *  }) // validate type of schema when return results
-    */
+     *  }) // => validate type of schema when return results
+     * this.useCreateTableIfNotExists ({ 
+     *     id          : new Blueprint().int().notNull().primary().autoIncrement(),
+     *     uuid        : new Blueprint().varchar(50).null(),
+     *     user_id     : new Blueprint().int().notNull(),
+     *     title       : new Blueprint().varchar(255).null(),
+     *     created_at  : new Blueprint().timestamp().null(),
+     *     updated_at  : new Blueprint().timestamp().null(),
+     *     deleted_at  : new Blueprint().timestamp().null()
+     *   })
+     */
+
 
     /*
      * the "snake case", plural name of the class will be used as the table name 
@@ -508,7 +535,7 @@ class Phone extends Model {
     }
     /**
      * 
-     * @belongsToQuery Get the user that owns the phone.. using function callback
+     * @belongsToBuilder Get the user that owns the phone.. using function callback
      * @function 
      */
     user (callback ?: Function) {
@@ -543,7 +570,7 @@ class User extends Model {
         this.belognsToMany({ name : 'roles' , model : Role })
     }
     /**
-     * @belongsToQuery Get the user that owns the phone.. using function callback
+     * @belongsToBuilder Get the user that owns the phone.. using function callback
      * @function 
      */
     roles (callback ?: Function) {
@@ -561,8 +588,8 @@ const userUsingFunction = await new User().roles().findOne()
 // user?.roles => [{...}]
 ```
 
-## Relation in Relation
-Relationships can deep relations. 
+## Deeply Nested Relations
+Relationships can deeply relations. 
 let's example a deep in relations :
 ```js
 import { Model } from 'tspace-mysql'
@@ -590,8 +617,9 @@ class Comment extends Model {
     }
 }
 +--------------------------------------------------------------------------+
+// Deeply nested relations
 await new User().relations('posts')
-    .relationQuery('posts', (query : Post) => { // relationQuery return a callback query in model registry
+    .relationQuery('posts', (query : Post) => { 
         return query.relations('comments','user')
         .relationQuery('comments', (query : Comment) => {
             return query.relations('user','post')
@@ -604,6 +632,129 @@ await new User().relations('posts')
         })
     })
     .findMany()
+
+// Select some columns in nested relations    
+await new User().relations('posts')
+    .relationQuery('posts', (query : Post) => query.select('id','user_id','title'))
+    .findMany()
+
+// Where some columns in nested relations
+await new User().relations('posts')
+    .relationQuery('posts', (query : Post) => query.whereIn('id',[1,3,5]))
+    .findMany()
+
+// Sort data in  nested relations
+await new User().relations('posts')
+    .relationQuery('posts', (query : Post) => query.latest('id'))
+    .findMany()
+
+// Limit data in  nested relations
+await new User().relations('posts')
+    .relationQuery('posts', (query : Post) => {
+        return query
+        .limit(1)
+        .relations('comments')
+        .relationQuery('comments', (query : Comment) => query.limit(1))
+    })
+    .findMany()
+
+```
+## Relation Exists
+Relationships can return only result is not isempty related with soft delete. 
+let's example a exists in relations :
+```js
++-------------+--------------+----------------------------+--------------------+
+|                     table users                         |                    |
++-------------+--------------+----------------------------+--------------------+
+| id          | username     | email                      | deleted_at         |
+|-------------|--------------|----------------------------|--------------------|
+| 1           | tspace1      | tspace1@gmail.com          |                    |
+| 2           | tspace2      | tspace2@gmail.com          |                    |
+| 3           | tspace3      | tspace3@gmail.com          |                    |
++-------------+--------------+----------------------------+--------------------+
+
+
++-------------+--------------+----------------------------+--------------------+
+|                     table posts                         |                    |
++-------------+--------------+----------------------------+--------------------+
+| id          | user_id      | title                      | deleted_at         |
+|-------------|--------------|----------------------------|--------------------|
+| 1           | 1            | posts 1                    |2020-07-15 00:00:00 |
+| 2           | 2            | posts 2                    |                    |
+| 3           | 3            | posts 3                    |2020-07-15 00:00:00 |
++-------------+--------------+----------------------------+--------------------+
+
+import { Model } from 'tspace-mysql'
+
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'posts' , model : Post })
+        this.useSoftDelete()
+    }
+}
+
++--------------------------------------------------------------------------+
+
+class Post extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'comments' , model : Comment })
+        this.belongsTo({ name : 'user' , model : User })
+        this.useSoftDelete()
+    }
+}
+// normal relations
+await new User().relations('posts').findMany()
+/*
+ * @returns [
+ *  {
+ *      id : 1,
+ *      username:  "tspace1",
+ *      email : "tspace1@gmail.com",
+ *      posts : []  
+ *  },
+ *  {
+ *      id : 2,
+ *      username:  "tspace2",
+ *      email : "tspace2@gmail.com",
+ *      posts : [
+ *       {
+ *          id : 2,
+ *          user_id :  2,
+ *          title : "posts 2"
+ *        }
+ *      ]   
+ *  },
+ *  {
+ *      id : 3,
+ *      username:  "tspace3",
+ *      email : "tspace3@gmail.com",
+ *      posts : []  
+ *  }
+ * ]
+*/
+
+await new User().relationsExists('posts').findMany()
+/* 
+ * @returns [
+ *  {
+ *      id : 2,
+ *      username:  "tspace2",
+ *      email : "tspace2@gmail.com",
+ *      posts : [
+ *       {
+ *          id : 2,
+ *          user_id :  2,
+ *          title : "posts 2"
+ *        }
+ *      ]  
+ *  }
+ * ]
+ * because posts id 1 and id 3 has been removed from database using soft delete
+ */
+
+
 ```
 
 ## Built in Relation Functions

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

@@ -16,6 +16,8 @@ export declare class PoolConnection {
     connection(): Connection;
     private _defaultOptions;
     private _loadOptions;
+    private _convertStringToObject;
+    private _covertKeyTypeToCorrectType;
     private _messageError;
 }
 /**

package/dist/lib/connection/index.js

@@ -34,7 +34,7 @@ class PoolConnection {
                     return;
                 const message = this._messageError.bind(this);
                 process.nextTick(() => {
-                    console.log(message());
+                    console.log(message(err === null || err === void 0 ? void 0 : err.message));
                     return process.exit();
                 });
             });
@@ -79,65 +79,114 @@ class PoolConnection {
     }
     _defaultOptions() {
         return new Map(Object.entries({
-            connectionLimit: Number(options_1.default.CONNECTION_LIMIT),
+            connectionLimit: Number.isNaN(Number(options_1.default.CONNECTION_LIMIT)) ? 30 : Number(options_1.default.CONNECTION_LIMIT),
             dateStrings: Boolean(options_1.default.DATE_STRINGS),
-            connectTimeout: Number(options_1.default.TIMEOUT),
+            connectTimeout: Number.isNaN(Number(options_1.default.TIMEOUT)) ? 60 * 1000 : Number(options_1.default.TIMEOUT),
             waitForConnections: Boolean(options_1.default.WAIT_FOR_CONNECTIONS),
-            queueLimit: Number(options_1.default.QUEUE_LIMIT),
-            multipleStatements: true,
+            queueLimit: Number.isNaN(Number(options_1.default.QUEUE_LIMIT) ? 0 : Number(options_1.default.QUEUE_LIMIT)),
             charset: String(options_1.default.CHARSET),
             host: String(options_1.default.HOST),
-            port: Number.isNaN(Number(options_1.default.PORT))
-                ? 3306
-                : Number(options_1.default.PORT),
+            port: Number.isNaN(Number(options_1.default.PORT)) ? 3306 : Number(options_1.default.PORT),
             database: String(options_1.default.DATABASE),
             user: String(options_1.default.USERNAME),
-            password: String(options_1.default.PASSWORD) !== ''
-                ? String(options_1.default.PASSWORD)
-                : ''
+            password: String(options_1.default.PASSWORD) === '' ? '' : String(options_1.default.PASSWORD),
+            multipleStatements: options_1.default.MULTIPLE_STATEMENTS || false,
+            enableKeepAlive: options_1.default.ENABLE_KEEP_ALIVE || false,
+            keepAliveInitialDelay: options_1.default.KEEP_ALIVE_DELAY || 0,
         }));
     }
     _loadOptions() {
         try {
             /**
-             *
-             * @Json connection
-             *
-                "host"                  : "",
-                "port"                  : "",
-                "database"              : "",
-                "user"                  : "",
-                "password"              : "",
-                "connectionLimit"       : "",
-                "dateStrings"           : "",
-                "idleTimeout"           : "",
-                "waitForConnections"    : "",
-                "queueLimit"            : "",
-                "charset"               : ""
+             *  @source data
+             *  source db {
+             *       host               = localhost
+             *       port               = 3306
+             *       database           = npm
+             *       user               = root
+             *       password           =
+             *       connectionLimit    =
+             *       dateStrings        =
+             *       connectTimeout     =
+             *       waitForConnections =
+             *       queueLimit         =
+             *       charset            =
+             *   }
              */
-            const jsonPath = path_1.default.join(path_1.default.resolve(), 'tspace-mysql.json');
-            const jsonOptionsExists = fs_1.default.existsSync(jsonPath);
-            if (!jsonOptionsExists)
+            const dbOptionsPath = path_1.default.join(path_1.default.resolve(), 'db.tspace');
+            const dbOptionsExists = fs_1.default.existsSync(dbOptionsPath);
+            if (!dbOptionsExists)
+                return this._defaultOptions();
+            const dbOptions = fs_1.default.readFileSync(dbOptionsPath, 'utf8');
+            const options = this._convertStringToObject(dbOptions);
+            if (options == null)
                 return this._defaultOptions();
-            const jsonOptions = fs_1.default.readFileSync(jsonPath, 'utf8');
-            const options = JSON.parse(jsonOptions);
             return new Map(Object.entries(options));
         }
         catch (e) {
             return this._defaultOptions();
         }
     }
-    _messageError() {
+    _convertStringToObject(str, target = 'db') {
+        if (str.toLocaleLowerCase().includes('#ignore'))
+            return null;
+        str = str.trim();
+        const sources = str.split('\n\n');
+        if (!sources.length)
+            return null;
+        const lines = sources[0].split('\r\n');
+        if (!lines.length)
+            return null;
+        const sourceObj = {};
+        let targetKey = '';
+        for (const line of lines) {
+            let [key, value] = line.split('=');
+            const sourceKey = key.match(/source\s+(\w+)/);
+            const sourceKeyClose = key.match(/}/g);
+            if (sourceKey != null) {
+                targetKey = sourceKey[1];
+                continue;
+            }
+            if (sourceKeyClose != null && sourceKeyClose.length) {
+                targetKey = '';
+                continue;
+            }
+            if (key == null || value == null)
+                continue;
+            key = key.trim();
+            value = value.trim();
+            if (!sourceObj.hasOwnProperty(targetKey))
+                sourceObj[targetKey] = {};
+            sourceObj[targetKey][key] = value;
+        }
+        return this._covertKeyTypeToCorrectType(sourceObj[target]) || null;
+    }
+    _covertKeyTypeToCorrectType(data) {
+        for (const [key, value] of Object.entries(data)) {
+            if (value == null)
+                continue;
+            if (typeof value === 'string' && ['true', 'false'].some(v => value.toLowerCase() === v)) {
+                data[key] = JSON.parse(value.toLowerCase());
+                continue;
+            }
+            if (/^[0-9]+$/.test(value))
+                data[key] = +value;
+        }
+        return data;
+    }
+    _messageError(err) {
         return `
             \x1b[1m\x1b[31m
             Connection lost to database ! \x1b[0m
-            --------------------------------- \x1b[33m
+            ------------------------------- \x1b[33m
                 HOST     : ${this.OPTIONS.get('host')}         
                 PORT     : ${this.OPTIONS.get('port')}        
                 DATABASE : ${this.OPTIONS.get('database')} 
                 USERNAME : ${this.OPTIONS.get('user')}          
-                PASSWORD : ${this.OPTIONS.get('password')} \x1b[0m  
-            ---------------------------------
+                PASSWORD : ${this.OPTIONS.get('password')} \x1b[0m 
+            -------------------------------
+            \x1b[1m\x1b[31mError Message 
+            : ${err !== null && err !== void 0 ? err : ''} \x1b[0m
         `;
     }
 }

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

@@ -1,15 +1,19 @@
 declare const _default: Readonly<{
+    [x: string]: any;
     HOST?: string | null | undefined;
     PORT?: string | number | undefined;
-    USERNAME?: string | undefined;
-    PASSWORD?: string | undefined;
-    DATABASE?: string | undefined;
+    USERNAME?: string | null | undefined;
+    PASSWORD?: string | null | undefined;
+    DATABASE?: string | null | undefined;
     CONNECTION_LIMIT?: string | number | undefined;
     QUEUE_LIMIT?: string | number | undefined;
     TIMEOUT?: string | number | undefined;
-    CHARSET?: string | undefined;
+    CHARSET?: string | null | undefined;
     CONNECTION_ERROR?: string | boolean | undefined;
     WAIT_FOR_CONNECTIONS?: string | boolean | undefined;
     DATE_STRINGS?: string | boolean | undefined;
+    KEEP_ALIVE_DELAY?: string | number | undefined;
+    ENABLE_KEEP_ALIVE?: string | boolean | undefined;
+    MULTIPLE_STATEMENTS?: string | boolean | undefined;
 }>;
 export default _default;

package/dist/lib/connection/options.js

@@ -24,20 +24,25 @@ const env = {
     USERNAME: process.env.DB_USERNAME || process.env.TSPACE_USERNAME,
     PASSWORD: process.env.DB_PASSWORD || process.env.TSPACE_PASSWORD || '',
     DATABASE: process.env.DB_DATABASE || process.env.TSPACE_DATABASE,
-    CONNECTION_LIMIT: process.env.DB_CONNECTION_LIMIT || process.env.TSPACE_CONNECTION_LIMIT || 10,
+    CONNECTION_LIMIT: process.env.DB_CONNECTION_LIMIT || process.env.TSPACE_CONNECTION_LIMIT || 30,
     QUEUE_LIMIT: process.env.DB_QUEUE_LIMIT || process.env.TSPACE_QUEUE_LIMIT || 0,
     TIMEOUT: process.env.DB_TIMEOUT || process.env.TSPACE_TIMEOUT || 1000 * 60,
     CHARSET: process.env.DB_CHARSET || process.env.TSPACE_CHARSET || 'utf8mb4',
     CONNECTION_ERROR: process.env.DB_CONNECTION_ERROR || process.env.TSPACE_CONNECTION_ERROR || true,
     WAIT_FOR_CONNECTIONS: process.env.DB_WAIT_FOR_CONNECTIONS || process.env.TSPACE_WAIT_FOR_CONNECTIONS || true,
-    DATE_STRINGS: process.env.DB_DATE_STRINGS || process.env.TSPACE_DATE_STRINGS || true
+    DATE_STRINGS: process.env.DB_DATE_STRINGS || process.env.TSPACE_DATE_STRINGS || true,
+    KEEP_ALIVE_DELAY: process.env.DB_KEEP_ALIVE_DELAY || process.env.TSPACE_KEEP_ALIVE_DELAY || 0,
+    ENABLE_KEEP_ALIVE: process.env.DB_ENABLE_KEEP_ALIVE || process.env.TSPACE_ENABLE_KEEP_ALIVE || false,
+    MULTIPLE_STATEMENTS: process.env.MULTIPLE_STATEMENTS || process.env.TSPACE_MULTIPLE_STATEMENTS || false
 };
 for (const [key, value] of Object.entries(env)) {
     if (value == null)
         continue;
     if (typeof value === 'string' && ['true', 'false'].some(v => value.toLowerCase() === v)) {
-        const configEnv = env;
-        configEnv[key] = JSON.parse(value.toLowerCase());
+        env[key] = JSON.parse(value.toLowerCase());
+        continue;
     }
+    if (/^[0-9]+$/.test(value))
+        env[key] = +value;
 }
 exports.default = Object.freeze(Object.assign({}, env));

package/dist/lib/constants/index.js

@@ -76,6 +76,9 @@ const CONSTANTS = Object.freeze({
         snake_case: 'snake_case',
         camelCase: 'camelCase'
     },
+    DEFAULT: {
+        DEBUG: false,
+    },
     DB: {
         PRIMARY_KEY: 'id',
         VOID: false,
@@ -156,7 +159,9 @@ const CONSTANTS = Object.freeze({
             UPDATED_AT: 'updated_at'
         },
         SCHEMA: null,
-        FUNCTION_RELATION: false
+        FUNCTION_RELATION: false,
+        CREATE_TABLE: null,
+        QUERIES: 0
     }
 });
 exports.CONSTANTS = CONSTANTS;

package/dist/lib/tspace/AbstractBuilder.d.ts

@@ -1,16 +1,12 @@
 import { Pagination } from './Interface';
+import { StateHandler } from './StateHandler';
 declare abstract class AbstractBuilder {
     protected $setters: string[];
     protected $utils: {
         [key: string]: Function;
     };
     protected $constants: Function;
-    protected $state: {
-        original: Function;
-        get: Function;
-        set: Function;
-        clone: Function;
-    };
+    protected $state: StateHandler;
     protected $pool: {
         query: Function;
         set: Function;
@@ -19,6 +15,7 @@ declare abstract class AbstractBuilder {
     protected $logger: {
         get: Function;
         set: (value: string) => void;
+        reset: () => void;
         check: (value: string) => boolean;
     };
     protected $attributes: {

package/dist/lib/tspace/AbstractBuilder.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractBuilder = void 0;
+const StateHandler_1 = require("./StateHandler");
 class AbstractBuilder {
     constructor() {
         this.$setters = [
@@ -13,12 +14,7 @@ class AbstractBuilder {
         ];
         this.$utils = {};
         this.$constants = (name) => { };
-        this.$state = {
-            original: () => { },
-            get: (key) => { },
-            set: (key, value) => { },
-            clone: (data) => { }
-        };
+        this.$state = new StateHandler_1.StateHandler({});
         this.$pool = {
             query: (sql) => { },
             set: (pool) => { },
@@ -27,6 +23,7 @@ class AbstractBuilder {
         this.$logger = {
             get: () => { },
             set: (value) => { },
+            reset: () => { },
             check: (value) => true || false
         };
         this.$attributes = null;

package/dist/lib/tspace/AbstractModel.d.ts

@@ -11,6 +11,8 @@ declare abstract class AbstractModel extends Builder {
     protected abstract useTimestamp(): this;
     protected abstract useSoftDelete(): this;
     protected abstract usePattern(pattern: string): this;
+    protected abstract useLoadRelationsInRegistry(): this;
+    protected abstract useBuiltInRelationFunctions(): this;
     protected abstract define(): void;
     protected abstract hasOne({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;
     protected abstract hasMany({ name, model, localKey, foreignKey, freezeTable, as }: Relation): this;