tspace-mysql 1.4.5 → 1.4.7

package/README.md

@@ -21,15 +21,17 @@ npm install tspace-mysql --save
 - [Backup](#backup)
 - [Generating Model Classes](#generating-model-classes)
 - [Model Conventions](#model-conventions)
-- [Relationships](#relationships)
-  - [One To One](#one-to-one)
-  - [One To Many](#one-to-many)
-  - [Belongs To](#belongs-to)
-  - [Many To Many](#many-to-many)
-  - [Deeply Nested Relations](#deeply-nested-relations)
-  - [Relation Exists](#relation-exists)
-  - [Built in Relation Functions](#built-in-relation-functions)
-- [Schema Sync](#schema-sync)
+  - [Relationships](#relationships)
+    - [One To One](#one-to-one)
+    - [One To Many](#one-to-many)
+    - [Belongs To](#belongs-to)
+    - [Many To Many](#many-to-many)
+    - [Deeply Nested Relations](#deeply-nested-relations)
+    - [Relation Exists](#relation-exists)
+    - [Built in Relation Functions](#built-in-relation-functions)
+  - [Schema Model](#schema-model)
+    - [Validation](#validation)
+    - [Sync](#sync)
 - [Query Builder](#query-builder)
 - [Cli](#cli)
   - [Make Model](#make-model)
@@ -52,7 +54,6 @@ DB_DATABASE = database
 /** 
  * @default
  *  DB_CONNECTION_LIMIT = 10
- *  DB_CONNECTION_ERROR = true
  *  DB_QUEUE_LIMIT      = 0
  *  DB_TIMEOUT          = 60000
  *  DB_DATE_STRINGS     = true
@@ -99,18 +100,27 @@ Once you have configured your database connection, you may run queries is this :
 
 import { DB } from 'tspace-mysql'
 (async () => {
-    await new DB('users').findMany() // SELECT * FROM users => Array
-    await new DB('users').findOne() //  SELECT * FROM users LIMIT 1 => Object
+    await new DB('users').findMany() //  SELECT * FROM users => Array
+    await new DB('users').findOne()  //  SELECT * FROM users LIMIT 1 => Object
 })()
+
+```
+Running A Raw Query
+```js
+const rawQuery = await new DB().query('SELECT * FROM users') 
+
 ```
 Running A Select Query
 ```js
-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'}]
+const select = await new DB('users').select('id','username').findOne() 
+
+const selectRaw = await new DB('users').selectRaw('COUNT(id)').findMany()
 
-const selectQueryRaw = await new DB('users').selectRaw('COUNT(id)').findMany() 
+const selectObject = await new DB('posts')
+.join('posts.user_id', 'users.id')
+.select('posts.*')
+.selectObject({ id : 'users.id', name : 'users.name' , email : 'users.email'},'user')
+.findOne()
 
 /**
  * @example except
@@ -138,119 +148,147 @@ await new DB('posts').rightJoin('posts.user_id' , 'users.id').findMany()
 
 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 whereEqual = await new DB('users').where('id',1).findOne()
+// SELECT * FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
+
+const whereNotEqual = await new DB('users').where('id','!=',1).findMany()
+// SELECT * FROM `users` WHERE `users`.`id` != '1';
 
 const whereIn = await new DB('users').whereIn('id',[1,2]).findMany()
+// SELECT * FROM `users` WHERE `users`.`id` BETWEEN '1' AND '2';
+
 const whereBetween = await new DB('users').whereBetween('id',[1,2]).findMany()
-const whereSubQuery = await new DB('users').whereSubQuery('id','select id from users').findMany()
-// same As await new DB('users').whereSubQuery('id',new DB('users').select('id').toString()).findMany()
+// SELECT * FROM `users` WHERE `users`.`id` BETWEEN '1' AND '2';
+
+const whereSubQuery = await new DB('users').whereSubQuery('id','SELECT id FROM users').findMany()
+// SELECT * FROM `users` WHERE `users`.`id` IN (SELECT id FROM users);
+// or use -> await new DB('users').whereSubQuery('id',new DB('users').select('id').toString()).findMany()
+
 const whereNull = await new DB('users').whereNull('username').findOne()
+// SELECT * FROM `users` WHERE `users`.`username` IS NULL LIMIT 1;
+
 const whereNotNull = await new DB('users').whereNotNull('username').findOne()
-const whereQuery = await new DB('users').whereQuery(query => query.where('id',1).where('username','tspace')).whereIn('id',[1,2]).findOne()
-    // SELECT * FROM `users` WHERE ( `users`.`id` = '1' AND `users`.`username` = 'tspace') AND `users`.`id` IN ('1','2'') LIMIT 1
-const whereJson= await  new DB('users').whereJson({column : 'json',targetKey : 'id', value : '1234' }).findOne()
+// SELECT * FROM `users` WHERE `users`.`username` IS NOT NULL LIMIT 1;
+
+const whereQuery = await new DB('users').whereQuery(query => query.where('id',1).where('username','values')).whereIn('id',[1,2]).findOne()
+// SELECT * FROM `users` WHERE ( `users`.`id` = '1' AND `users`.`username` = 'values') AND `users`.`id` IN ('1','2'') LIMIT 1;
+
+const whereExists = await new DB('users').whereExists(new DB('users').select('id').where('id',1).toString()).findOne()
+// SELECT * FROM `users` WHERE EXISTS (SELECT `id` FROM `users` WHERE id = 1) LIMIT 1;
+
+const whereJSON = await  new DB('users').whereJSON('json', { key : 'id', value : '1234' }).findOne()
+// SELECT * FROM `users` WHERE `users`.`json`->>'$.id' = '1234' LIMIT 1;
+
+const whereWhenIsTrue = await new DB('users').where('id',1).when(true, (query) => query.where('username','when is actived')).findOne()
+// SELECT * FROM `users` WHERE `users`.`id` = '1' AND `users`.`username` = 'when is actived' LIMIT 1;
+
+const whereWhenIsFalse = await new DB('users').where('id',1).when(false, (query) => query.where('username','when is actived')).findOne()
+// SELECT * FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
 ```
 
 Running A Hook Query
 ```js
-const hookResult = (result) => console.log(result)
+const hookResult = (result) => console.log('hook!! result => ',result)
 const user = await new DB('users').where('id',1).hook(hookResult).findOne()
 ```
 
 Running A Insert Query
 ```js
 const user = await new DB('users')
-    .create({
-        name : 'tspace3',
-        email : 'tspace3@gmail.com'
-    }).save()
-    // user =>  { id : 3 , username : 'tspace3', email : 'tspace3@gmail.com'}
+.create({
+    name : 'tspace3',
+    email : 'tspace3@gmail.com'
+})
+.save()
+// user =>  { id : 3 , username : 'tspace3', email : 'tspace3@gmail.com'}
 
 +--------------------------------------------------------------------------+
 
 const reposity = new DB('users')
-    reposity.name = 'tspace4'
-    reposity.email = 'tspace4@gmail.com'
-    await reposity.save()
-const { result } = reposity
-    // result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
+reposity.name = 'tspace4'
+reposity.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()
+await reposity.save()
+
+const { result } = reposity
+// result =>  { id : 4 , username : 'tspace4', email : 'tspace4@gmail.com'}
 
 const users = await new DB('users')
-    .where('name','tspace4')
-    .where('email','tspace4@gmail.com')
-    .createNotExists({
+.createMultiple([
+    {
         name :'tspace4',
         email : 'tspace4@gmail.com'
-    })
-    .save()
-    // if has exists return null, if not exists created new data
+    },
+    {
+        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')
-    .createOrSelect({
-        name :'tspace4',
-        email : 'tspace4@gmail.com'
-    })
-    .save()
-    // if has exists return data, if not exists created new data
+.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
+
+const users = await new DB('users')
+.where('name','tspace4')
+.where('email','tspace4@gmail.com')
+.createOrSelect({
+    name :'tspace4',
+    email : 'tspace4@gmail.com'
+})
+.save()
+// if has exists return data, if not exists created new data
 
 ```
 Running A Update Query
 ```js
 const user = await new DB('users')
-    .where('id',1)
-    .update({
-          name : 'tspace1**',
-          email : 'tspace1@gmail.com'
-    }).save()
-    // user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
+.where('id',1)
+.update({
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
+})
+.save()
+// user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
 
 +--------------------------------------------------------------------------+
 
 const reposity = new DB('users').where('id',1)
-    reposity.name = 'tspace1++'
-    reposity.email = 'tspace1++@gmail.com'
-    await reposity.save()
+reposity.name = 'tspace1++'
+reposity.email = 'tspace1++@gmail.com'
+
+await reposity.save()
+
 const { result } = reposity
-    // result =>  { id : 1 , username : 'tspace1++', email : 'tspace1++@gmail.com'} 
-```
+// 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' } 
+.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()
-    // deleted => Boolean
+// deleted => Boolean
 ``` 
 ## Database Transactions 
 
@@ -313,7 +351,6 @@ try {
 }
 
 ```
-
 ## Connection
 When establishing a connection, you may establish options is this:
 ```js
@@ -326,8 +363,8 @@ const connection = await new DB().getConnection({
 })
 
 const users = await new DB('users')
-    .bind(connection)
-    .findMany()
+.bind(connection)
+.findMany()
 // users => [{ .... }]
 ```
 
@@ -355,15 +392,15 @@ const backup = await new DB().backup({
  * @param {object | null} conection defalut current connection
  */
 const backupToFile = await new DB().backupToFile({
-     database: 'try-to-backup',
-     filePath: 'backup.sql',
-     connection ?: {
+    database: 'try-to-backup',
+    filePath: 'backup.sql',
+    connection ?: {
         host: 'localhost',
         port : 3306,
         database: 'database'
         username: 'username',
         password: 'password',
-  }
+    }
 })
 // backupToFile => backup.sql
 ```
@@ -401,7 +438,7 @@ class User extends Model {
      * 
      * Assign setting global in your model
      * @useMethod
-     *
+     * this.usePattern('camelCase') // => default 'snake_case' 
      * this.useDebug() 
      * this.usePrimaryKey('id')
      * this.useTimestamp({
@@ -411,8 +448,7 @@ class User extends Model {
      * this.useSoftDelete('deletedAt') // => default target to colmun deleted_at 
      * this.useTable('users')
      * this.useTableSingular() // => 'user'
-     * this.useTablePlural() // => 'users'
-     * this.usePattern('camelCase') // => default 'snake_case'   
+     * this.useTablePlural() // => 'users'  
      * this.useUUID('uuid') // => runing a uuid (universally unique identifier) when insert new data
      * this.useRegistry() // => build-in functions registry
      * this.useLoadRelationsInRegistry() // => auto generated result from relationship to results
@@ -421,14 +457,34 @@ class User extends Model {
      * this.useSchema ({ 
      *     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(),
+     *     name        : new Blueprint().varchar(191).notNull(),
+     *     email       : new Blueprint().varchar(191).notNull(),
      *     created_at  : new Blueprint().timestamp().null(),
      *     updated_at  : new Blueprint().timestamp().null(),
      *     deleted_at  : new Blueprint().timestamp().null()
      *  }) // auto-generated table when table is not exists and auto-create column when column not exists
      * 
-     * this.useValidateSchema() // => validate type of value when return results reference to the schema in 'this.useSchema'
+     *  // validate input when create or update reference to the schema in 'this.useSchema'
+     *  this.useValidateSchema({
+     *   id : Number,
+     *   uuid :  Number,
+     *   name : {
+     *       type : String,
+     *       length : 191
+     *       require : true
+     *   },
+     *   email : {
+     *       type : String,
+     *       require : true,
+     *       length : 191,
+     *       match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+     *       unique : true,
+     *       fn : (email : string) => !/^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+     *   },
+     *   created_at : Date,
+     *   updated_at : Date,
+     *   deleted_at : Date
+     *   })
      */
 
 
@@ -667,7 +723,7 @@ await new User()
 
 ```
 ## Relation Exists
-Relationships can return only result is not empty in relations. 
+Relationships can return only result is not empty in relations (soft delete). 
 let's example a exists in relations :
 ```js
 +-------------+--------------+----------------------------+--------------------+
@@ -758,12 +814,11 @@ await new User().relationsExists('posts').findMany()
  *      ]  
  *  }
  * ]
- * because posts id 1 and id 3 has been removed from database using soft delete
+ * because posts id 1 and id 3 has been removed from database (using soft delete)
  */
 
 
 ```
-
 ## Built in Relation Functions
 Relationships can using built in function in results 
 let's example a built in function :
@@ -799,16 +854,65 @@ class Comment extends Model {
 const user = await new User().findOne()
 const posts = await user.$posts()
 
-/** Warning built in function has Big-O effect */
+/** Warning built-in function has Big-O effect */
 for (const post of posts) {
     const comments = await post.$comments()
 }
 
+```
+## Schema Model
+Define the schema of Model 
+let's example a validator model:
+
+## Validation
+Validate the schema of Model 
+let's example a validator model:
+```js
+
+class User extends Model {
+  constructor(){
+    super()
+    this.useCamelCase()
+    this.useSchema ({ 
+        id          : new Blueprint().int().notNull().primary().autoIncrement(),
+        uuid        : new Blueprint().varchar(50).null(),
+        name        : new Blueprint().varchar(191).notNull(),
+        email       : new Blueprint().varchar(191).notNull(),
+        createdAt   : new Blueprint().timestamp().null(),
+        updatedAt   : new Blueprint().timestamp().null(),
+        deletedAt   : new Blueprint().timestamp().null()
+     })
+     // validate input when create or update reference to the schema in 'this.useSchema'
+     this.useValidateSchema({
+      id : Number,
+      uuid :  Number,
+      name : {
+          type : String,
+          length : 191
+          require : true,
+          json : true
+      },
+      email : {
+          type : String,
+          require : true,
+          length : 191,
+          match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+          unique : true,
+          fn : (email : string) => !/^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+      },
+      createdAt : Date,
+      updatedAt : Date,
+      deletedAt : Date
+    })
+  }
+}
+
 ```
 
-## Schema Sync
-Sync schema to Models in your directory, 
-Sync will check for create or update table or columns with useSchema in your model. 
+## Sync
+Sync schema with Models setting in your directory, 
+Sync will check for create or update table columns and foreign keys, 
+Related by method 'useSchema' in your models. 
 Let's examine a basic model sync class:
 
 ```js
@@ -817,48 +921,50 @@ Let's examine a basic model sync class:
 * @Ex directory
 * 
 * - node_modules
-* - app
+* - src
+*   - index.ts
 *   - Models
 *    - User.ts
 *    - Post.ts
-*
-*  // file User.ts
-*  class User extends Model {
-*      constructor(){
-*          super()
-*          this.hasMany({ name : 'posts' , model : Post })
-*          this.useSchema ({ 
-*               id          : new Blueprint().int().notNull().primary().autoIncrement(),
-*               uuid        : new Blueprint().varchar(50).null(),
-*               email       : new Blueprint().int().notNull().unique(),
-*               name        : new Blueprint().varchar(255).null(),
-*               created_at  : new Blueprint().timestamp().null(),
-*               updated_at  : new Blueprint().timestamp().null(),
-*               deleted_at  : new Blueprint().timestamp().null()
-*           })
-*       }
-*   }
-* 
-*   // file Post.ts
-*   class Post extends Model {
-*      constructor(){
-*          super()
-*          this.hasMany({ name : 'comments' , model : Comment })
-*          this.belongsTo({ name : 'user' , model : User })
-*          this.useSchema ({ 
-*               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()
-*           })
-*       }
-*   }
-*  
 */
-await Schema.sync(`app/Models` , { force : true })
+
+// file User
+class User extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'posts' , model : Post })
+        this.useSchema ({ 
+            id          : new Blueprint().int().notNull().primary().autoIncrement(),
+            uuid        : new Blueprint().varchar(50).null(),
+            email       : new Blueprint().int().notNull().unique(),
+            name        : new Blueprint().varchar(255).null(),
+            created_at  : new Blueprint().timestamp().null(),
+            updated_at  : new Blueprint().timestamp().null(),
+            deleted_at  : new Blueprint().timestamp().null()
+        })
+    }
+}
+ 
+// file Post
+import User from './User'
+class Post extends Model {
+    constructor(){
+        super()
+        this.hasMany({ name : 'comments' , model : Comment })
+        this.belongsTo({ name : 'user' , model : User })
+        this.useSchema ({ 
+            id          : new Blueprint().int().notNull().primary().autoIncrement(),
+            uuid        : new Blueprint().varchar(50).null(),
+            user_id     : new Blueprint().int().notNull()
+            .foreign({ references : 'id' , on : User ,onDelete : 'CASCADE' , onUpdate : 'CASCADE' }),
+            title       : new Blueprint().varchar(255).null(),
+            created_at  : new Blueprint().timestamp().null(),
+            updated_at  : new Blueprint().timestamp().null(),
+            deleted_at  : new Blueprint().timestamp().null()
+        })
+    }
+}
+await Schema.sync(`src/Models` , { force : true })
 
 ```
 ## Query Builder
@@ -875,6 +981,7 @@ whereNull(column)
 whereNotNull(column)
 whereBetween (column , [value1 , value2])
 whereQuery(callback)
+whereJson(column, { targetKey, value , operator })
 whereRaw(sql)
 whereExists(sql)
 whereSubQuery(colmn , rawSQL)
@@ -883,7 +990,10 @@ orWhere(column , operator , value)
 orWhereRaw(sql)
 orWhereIn(column , [])
 orWhereSubQuery(colmn , rawSQL)
+when(contition , callback)
+if(contition , callback)
 select(column1 ,column2 ,...N)
+distinct()
 selectRaw(column1 ,column2 ,...N)
 except(column1 ,column2 ,...N)
 only(column1 ,column2 ,...N)
@@ -905,8 +1015,10 @@ groupByRaw (column)
 create(objects)
 createMultiple(array objects)
 update (objects)
+updateMany (objects)
 createNotExists(objects)
 updateOrCreate (objects)
+onlyTrashed()
 connection(options)
 backup({ database , connection })
 backupToFile({ filePath, database , connection })
@@ -950,9 +1062,8 @@ findMany()
 findOne()
 find(id)
 delelte()
-exists ()
-onlyTrashed()
-toSQL()
+delelteMany()
+exists()
 toString()
 toJSON()
 toArray(column)
@@ -962,7 +1073,7 @@ avg(column)
 max(column)
 min(column)
 pagination({ limit , page })
-save() /*for action statements insert update or delete */
+save() /* for actions statements insert or update */
 ```
 
 ## Cli
@@ -1068,9 +1179,9 @@ tspace-mysql dump:table "table" --values // backup with values in the table
 # Generate Models
 Command will be generate models from table in database
 ```js
-tspace-mysql generate:models --dir=<folder for creating>
+tspace-mysql generate:models --dir=<folder for creating> 
 or 
-tspace-mysql gen:models --dir=<folder for creating>
+tspace-mysql gen:models --dir=<folder for creating> --env=development
 
 ```
 
@@ -1079,13 +1190,14 @@ Schema table created by command make:migration,  you may use the:
 ```js
 import { Schema , Blueprint , DB } from 'tspace-mysql'
 (async () => {
-    await new Schema().table('users',{ 
-        id           :  new Blueprint().int().notNull().primary().autoIncrement(),
+    await new Schema().table('users', { 
+        id           : new Blueprint().int().notNull().primary().autoIncrement(),
         uuid         : new Blueprint().varchar(120).null()
         name         : new Blueprint().varchar(120).default('name'),
         email        : new Blueprint().varchar(255).unique().notNull(),
         email_verify : new Blueprint().tinyInt(),
         password     : new Blueprint().varchar(255),
+        json         : new Blueprint().json(),
         created_at   : new Blueprint().null().timestamp(),
         updated_at   : new Blueprint().null().timestamp()
     })
@@ -1097,15 +1209,16 @@ import { Schema , Blueprint , DB } from 'tspace-mysql'
 })()
 
 /**
- * type of schema in database
+ * add Type of schema in database
  * @Types
  * 
 */
-int ()
+int (number)
 tinyInt (number) 
 bigInt (number)
 double ()
 float ()
+json ()
 varchar (number)
 char (number)
 longText()
@@ -1118,7 +1231,7 @@ dateTime()
 timestamp ()
 
 /**
- * attrbuites of schema in database
+ * add Attrbuites of schema in database
  * @Attrbuites
  * 
 */
@@ -1130,4 +1243,5 @@ primary()
 default(string) 
 defaultTimestamp() 
 autoIncrement() 
+foreign({ references : <column> , on : <table or model>}),
 ```

package/dist/cli/generate/model.js

@@ -14,7 +14,7 @@ class ${model} extends Model {
      *    createdAt : 'created_at',
      *    updatedAt : 'updated_at'
      * }) // runing a timestamp when insert or update
-     * this.useSoftDelete('deletedAt') // => default target to colmun deleted_at 
+     * this.useSoftDelete('deletedAt') // => default target to column deleted_at 
      * this.usePattern('snake_case') // => default 'snake_case'   
      * this.useUUID('uuid') // => runing a uuid (universally unique identifier) when insert new data
      * this.useRegistry() // => build-in functions registry