tspace-mysql 1.4.6 → 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)
@@ -101,15 +103,24 @@ import { DB } from 'tspace-mysql'
     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
@@ -137,10 +148,10 @@ 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()
+const whereEqual = await new DB('users').where('id',1).findOne()
 // SELECT * FROM `users` WHERE `users`.`id` = '1' LIMIT 1;
 
-const users = await new DB('users').where('id','!=',1).findMany()
+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()
@@ -165,8 +176,14 @@ const whereQuery = await new DB('users').whereQuery(query => query.where('id',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', { targetKey : 'id', value : '1234' }).findOne()
+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
@@ -239,9 +256,10 @@ Running A Update Query
 const user = await new DB('users')
 .where('id',1)
 .update({
-        name : 'tspace1**',
-        email : 'tspace1@gmail.com'
-}).save()
+    name : 'tspace1**',
+    email : 'tspace1@gmail.com'
+})
+.save()
 // user =>  { id : 1 , username : 'tspace1**', email : 'tspace1@gmail.com'} 
 
 +--------------------------------------------------------------------------+
@@ -420,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({
@@ -430,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
@@ -440,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
+     *   })
      */
 
 
@@ -686,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
 +-------------+--------------+----------------------------+--------------------+
@@ -823,10 +860,59 @@ for (const post of posts) {
 }
 
 ```
+## 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 models. 
+```
+
+## 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
@@ -840,43 +926,44 @@ Let's examine a basic model sync class:
 *   - 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()
-*           })
-*       }
-*   }
-*  
 */
+
+// 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 })
 
 ```
@@ -903,6 +990,8 @@ 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)
@@ -926,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 })
@@ -971,8 +1062,8 @@ findMany()
 findOne()
 find(id)
 delelte()
-exists ()
-onlyTrashed()
+delelteMany()
+exists()
 toString()
 toJSON()
 toArray(column)
@@ -982,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
@@ -1152,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

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

@@ -29,6 +29,6 @@ export declare class PoolConnection {
  * @property {Function} Connection.connection
  */
 declare const pool: Connection;
-export { pool as Pool };
 export { loadOptionsEnvironment };
+export { pool as Pool };
 export default pool;

package/dist/lib/connection/index.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadOptionsEnvironment = exports.Pool = exports.PoolConnection = void 0;
+exports.Pool = exports.loadOptionsEnvironment = exports.PoolConnection = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const options_1 = __importStar(require("./options"));

package/dist/lib/constants/index.js

@@ -5,9 +5,9 @@ const CONSTANTS = Object.freeze({
     ID: 'ID',
     SHOW: 'SHOW',
     BINARY: 'BINARY',
-    SHOW_TABLES: 'SHOW TABLES',
     FIELDS: 'FIELDS',
     COLUMNS: 'COLUMNS',
+    TABLES: 'TABLES',
     WHERE: 'WHERE',
     BETWEEN: 'BETWEEN',
     NOT_BETWEEN: 'NOT BETWEEN',
@@ -18,7 +18,6 @@ const CONSTANTS = Object.freeze({
     OR: 'OR',
     LIKE: 'LIKE',
     SELECT: 'SELECT',
-    SELECTED: '*',
     DISTINCT: 'DISTINCT',
     FROM: 'FROM',
     OFFSET: 'OFFSET',
@@ -71,6 +70,7 @@ const CONSTANTS = Object.freeze({
     ALTER_TABLE: 'ALTER TABLE',
     ADD: 'ADD',
     AFTER: 'AFTER',
+    JSON_OBJECT: 'JSON_OBJECT',
     RELATIONSHIP: {
         hasOne: 'hasOne',
         hasMany: 'hasMany',
@@ -94,13 +94,13 @@ const CONSTANTS = Object.freeze({
         DELETE: '',
         UPDATE: '',
         INSERT: '',
-        SELECT: '',
+        SELECT: [],
         ONLY: [],
         EXCEPTS: [],
         CHUNK: 0,
         COUNT: '',
-        FROM: '',
-        JOIN: '',
+        FROM: 'FROM',
+        JOIN: [],
         WHERE: '',
         GROUP_BY: '',
         ORDER_BY: '',
@@ -119,7 +119,7 @@ const CONSTANTS = Object.freeze({
     MODEL: {
         PRIMARY_KEY: 'id',
         VOID: false,
-        SELECT: '',
+        SELECT: [],
         DELETE: '',
         UPDATE: '',
         INSERT: '',
@@ -127,8 +127,8 @@ const CONSTANTS = Object.freeze({
         EXCEPTS: [],
         CHUNK: 0,
         COUNT: '',
-        FROM: '',
-        JOIN: '',
+        FROM: 'FROM',
+        JOIN: [],
         WHERE: '',
         GROUP_BY: '',
         ORDER_BY: '',
@@ -143,7 +143,6 @@ const CONSTANTS = Object.freeze({
         SOFT_DELETE: false,
         SOFT_DELETE_FORMAT: 'deleted_at',
         SOFT_DELETE_RELATIONS: false,
-        RELATION: [],
         PAGE: 1,
         PER_PAGE: 1,
         REGISTRY: {},
@@ -153,6 +152,7 @@ const CONSTANTS = Object.freeze({
         PLUCK: '',
         SAVE: '',
         HOOKS: [],
+        RELATION: [],
         RELATIONS: [],
         RELATIONS_TRASHED: false,
         RELATIONS_EXISTS: false,
@@ -166,7 +166,9 @@ const CONSTANTS = Object.freeze({
         VALIDATE_SCHEMA_DEFINED: null,
         FUNCTION_RELATION: false,
         SCHEMA_TABLE: null,
-        RETRY_QUERIES: 0
+        RETRY: 0,
+        OBSERVER: null,
+        DATA: null
     }
 });
 exports.CONSTANTS = CONSTANTS;

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

@@ -35,8 +35,8 @@ declare abstract class AbstractBuilder {
     abstract whereUser(id: number): this;
     abstract whereEmail(value: string): this;
     abstract whereQuery(callback: Function): this;
-    abstract whereJSON(column: string, { targetKey, value, operator }: {
-        targetKey: string;
+    abstract whereJSON(column: string, { key, value, operator }: {
+        key: string;
         value: string;
         operator: string;
     }): this;
@@ -70,6 +70,7 @@ declare abstract class AbstractBuilder {
     abstract insert(data: Record<string, any>): this;
     abstract create(data: Record<string, any>): this;
     abstract update(data: Record<string, any>, updateNotExists?: string[]): this;
+    abstract updateMany(data: Record<string, any>, updateNotExists?: string[]): this;
     abstract insertNotExists(data: Record<string, any>): this;
     abstract createNotExists(data: Record<string, any>): this;
     abstract insertOrUpdate(data: Record<string, any>): this;
@@ -111,6 +112,7 @@ declare abstract class AbstractBuilder {
     abstract min(column: string): Promise<number>;
     abstract rawQuery(sql: string): Promise<any[]>;
     abstract delete(): Promise<boolean>;
+    abstract deleteMany(): Promise<boolean>;
     abstract exists(): Promise<boolean>;
     abstract save(): Promise<Record<string, any> | any[] | null | undefined>;
     abstract increment(column: string, value: number): Promise<number>;

package/dist/lib/tspace/Abstract/AbstractBuilder.js

@@ -11,10 +11,14 @@ class AbstractBuilder {
             '$constants',
             '$pool',
             '$state',
+            '$relation'
         ];
         this.$utils = {};
         this.$constants = (name) => { };
-        this.$state = new StateHandler_1.StateHandler({});
+        this.$state = new StateHandler_1.StateHandler({
+            state: {},
+            constants: {}
+        });
         this.$pool = {
             query: (sql) => { },
             set: (pool) => { },

package/dist/lib/tspace/Abstract/AbstractDB.d.ts

@@ -3,8 +3,6 @@ import { Connection, ConnectionOptions } from '../Interface';
 declare abstract class AbstractDB extends Builder {
     abstract table(name: string): void;
     abstract beginTransaction(): Promise<any>;
-    abstract makeObject(value: any): Record<string, any> | null;
-    abstract makeArray(value: any): Array<any>;
     abstract generateUUID(): string;
     abstract raw(sql: string): string;
     abstract constants(constants?: string): string | Record<string, any>;

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

@@ -1,6 +1,8 @@
 import { Relation, RelationQuery } from '../Interface';
-import Builder from '../Builder';
+import { Builder } from '../Builder';
+import { RelationHandler } from '../RelationHandler';
 declare abstract class AbstractModel extends Builder {
+    protected $relation: RelationHandler | undefined;
     protected abstract useUUID(): this;
     protected abstract usePrimaryKey(primaryKey: string): this;
     protected abstract useRegistry(): this;
@@ -23,12 +25,12 @@ declare abstract class AbstractModel extends Builder {
     protected abstract hasOneBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
     protected abstract hasManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
     protected abstract belongsToBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
-    protected abstract belongsToManyBuilder({ name, model, localKey, foreignKey, freezeTable, as }: RelationQuery, callback: Function): this;
+    protected abstract belongsToManyBuilder({ name, model, localKey, foreignKey, freezeTable, as, pivot }: RelationQuery, callback: Function): this;
     abstract ignoreSoftDelete(): this;
     abstract disableSoftDelete(): this;
     abstract registry(func: Record<string, Function>): this;
-    abstract onlyTrashed(): Promise<any[]>;
-    abstract trashed(): Promise<any[]>;
+    abstract onlyTrashed(): this;
+    abstract trashed(): this;
     abstract restore(): Promise<any[]>;
     abstract with(...nameRelations: string[]): this;
     abstract withQuery(nameRelations: string, callback: Function): this;

package/dist/lib/tspace/Abstract/AbstractModel.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractModel = void 0;
-const Builder_1 = __importDefault(require("../Builder"));
-class AbstractModel extends Builder_1.default {
+const Builder_1 = require("../Builder");
+class AbstractModel extends Builder_1.Builder {
 }
 exports.AbstractModel = AbstractModel;
 exports.default = AbstractModel;

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

@@ -1,3 +1,4 @@
+import { Model } from "./Model";
 /**
  * Make schema for table with Blueprint
  * @example
@@ -15,13 +16,14 @@
  */
 declare class Blueprint {
     protected type: string;
-    protected attributes: Array<string>;
+    protected attributes: string[];
+    protected foreignKey: Record<string, any> | null;
     protected valueType: NumberConstructor | StringConstructor | DateConstructor;
     /**
      * Assign type 'int' in table
      * @return {this} this
      */
-    int(number?: number): this;
+    int(_?: number): this;
     /**
      * Assign type 'TINYINT' in table
      * @param {number} number
@@ -192,6 +194,12 @@ declare class Blueprint {
      * @return {this} this
      */
     autoincrement(): this;
+    foreign({ references, on, onDelete, onUpdate }: {
+        references?: string;
+        on: (new () => Model) | string;
+        onDelete?: 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET NULL';
+        onUpdate?: 'CASCADE' | 'NO ACTION' | 'RESTRICT' | 'SET NULL';
+    }): this;
     private _addAssignType;
     private _addAssignAttribute;
 }

package/dist/lib/tspace/Blueprint.js

@@ -20,13 +20,14 @@ class Blueprint {
     constructor() {
         this.type = 'INT';
         this.attributes = [];
+        this.foreignKey = null;
         this.valueType = String;
     }
     /**
      * Assign type 'int' in table
      * @return {this} this
      */
-    int(number) {
+    int(_) {
         this._addAssignType('INT');
         this.valueType = Number;
         return this;
@@ -314,6 +315,15 @@ class Blueprint {
         this._addAssignAttribute(`AUTO_INCREMENT`);
         return this;
     }
+    foreign({ references, on, onDelete, onUpdate }) {
+        this.foreignKey = {
+            references: references == null ? 'id' : references,
+            on: typeof on === 'string' ? on : new on(),
+            onDelete: onDelete == null ? 'CASCADE' : onDelete,
+            onUpdate: onUpdate == null ? 'CASCADE' : onUpdate
+        };
+        return this;
+    }
     _addAssignType(type) {
         this.type = type;
         return this;