tspace-mysql 1.4.7 → 1.4.9

package/dist/lib/tspace/Model.js

@@ -16,10 +16,10 @@ exports.Model = void 0;
 const pluralize_1 = __importDefault(require("pluralize"));
 const DB_1 = require("./DB");
 const Schema_1 = require("./Schema");
-const AbstractModel_1 = require("./Abstract/AbstractModel");
-const ProxyHandler_1 = require("./ProxyHandler");
-const StateHandler_1 = require("./StateHandler");
-const RelationHandler_1 = require("./RelationHandler");
+const AbstractModel_1 = require("./Abstracts/AbstractModel");
+const Proxy_1 = require("./Handlers/Proxy");
+const State_1 = require("./Handlers/State");
+const Relation_1 = require("./Handlers/Relation");
 /**
  *
  * 'Model' class is a representation of a database table
@@ -41,7 +41,7 @@ class Model extends AbstractModel_1.AbstractModel {
          */
         this.define();
         this.boot();
-        return new Proxy(this, ProxyHandler_1.proxyHandler);
+        return new Proxy(this, Proxy_1.proxyHandler);
     }
     /**
      * The 'define' method is a special method that you can define within a model.
@@ -145,7 +145,6 @@ class Model extends AbstractModel_1.AbstractModel {
      *        this.useRegistry()
      *     }
      * }
-     
      */
     useRegistry() {
         this._setState('REGISTRY', Object.assign(Object.assign({}, this._getState('REGISTRY')), { '$attach': this._attach, '$detach': this._detach }));
@@ -247,11 +246,31 @@ class Model extends AbstractModel_1.AbstractModel {
         this._makeTableName();
         return this;
     }
+    /**
+     * The "useCamelCase" method is used to assign pattern camelCase.
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.useCamelCase()
+     *     }
+     * }
+     */
     useCamelCase() {
         this._setState('PATTERN', this.$constants('PATTERN').camelCase);
         this._makeTableName();
         return this;
     }
+    /**
+     * The "SnakeCase" method is used to assign pattern snake_case.
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *     constructor() {
+     *        this.SnakeCase()
+     *     }
+     * }
+     */
     useSnakeCase() {
         this._setState('PATTERN', this.$constants('PATTERN').snake_case);
         this._makeTableName();
@@ -350,7 +369,7 @@ class Model extends AbstractModel_1.AbstractModel {
     useTablePlural() {
         var _a;
         const table = this._classToTableName((_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name);
-        this._setState('TABLE_NAME', `\`${pluralize_1.default.plural(table)}\``);
+        this._setState('TABLE_NAME', `\`${this._valuePattern(table)}\``);
         return this;
     }
     /**
@@ -447,7 +466,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @override
      * @return {promise<string>} string
      */
-    _exceptColumns() {
+    exceptColumns() {
         return __awaiter(this, void 0, void 0, function* () {
             const excepts = this._getState('EXCEPTS');
             const hasDot = excepts.some((except) => /\./.test(except));
@@ -458,9 +477,14 @@ class Model extends AbstractModel_1.AbstractModel {
             }).filter((d) => d != null);
             const tableNames = names.length ? [...new Set(names)] : [this._getState('TABLE_NAME')];
             const removeExcepts = [];
+            const schemaColumns = this.getSchemaModel();
             for (const tableName of tableNames) {
-                if (this._getState('SCHEMA_TABLE') && (tableName === this._getState('TABLE_NAME').replace(/`/g, ''))) {
-                    const columns = Object.keys(this._getState('SCHEMA_TABLE'));
+                const isHasSchema = [
+                    schemaColumns != null,
+                    tableName.replace(/`/g, '') === this._getState('TABLE_NAME').replace(/`/g, '')
+                ].every(d => d);
+                if (isHasSchema) {
+                    const columns = Object.keys(schemaColumns);
                     const removeExcept = columns.filter((column) => {
                         return excepts.every((except) => {
                             if (/\./.test(except)) {
@@ -470,7 +494,7 @@ class Model extends AbstractModel_1.AbstractModel {
                             return except !== column;
                         });
                     });
-                    removeExcepts.push(hasDot ? removeExcept.map(r => `\`${tableName}\`.${r}`) : removeExcept);
+                    removeExcepts.push(hasDot ? removeExcept.map(r => `${tableName}.${r}`) : removeExcept);
                     continue;
                 }
                 const sql = [
@@ -515,6 +539,135 @@ class Model extends AbstractModel_1.AbstractModel {
         relation.query = callback(new relation.model());
         return this;
     }
+    /**
+     *
+     * The 'makeSelectStatement' method is used to make select statement.
+     * @return {Promise<string>} string
+     */
+    makeSelectStatement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaModel = this.getSchemaModel();
+            const makeStatement = (columns) => {
+                return [
+                    `${this.$constants('SELECT')}`,
+                    `${columns.join(', ')}`,
+                    `${this.$constants('FROM')}`,
+                    `\`${this.getTableName()}\``,
+                ].join(' ');
+            };
+            if (schemaModel == null) {
+                const schemaTable = yield this.getSchema();
+                const columns = schemaTable.map(column => `\`${this.getTableName()}\`.\`${column.Field}\``);
+                return makeStatement(columns);
+            }
+            const columns = Object.keys(schemaModel).map((column) => `\`${this.getTableName()}\`.\`${column}\``);
+            return makeStatement(columns);
+        });
+    }
+    /**
+     *
+     * The 'makeInsertStatement' method is used to make insert table statement.
+     * @return {Promise<string>} string
+     */
+    makeInsertStatement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaModel = this.getSchemaModel();
+            const makeStatement = (columns) => {
+                return [
+                    `${this.$constants('INSERT')}`,
+                    `\`${this.getTableName()}\``,
+                    `(${columns.join(', ')})`,
+                    `${this.$constants('VALUES')}`,
+                    `(${Array(columns.length).fill('?').join(' , ')})`
+                ].join(' ');
+            };
+            if (schemaModel == null) {
+                const schemaTable = yield this.getSchema();
+                const columns = schemaTable.map(column => `\`${column.Field}\``);
+                return makeStatement(columns);
+            }
+            const columns = Object.keys(schemaModel).map((column) => `\`${column}\``);
+            return makeStatement(columns);
+        });
+    }
+    /**
+     *
+     * The 'makeUpdateStatement' method is used to make update table statement.
+     * @return {Promise<string>} string
+     */
+    makeUpdateStatement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaModel = this.getSchemaModel();
+            const makeStatement = (columns) => {
+                return [
+                    `${this.$constants('UPDATE')}`,
+                    `\`${this.getTableName()}\``,
+                    `${this.$constants('SET')}`,
+                    `(${columns.join(', ')})`
+                ].join(' ');
+            };
+            if (schemaModel == null) {
+                const schemaTable = yield this.getSchema();
+                const columns = schemaTable.map(column => `\`${column.Field}\` = ?`);
+                return makeStatement(columns);
+            }
+            const columns = Object.keys(schemaModel).map((column) => `\`${column}\` = ?`);
+            return makeStatement(columns);
+        });
+    }
+    /**
+     *
+     * The 'makeDeleteStatement' method is used to make delete statement.
+     * @return {Promise<string>} string
+     */
+    makeDeleteStatement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const makeStatement = () => {
+                return [
+                    `${this.$constants('DELETE')}`,
+                    `${this.$constants('FROM')}`,
+                    `\`${this.getTableName()}\``,
+                    `${this.$constants('WHERE')}`,
+                    `?where_expression`
+                ].join(' ');
+            };
+            return makeStatement();
+        });
+    }
+    /**
+     *
+     * The 'makeCreateStatement' method is used to make create table statement.
+     * @return {Promise<string>} string
+     */
+    makeCreateStatement() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schemaModel = this.getSchemaModel();
+            const makeStatement = (columns) => {
+                return [
+                    `${this.$constants('CREATE_TABLE_NOT_EXISTS')}`,
+                    `\`${this.getTableName()}\``,
+                    `(`,
+                    `\n${columns === null || columns === void 0 ? void 0 : columns.join(',\n')}`,
+                    `\n)`,
+                    `${this.$constants('ENGINE')}`
+                ].join(' ');
+            };
+            if (schemaModel == null) {
+                const columns = yield this.showSchema();
+                return makeStatement(columns);
+            }
+            let columns = [];
+            for (const key in schemaModel) {
+                const data = schemaModel[key];
+                const { type, attributes } = data;
+                columns = [
+                    ...columns,
+                    `${key} ${type} ${attributes === null || attributes === void 0 ? void 0 : attributes.join(' ')}`
+                ];
+            }
+            return makeStatement(columns);
+        });
+    }
     /**
      *
      * Clone instance of model
@@ -547,7 +700,7 @@ class Model extends AbstractModel_1.AbstractModel {
         if ((options === null || options === void 0 ? void 0 : options.delete) == null)
             newInstance.$state.set('DELETE', '');
         if ((options === null || options === void 0 ? void 0 : options.where) == null)
-            newInstance.$state.set('WHERE', '');
+            newInstance.$state.set('WHERE', []);
         if ((options === null || options === void 0 ? void 0 : options.limit) == null)
             newInstance.$state.set('LIMIT', '');
         if ((options === null || options === void 0 ? void 0 : options.offset) == null)
@@ -559,7 +712,7 @@ class Model extends AbstractModel_1.AbstractModel {
         if ((options === null || options === void 0 ? void 0 : options.select) == null)
             newInstance.$state.set('SELECT', []);
         if ((options === null || options === void 0 ? void 0 : options.join) == null)
-            newInstance.$state.set('JOIN', '');
+            newInstance.$state.set('JOIN', []);
         return newInstance;
     }
     /**
@@ -573,11 +726,8 @@ class Model extends AbstractModel_1.AbstractModel {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this._getState('DEBUG')) {
+                if (this._getState('DEBUG'))
                     this.$utils.consoleDebug(sql);
-                    const result = yield this.$pool.query(sql);
-                    return result;
-                }
                 return yield this.$pool.query(sql);
             }
             catch (error) {
@@ -602,15 +752,8 @@ class Model extends AbstractModel_1.AbstractModel {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this._getState('DEBUG')) {
+                if (this._getState('DEBUG'))
                     this.$utils.consoleDebug(sql);
-                    if (returnId) {
-                        const result = yield this.$pool.query(sql);
-                        return [result.affectedRows, result.insertId];
-                    }
-                    const { affectedRows: result } = yield this.$pool.query(sql);
-                    return result;
-                }
                 if (returnId) {
                     const result = yield this.$pool.query(sql);
                     return [result.affectedRows, result.insertId];
@@ -710,6 +853,19 @@ class Model extends AbstractModel_1.AbstractModel {
         this._setState('RELATIONS', (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.apply(nameRelations, 'all'));
         return this;
     }
+    /**
+    * The 'withAll' method is used to eager load related (relations) data when retrieving records from a database.
+    *
+    * Eager loading allows you to retrieve a primary model and its related models in a more efficient
+    * It's method ignore soft delete
+    * @param {...string} nameRelations if data exists return blank
+    * @return {this} this
+    */
+    withCount(...nameRelations) {
+        var _a;
+        this._setState('RELATIONS', (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.apply(nameRelations, 'count'));
+        return this;
+    }
     /**
      * The 'withTrashed' method is used to eager load related (relations) data when retrieving records from a database.
      *
@@ -780,7 +936,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     has(...nameRelations) {
-        return this.relationsExists(...nameRelations);
+        return this.withExists(...nameRelations);
     }
     /**
      *
@@ -832,6 +988,7 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     withQuery(nameRelation, callback) {
         var _a;
+        this.with(nameRelation);
         (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.callback(nameRelation, callback);
         return this;
     }
@@ -860,7 +1017,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relations(...nameRelations) {
-        return this.relations(...nameRelations);
+        return this.with(...nameRelations);
     }
     /**
      *
@@ -887,7 +1044,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationsExists(...nameRelations) {
-        return this.relationsExists(...nameRelations);
+        return this.withExists(...nameRelations);
     }
     /**
      *
@@ -945,7 +1102,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationsAll(...nameRelations) {
-        return this.relationsAll(...nameRelations);
+        return this.withAll(...nameRelations);
     }
     /**
      *
@@ -954,7 +1111,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationsTrashed(...nameRelations) {
-        return this.relationsTrashed(...nameRelations);
+        return this.withTrashed(...nameRelations);
     }
     /**
      * The 'hasOne' relationship defines a one-to-one relationship between two database tables.
@@ -1222,12 +1379,622 @@ class Model extends AbstractModel_1.AbstractModel {
             return yield this.save();
         });
     }
+    /**
+     *
+     * @return {string} string
+     */
     toTableName() {
         return this.getTableName();
     }
+    /**
+     *
+     * @param {string} column
+     * @return {string} string
+     */
     toTableNameAndColumn(column) {
         return `\`${this.getTableName()}\`.\`${this._valuePattern(column)}\``;
     }
+    _columnPattern(column) {
+        if (column.startsWith(this.$constants('RAW'))) {
+            return column.replace(`${this.$constants('RAW')} `, '').replace(this.$constants('RAW'), '');
+        }
+        return this._valuePattern(column);
+    }
+    /**
+     * @override Method
+     * @param {string} column if arguments is object
+     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
+     * @param {any?} value
+     * @return {this} this
+     */
+    where(column, operator, value) {
+        if (typeof column === 'object' && column !== null && !Array.isArray(column)) {
+            return this.whereObject(column);
+        }
+        column = this._columnPattern(String(column));
+        [value, operator] = this._valueAndOperator(value, operator, arguments.length === 2);
+        value = this.$utils.escape(value);
+        value = this._valueTrueFalse(value);
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(String(column))}`,
+                `${operator}`,
+                `${this._checkValueHasRaw(value)}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator ['=', '<', '>' ,'!=', '!<', '!>' ,'LIKE']
+     * @param {any?} value
+     * @return {this}
+     */
+    orWhere(column, operator, value) {
+        [value, operator] = this._valueAndOperator(value, operator, arguments.length === 2);
+        column = this._columnPattern(String(column));
+        value = this.$utils.escape(value);
+        value = this._valueTrueFalse(value);
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(String(column))}`,
+                `${operator}`,
+                `${this._checkValueHasRaw(value)}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {Object} columns
+     * @return {this}
+     */
+    whereObject(columns) {
+        for (let column in columns) {
+            column = this._columnPattern(String(column));
+            const operator = '=';
+            const value = this.$utils.escape(columns[column]);
+            this._setState('WHERE', [
+                ...this._getState('WHERE'),
+                [
+                    this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                    `${this.bindColumn(String(column))}`,
+                    `${operator}`,
+                    `${this._checkValueHasRaw(value)}`
+                ].join(' ')
+            ]);
+        }
+        return this;
+    }
+    /**
+    * @override Method
+    * @param    {string} column
+    * @param    {object}  property object { key , value , operator }
+    * @property {string}  property.key
+    * @property {string}  property.value
+    * @property {string?} property.operator
+    * @return   {this}
+    */
+    whereJSON(column, { key, value, operator }) {
+        value = this.$utils.escape(value);
+        value = this._valueTrueFalse(value);
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}->>'$.${key}'`,
+                `${operator == null ? "=" : operator.toLocaleUpperCase()}`,
+                `${this._checkValueHasRaw(value)}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {number} userId
+     * @param {string?} column custom it *if column is not user_id
+     * @return {this}
+     */
+    whereUser(userId, column = 'user_id') {
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)} = ${this.$utils.escape(userId)}`,
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereIn(column, array) {
+        if (!Array.isArray(array))
+            throw new Error(`This 'whereIn' method is required array only`);
+        column = this._columnPattern(String(column));
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IN')}`,
+                `(${values})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereIn(column, array) {
+        if (!Array.isArray(array))
+            throw new Error(`This 'whereIn' method is required array only`);
+        column = this._columnPattern(String(column));
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IN')}`,
+                `(${values})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereNotIn(column, array) {
+        if (!Array.isArray(array))
+            throw new Error(`This 'whereIn' method is required array only`);
+        column = this._columnPattern(String(column));
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('NOT_IN')}`,
+                `(${values})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotIn(column, array) {
+        if (!Array.isArray(array))
+            throw new Error(`This 'whereIn' method is required array only`);
+        column = this._columnPattern(String(column));
+        const values = array.length
+            ? `${array.map((value) => this._checkValueHasRaw(this.$utils.escape(value))).join(',')}`
+            : this.$constants('NULL');
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('NOT_IN')}`,
+                `(${values})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    whereSubQuery(column, subQuery) {
+        if (!this.$utils.isSubQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid. Sub query is should contain 1 column(s)`);
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IN')}`,
+                `(${subQuery})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    whereNotSubQuery(column, subQuery) {
+        if (!this.$utils.isSubQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid. Sub query is should contain 1 column(s)`);
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('NOT_IN')}`,
+                `(${subQuery})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    orWhereSubQuery(column, subQuery) {
+        if (!this.$utils.isSubQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid. Sub query is should contain 1 column(s)`);
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IN')}`,
+                `(${subQuery})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string} subQuery
+     * @return {this}
+     */
+    orWhereNotSubQuery(column, subQuery) {
+        if (!this.$utils.isSubQuery(subQuery))
+            throw new Error(`This "${subQuery}" is invalid sub query (Sub query Operand should contain 1 column(s) not select * )`);
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('NOT_IN')}`,
+                `(${subQuery})`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereBetween(column, array) {
+        if (!Array.isArray(array))
+            throw new Error("Value is't array");
+        column = this._columnPattern(String(column));
+        if (!array.length) {
+            this._setState('WHERE', [
+                ...this._getState('WHERE'),
+                [
+                    this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                    `${this.bindColumn(column)}`,
+                    `${this.$constants('BETWEEN')}`,
+                    `${this.$constants('NULL')}`,
+                    `${this.$constants('AND')}`,
+                    `${this.$constants('NULL')}`
+                ].join(' ')
+            ]);
+            return this;
+        }
+        const [value1, value2] = array;
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('BETWEEN')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value1))}`,
+                `${this.$constants('AND')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value2))}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereBetween(column, array) {
+        if (!Array.isArray(array))
+            throw new Error("Value is't array");
+        column = this._columnPattern(String(column));
+        if (!array.length) {
+            this._setState('WHERE', [
+                ...this._getState('WHERE'),
+                [
+                    this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                    `${this.bindColumn(column)}`,
+                    `${this.$constants('BETWEEN')}`,
+                    `${this.$constants('NULL')}`,
+                    `${this.$constants('AND')}`,
+                    `${this.$constants('NULL')}`
+                ].join(' ')
+            ]);
+            return this;
+        }
+        const [value1, value2] = array;
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('BETWEEN')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value1))}`,
+                `${this.$constants('AND')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value2))}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    whereNotBetween(column, array) {
+        if (!Array.isArray(array))
+            throw new Error("Value is't array");
+        column = this._columnPattern(String(column));
+        if (!array.length) {
+            this._setState('WHERE', [
+                ...this._getState('WHERE'),
+                [
+                    this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                    `${this.bindColumn(column)}`,
+                    `${this.$constants('NOT_BETWEEN')}`,
+                    `${this.$constants('NULL')}`,
+                    `${this.$constants('AND')}`,
+                    `${this.$constants('NULL')}`
+                ].join(' ')
+            ]);
+            return this;
+        }
+        const [value1, value2] = array;
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('NOT_BETWEEN')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value1))}`,
+                `${this.$constants('AND')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value2))}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {array} array
+     * @return {this}
+     */
+    orWhereNotBetween(column, array) {
+        if (!Array.isArray(array))
+            throw new Error("Value is't array");
+        column = this._columnPattern(String(column));
+        if (!array.length) {
+            this._setState('WHERE', [
+                ...this._getState('WHERE'),
+                [
+                    this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                    `${this.bindColumn(column)}`,
+                    `${this.$constants('NOT_BETWEEN')}`,
+                    `${this.$constants('NULL')}`,
+                    `${this.$constants('AND')}`,
+                    `${this.$constants('NULL')}`
+                ].join(' ')
+            ]);
+            return this;
+        }
+        const [value1, value2] = array;
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('NOT_BETWEEN')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value1))}`,
+                `${this.$constants('AND')}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value2))}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    whereNull(column) {
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IS_NULL')}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    orWhereNull(column) {
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IS_NULL')}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    whereNotNull(column) {
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IS_NOT_NULL')}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @return {this}
+     */
+    orWhereNotNull(column) {
+        column = this._columnPattern(String(column));
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.bindColumn(column)}`,
+                `${this.$constants('IS_NOT_NULL')}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator = < > != !< !>
+     * @param {any?} value
+     * @return {this}
+     */
+    whereSensitive(column, operator, value) {
+        [value, operator] = this._valueAndOperator(value, operator, arguments.length === 2);
+        column = this._columnPattern(String(column));
+        value = this.$utils.escape(value);
+        value = this._valueTrueFalse(value);
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `${this.$constants('BINARY')}`,
+                `${this.bindColumn(column)}`,
+                `${operator}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value))}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator = < > != !< !>
+     * @param {any?} value
+     * @return {this}
+     */
+    whereStrict(column, operator, value) {
+        return this.whereSensitive(column, operator, value);
+    }
+    /**
+     * @override Method
+     * @param {string} column
+     * @param {string?} operator = < > != !< !>
+     * @param {any?} value
+     * @return {this}
+     */
+    orWhereSensitive(column, operator, value) {
+        [value, operator] = this._valueAndOperator(value, operator, arguments.length === 2);
+        column = this._columnPattern(String(column));
+        value = this.$utils.escape(value);
+        value = this._valueTrueFalse(value);
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('OR')}` : '',
+                `${this.$constants('BINARY')}`,
+                `${this.bindColumn(column)}`,
+                `${operator}`,
+                `${this._checkValueHasRaw(this.$utils.escape(value))}`
+            ].join(' ')
+        ]);
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {Function} callback callback query
+     * @return {this}
+     */
+    whereQuery(callback) {
+        const db = new Model().copyModel(this);
+        const repository = callback(db);
+        if (repository instanceof Promise)
+            throw new Error('"whereQuery" is not supported a Promise');
+        if (!(repository instanceof Model))
+            throw new Error(`Unknown callback query: '${repository}'`);
+        const where = (repository === null || repository === void 0 ? void 0 : repository._getState('WHERE')) || [];
+        if (!where.length)
+            return this;
+        const query = where.join(' ');
+        this._setState('WHERE', [
+            ...this._getState('WHERE'),
+            [
+                this._getState('WHERE').length ? `${this.$constants('AND')}` : '',
+                `(${query})`
+            ].join(' ')
+        ]);
+        return this;
+    }
     /**
      * @override Method
      * @return {promise<boolean>} promise boolean
@@ -1235,8 +2002,7 @@ class Model extends AbstractModel_1.AbstractModel {
     delete() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._getState('WHERE'))
-                throw new Error("Can't delete without where condition");
+            this._assertError(!this._getState('where').length, "This method 'delete' is require to use 'where' conditions");
             this.limit(1);
             if (this._getState('SOFT_DELETE')) {
                 const deletedAt = this._valuePattern(this._getState('SOFT_DELETE_FORMAT'));
@@ -1270,14 +2036,13 @@ class Model extends AbstractModel_1.AbstractModel {
     deleteMany() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this._getState('WHERE'))
-                throw new Error("Can't delete without where condition");
+            this._assertError(!this._getState('where').length, "This method 'delete' is require to use 'where' conditions");
             if (this._getState('SOFT_DELETE')) {
                 const deletedAt = this._valuePattern(this._getState('SOFT_DELETE_FORMAT'));
                 const sql = new Model()
                     .copyModel(this, { where: true, limit: true })
                     .bind(this.$pool.get())
-                    .update({
+                    .updateMany({
                     [deletedAt]: this.$utils.timestamp()
                 })
                     .toString();
@@ -1308,7 +2073,7 @@ class Model extends AbstractModel_1.AbstractModel {
             if (this._getState('VOID'))
                 return this._resultHandler(undefined);
             if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this._exceptColumns());
+                this.select(...yield this.exceptColumns());
             this.limit(1);
             if (this._getState('RELATIONS_EXISTS')) {
                 return yield this._execute({
@@ -1340,7 +2105,7 @@ class Model extends AbstractModel_1.AbstractModel {
         return __awaiter(this, void 0, void 0, function* () {
             this._validateMethod('firstOrError');
             if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this._exceptColumns());
+                this.select(...yield this.exceptColumns());
             this.limit(1);
             if (this._getState('RELATIONS_EXISTS')) {
                 return yield this._execute({
@@ -1378,7 +2143,7 @@ class Model extends AbstractModel_1.AbstractModel {
             if (this._getState('VOID'))
                 return [];
             if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this._exceptColumns());
+                this.select(...yield this.exceptColumns());
             let sql = this._queryBuilder().select();
             if (this._getState('RELATIONS_EXISTS'))
                 sql = String((_b = this.$relation) === null || _b === void 0 ? void 0 : _b.loadExists());
@@ -1416,7 +2181,7 @@ class Model extends AbstractModel_1.AbstractModel {
                 page = (paginationOptions === null || paginationOptions === void 0 ? void 0 : paginationOptions.page) || page;
             }
             if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this._exceptColumns());
+                this.select(...yield this.exceptColumns());
             const offset = (page - 1) * limit;
             this._setState('PER_PAGE', limit);
             this._setState('PAGE', page);
@@ -1453,7 +2218,7 @@ class Model extends AbstractModel_1.AbstractModel {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this._exceptColumns());
+                this.select(...yield this.exceptColumns());
             this.selectRaw([
                 `\`${column}\`,`,
                 `${this.$constants('GROUP_CONCAT')}(id)`,
@@ -1721,24 +2486,23 @@ class Model extends AbstractModel_1.AbstractModel {
     insertNotExists(data) {
         return this.createNotExists(data);
     }
+    getSchemaModel() {
+        if (this.$schema == null)
+            return this._getState('SCHEMA_TABLE');
+        return this.$schema;
+    }
+    validation(schema) {
+        this._setState('VALIDATE_SCHEMA', true);
+        this._setState('VALIDATE_SCHEMA_DEFINED', schema);
+        return this;
+    }
     /**
-     *
-     * get schema from table
-     * @return {this} this this
+     * The 'bindPattern' method is used to covert column relate with pattern
+     * @param {string} column
+     * @return {string} return table.column
      */
-    getSchema() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sql = [
-                `${this.$constants('SHOW')}`,
-                `${this.$constants('COLUMNS')}`,
-                `${this.$constants('FROM')}`,
-                `\`${this._getState('TABLE_NAME').replace(/\`/g, '')}\``
-            ].join(' ');
-            return yield this._queryStatement(sql);
-        });
-    }
-    getSchemaModel() {
-        return this._getState('SCHEMA_TABLE');
+    bindPattern(column) {
+        return this._valuePattern(column);
     }
     /**
      * @override Method
@@ -1746,17 +2510,6 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     save() {
         return __awaiter(this, void 0, void 0, function* () {
-            const attributes = this.$attributes;
-            if (attributes != null) {
-                while (true) {
-                    if (this._getState('WHERE')) {
-                        this.update(attributes);
-                        break;
-                    }
-                    this.create(attributes);
-                    break;
-                }
-            }
             this._validateMethod('save');
             switch (String(this._getState('SAVE'))) {
                 case 'INSERT': return yield this._insertModel();
@@ -1775,36 +2528,129 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {number} rows number of rows
      * @return {promise<any>}
      */
-    faker(rows = 1) {
+    faker(rows, callback) {
         return __awaiter(this, void 0, void 0, function* () {
             let data = [];
-            this.void();
             const sql = [
                 `${this.$constants('SHOW')}`,
                 `${this.$constants('FIELDS')}`,
                 `${this.$constants('FROM')}`,
                 `${this._getState('TABLE_NAME')}`
             ].join(' ');
-            const fields = yield this._queryStatement(sql);
+            const schemaModel = this.getSchemaModel();
+            const fields = schemaModel == null
+                ? yield this._queryStatement(sql)
+                : Object.entries(schemaModel).map(([key, value]) => {
+                    return {
+                        Field: key,
+                        Type: value.type
+                    };
+                });
             for (let row = 0; row < rows; row++) {
                 this._assertError(this._getState('TABLE_NAME') === '' || this._getState('TABLE_NAME') == null, "Unknow this table");
                 let columnAndValue = {};
                 for (const { Field: field, Type: type } of fields) {
-                    const passed = ['id', '_id', 'uuid', 'deleted_at', 'deletedAt'].some(p => field.toLowerCase() === p);
+                    const deletedAt = this._valuePattern(this._getState('SOFT_DELETE_FORMAT'));
+                    const passed = ['id', '_id', 'uuid', deletedAt].some(p => field === p);
                     if (passed)
                         continue;
                     columnAndValue = Object.assign(Object.assign({}, columnAndValue), { [field]: this.$utils.faker(type) });
                 }
+                if (callback) {
+                    data = [...data, callback(columnAndValue, row)];
+                    continue;
+                }
                 data = [...data, columnAndValue];
             }
-            const query = this._queryInsertMultipleModel(data);
-            this._setState('INSERT', [
-                `${this.$constants('INSERT')}`,
-                `${this._getState('TABLE_NAME')}`,
-                `${query}`
-            ].join(' '));
-            this._setState('SAVE', 'INSERT_MULTIPLE');
-            return yield this.save();
+            return yield this.createMultiple(data).save();
+        });
+    }
+    /**
+     * The 'Sync' method is used to check for create or update table or columns with your schema in your model.
+     *
+     * @property {boolean} force - forec always check all columns if not exists will be created
+     * @property {boolean} foreign - foreign key for constraint
+     * @return {promise<void>}
+     */
+    sync({ force = false, foreign = false } = {}) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const checkTables = yield this._queryStatement(`SHOW TABLES LIKE '${this.getTableName()}'`);
+            const existsTables = checkTables.map((c) => Object.values(c)[0]);
+            const schemaModel = this.getSchemaModel();
+            if (schemaModel == null)
+                return this._assertError(schemaModel == null, 'Schema model not found');
+            const checkTableIsExists = existsTables.some((table) => table === this.getTableName());
+            const syncForeignKey = ({ schemaModel, model }) => __awaiter(this, void 0, void 0, function* () {
+                var _e;
+                for (const key in schemaModel) {
+                    if (((_e = schemaModel[key]) === null || _e === void 0 ? void 0 : _e.foreignKey) == null)
+                        continue;
+                    const foreign = schemaModel[key].foreignKey;
+                    const table = typeof foreign.on === "string" ? foreign.on : foreign.on.getTableName();
+                    const sql = [
+                        "ALTER TABLE",
+                        `\`${model.getTableName()}\``,
+                        "ADD CONSTRAINT",
+                        `\`${model.getTableName()}(${key})_${table}(${foreign.references})\``,
+                        `FOREIGN KEY(\`${key}\`)`,
+                        `REFERENCES \`${table}\`(\`${foreign.references}\`)`,
+                        `ON DELETE ${foreign.onDelete} ON UPDATE ${foreign.onUpdate}`
+                    ].join(' ');
+                    try {
+                        yield model._queryStatement(sql);
+                    }
+                    catch (e) {
+                        if (typeof foreign.on === "string")
+                            continue;
+                        if (String(e.message).includes("Duplicate foreign key constraint"))
+                            continue;
+                        const schemaModelOn = yield foreign.on.getSchemaModel();
+                        if (!schemaModelOn)
+                            continue;
+                        const tableSql = new Schema_1.Schema().createTable(`\`${table}\``, schemaModelOn);
+                        yield model._queryStatement(tableSql).catch(e => console.log(e));
+                        yield model._queryStatement(sql).catch(e => console.log(e));
+                        continue;
+                    }
+                }
+            });
+            if (!checkTableIsExists) {
+                const sql = new Schema_1.Schema().createTable(`\`${this.getTableName()}\``, schemaModel);
+                yield this._queryStatement(sql);
+                yield syncForeignKey({ schemaModel, model: this });
+            }
+            if (foreign) {
+                yield syncForeignKey({ schemaModel, model: this });
+                return;
+            }
+            if (!force)
+                return;
+            const schemaTable = yield this.getSchema();
+            const schemaTableKeys = schemaTable.map((k) => k.Field);
+            const schemaModelKeys = Object.keys(schemaModel);
+            const missingColumns = schemaModelKeys.filter(schemaModelKey => !schemaTableKeys.includes(schemaModelKey));
+            if (!missingColumns.length)
+                return;
+            const entries = Object.entries(schemaModel);
+            for (const column of missingColumns) {
+                const indexWithColumn = entries.findIndex(([key]) => key === column);
+                const findAfterIndex = indexWithColumn ? entries[indexWithColumn - 1][0] : null;
+                const type = (_b = (_a = schemaModel[column]) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : null;
+                const attributes = (_d = (_c = schemaModel[column]) === null || _c === void 0 ? void 0 : _c.attributes) !== null && _d !== void 0 ? _d : null;
+                if (findAfterIndex == null || type == null || attributes == null)
+                    continue;
+                const sql = [
+                    'ALTER TABLE',
+                    `\`${this.getTableName()}\``,
+                    'ADD',
+                    `\`${column}\` ${type} ${attributes.join(' ')}`,
+                    'AFTER',
+                    `\`${findAfterIndex}\``
+                ].join(' ');
+                yield this._queryStatement(sql);
+            }
+            return;
         });
     }
     _valuePattern(value) {
@@ -1830,14 +2676,27 @@ class Model extends AbstractModel_1.AbstractModel {
         return pluralize_1.default.plural(this._valuePattern(tb));
     }
     _makeTableName() {
-        const tableName = this._classToTableName();
-        this._setState('TABLE_NAME', `\`${tableName}\``);
+        if (this.$table == null || this.$table === '') {
+            const tableName = this._classToTableName();
+            this._setState('TABLE_NAME', `\`${this._valuePattern(tableName)}\``);
+            return this;
+        }
+        this._setState('TABLE_NAME', `\`${this._valuePattern(this.$table)}\``);
         return this;
     }
     _handleSoftDelete() {
         if (this._getState('SOFT_DELETE')) {
             const deletedAt = this._valuePattern(this._getState('SOFT_DELETE_FORMAT'));
-            this.whereNull(deletedAt);
+            const wheres = this._getState('WHERE');
+            const softDeleteIsNull = [
+                this.bindColumn(`${this.getTableName()}.${deletedAt}`),
+                this.$constants('IS_NULL')
+            ].join(' ');
+            if (!wheres.some((where) => where.includes(softDeleteIsNull))) {
+                this.whereNull(deletedAt);
+                return this;
+            }
+            return this;
         }
         return this;
     }
@@ -1872,7 +2731,7 @@ class Model extends AbstractModel_1.AbstractModel {
             const validateSchema = this._getState('VALIDATE_SCHEMA');
             if (!validateSchema)
                 return;
-            const schemaTable = this._getState('SCHEMA_TABLE');
+            const schemaTable = this.getSchemaModel();
             if (schemaTable == null) {
                 return this._assertError(schemaTable == null, `This method "validateSchema" isn't validation without schema. Please use the method "useSchema" for define your schema`);
             }
@@ -1885,10 +2744,6 @@ class Model extends AbstractModel_1.AbstractModel {
                 return;
             const regexDate = /[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])/;
             const regexDateTime = /[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1]) (2[0-3]|[01][0-9]):[0-5][0-9]/;
-            Object.entries(data).some(([column]) => {
-                if (schema[column] == null)
-                    this._assertError(`This column "${column}" is not in schema`);
-            });
             for (const column in schema) {
                 const s = schema[column];
                 const r = data[column];
@@ -2339,12 +3194,12 @@ class Model extends AbstractModel_1.AbstractModel {
         return [
             `(${[...new Set(columns)].join(',')})`,
             `${this.$constants('VALUES')}`,
-            `${values.join(',')}`
+            `${values.join(', ')}`
         ].join(' ');
     }
     _insertNotExistsModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!this._getState('WHERE'), "This method 'createNotExists' is require to use 'where'");
+            this._assertError(!this._getState('where').length, "This method 'createNotExists' is require to use 'where' conditions");
             const check = (yield new Model()
                 .copyModel(this, { where: true, select: true, limit: true })
                 .bind(this.$pool.get())
@@ -2390,8 +3245,9 @@ class Model extends AbstractModel_1.AbstractModel {
         });
     }
     _createMultipleModel() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            for (const data of this._getState('DATA')) {
+            for (const data of (_a = this._getState('DATA')) !== null && _a !== void 0 ? _a : []) {
                 yield this._validateSchema(data, 'insert');
             }
             const [result, id] = yield this._actionStatement({
@@ -2416,7 +3272,7 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     _updateOrInsertModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!this._getState('WHERE'), "This method 'createOrUpdate' is require to use 'where'");
+            this._assertError(!this._getState('where').length, "This method 'createOrUpdate' is require to use 'where' conditions");
             const check = (yield new Model()
                 .copyModel(this, { select: true, where: true, limit: true })
                 .bind(this.$pool.get())
@@ -2471,7 +3327,7 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     _insertOrSelectModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!this._getState('WHERE'), "This method 'createOrSelect' is require to use 'where'");
+            this._assertError(!this._getState('where').length, "This method 'createOrSelect' is require to use 'where' conditions");
             const check = (yield new Model()
                 .copyModel(this, { select: true, where: true, limit: true })
                 .bind(this.$pool.get())
@@ -2520,7 +3376,7 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     _updateModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!String(this._getState('WHERE')), "This method 'update' is require to use 'where'");
+            this._assertError(!this._getState('where').length, "This method 'update' is require to use 'where' conditions");
             yield this._validateSchema(this._getState('DATA'), 'update');
             const sql = this._queryBuilder().update();
             const result = yield this._actionStatement({ sql });
@@ -2600,9 +3456,9 @@ class Model extends AbstractModel_1.AbstractModel {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (retry > 3 || this._getState('RETRY') > 3)
+                if (retry > 2 || this._getState('RETRY') > 2)
                     throw e;
-                const schemaTable = this._getState('SCHEMA_TABLE');
+                const schemaTable = this.getSchemaModel();
                 if (schemaTable == null)
                     return this._stoppedRetry(e);
                 if (!(e instanceof Error))
@@ -2643,14 +3499,14 @@ class Model extends AbstractModel_1.AbstractModel {
                 yield this._queryStatement(sql);
             }
             catch (e) {
-                if (retry > 3)
+                if (retry >= 2)
                     throw e;
                 yield this._checkSchemaOrNextError(e, retry + 1);
             }
         });
     }
     _stoppedRetry(e) {
-        this._setState('RETRY', 3);
+        this._setState('RETRY', 2);
         throw e;
     }
     _observer(result, type) {
@@ -2664,10 +3520,44 @@ class Model extends AbstractModel_1.AbstractModel {
         }
         return;
     }
+    _makeRelations() {
+        if (this.$hasOne != null) {
+            for (const hasOne of this.$hasOne) {
+                this.hasOne(Object.assign(Object.assign({}, hasOne), { name: String(hasOne.name) }));
+            }
+        }
+        if (this.$hasMany != null) {
+            for (const hasMany of this.$hasMany) {
+                this.hasMany(Object.assign(Object.assign({}, hasMany), { name: String(hasMany.name) }));
+            }
+        }
+        if (this.$belongsTo != null) {
+            for (const belongsTo of this.$belongsTo) {
+                this.belongsTo(Object.assign(Object.assign({}, belongsTo), { name: String(belongsTo.name) }));
+            }
+        }
+        if (this.$belongsToMany != null) {
+            for (const belongsToMany of this.$belongsToMany) {
+                this.belongsToMany(Object.assign(Object.assign({}, belongsToMany), { name: String(belongsToMany.name) }));
+            }
+        }
+        return this;
+    }
     _initialModel() {
-        this.$state = new StateHandler_1.StateHandler(this.$constants('MODEL'));
+        this.$state = new State_1.StateHandler(this.$constants('MODEL'));
+        if (this.$pattern != null)
+            this.usePattern(this.$pattern);
         this._makeTableName();
-        this.$relation = new RelationHandler_1.RelationHandler(this);
+        this.$relation = new Relation_1.RelationHandler(this);
+        this._makeRelations();
+        if (this.$uuid != null)
+            this.useUUID(this.$uuidColumn);
+        if (this.$timestamp != null)
+            this.useTimestamp(this.$timestampColumns);
+        if (this.$softDelete != null)
+            this.useSoftDelete(this.$softDeleteColumn);
+        if (this.$validateSchema != null)
+            this.useValidateSchema(this.$validateSchema);
         return this;
     }
 }