tspace-mysql 1.4.6 → 1.4.7

package/dist/lib/tspace/Model.js

@@ -19,6 +19,14 @@ 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");
+/**
+ *
+ * 'Model' class is a representation of a database table
+ * @example
+ * class User extends Model {}
+ * new User().findMany().then(users => console.log(users))
+ */
 class Model extends AbstractModel_1.AbstractModel {
     constructor() {
         super();
@@ -36,8 +44,7 @@ class Model extends AbstractModel_1.AbstractModel {
         return new Proxy(this, ProxyHandler_1.proxyHandler);
     }
     /**
-     *
-     * define for initialize of models
+     * The 'define' method is a special method that you can define within a model.
      * @example
      *  class User extends Model {
      *     define() {
@@ -51,8 +58,7 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     define() { }
     /**
-     *
-     * boot for initialize of models like constructor()
+     *  The 'boot' method is a special method that you can define within a model.
      *  @example
      *  class User extends Model {
      *     boot() {
@@ -66,8 +72,46 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     boot() { }
     /**
+     * The "useObserve" pattern refers to a way of handling model events using observer classes.
+     * Model events are triggered when certain actions occur on models,
+     * such as creating, updating, deleting, or saving a record.
+     *
+     * Observers are used to encapsulate the event-handling logic for these events,
+     * keeping the logic separate from the model itself and promoting cleaner, more maintainable code.
+     * @param {Function} observer
+     * @return this
+     * @example
      *
-     * Assign auto create table when not exists table
+     * class UserObserve {
+     *
+     *    public created(results : unknown) {
+     *       console.log({ results , created : true })
+     *    }
+     *
+     *    public updated(results : unknown) {
+     *       console.log({ results ,updated : true })
+     *    }
+     *
+     *    public deleted(results : unknown) {
+     *       console.log({ results ,deleted : true })
+     *    }
+     *   }
+     *
+     *   class User extends Model {
+     *      constructor() {
+     *          super()
+     *          this.useObserver(UserObserve)
+     *      }
+     *   }
+     */
+    useObserver(observer) {
+        this._setState('OBSERVER', observer);
+        return this;
+    }
+    /**
+     * The "useSchema" method is used to define the schema.
+     *
+     * It's automatically create, called when not exists table or columns.
      * @param {object} schema using Blueprint for schema
      * @example
      * import { Blueprint } from 'tspace-mysql'
@@ -86,108 +130,112 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     useSchema(schema) {
-        this.$state.set('SCHEMA_TABLE', schema);
+        this._setState('SCHEMA_TABLE', schema);
         return this;
     }
     /**
      *
-     * Assign function callback in model like constructor()
+     * The "useRegistry" method is used to define Function to results.
+     *
+     * It's automatically given Function to results.
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useRegistry()
      *     }
      * }
-     * @return {this} this
+     
      */
     useRegistry() {
-        this.$state.set('REGISTRY', Object.assign(Object.assign({}, this.$state.get('REGISTRY')), { '$attach': this._attach, '$detach': this._detach }));
+        this._setState('REGISTRY', Object.assign(Object.assign({}, this._getState('REGISTRY')), { '$attach': this._attach, '$detach': this._detach }));
         return this;
     }
     /**
-     *
-     * Assign model calling all relationships in model
+     * The "useLoadRelationsInRegistry" method is used automatically called relations in your registry Model.
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useLoadRelationInRegistry()
      *     }
      * }
-     * @return {this} this
      */
     useLoadRelationsInRegistry() {
-        const relations = this.$state.get('RELATION').map((r) => String(r.name));
+        const relations = this._getState('RELATION').map((r) => String(r.name));
         if (relations.length)
-            this.with(...Array.from(new Set(relations)));
+            this.relations(...Array.from(new Set(relations)));
         return this;
     }
     /**
+     * The "useBuiltInRelationFunctions" method is used to define the function.
      *
-     * Assign model built-in relation functions to a results
+     * It's automatically given built-in relation functions to a results.
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useBuiltInRelationsFunction()
      *     }
      * }
-     * @return {this} this
      */
     useBuiltInRelationFunctions() {
-        this.$state.set('FUNCTION_RELATION', true);
+        this._setState('FUNCTION_RELATION', true);
         return this;
     }
     /**
+     * The "usePrimaryKey" method is add primary keys for database tables.
      *
-     * Assign primary column in model
      * @param {string} primary
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.usePrimaryKey()
      *     }
      * }
-     * @return {this} this
      */
     usePrimaryKey(primary) {
-        this.$state.set('PRIMARY_KEY', primary);
+        this._setState('PRIMARY_KEY', primary);
         return this;
     }
     /**
-     * Assign generate uuid when creating in model
+     * The "useUUID" method is a concept of using UUIDs (Universally Unique Identifiers) as column 'uuid' in table.
+     *
+     * It's automatically genarate when created a result.
      * @param {string?} column [column=uuid] make new name column for custom column replace uuid with this
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useUUID()
      *     }
      * }
-     * @return {this} this
      */
     useUUID(column) {
-        this.$state.set('UUID', true);
+        this._setState('UUID', true);
         if (column)
-            this.$state.set('UUID_FORMAT', column);
+            this._setState('UUID_FORMAT', column);
         return this;
     }
     /**
-     * Assign in model console.log raw sql when fetching query statement
+     * The "useDebug" method is viewer raw-sql logs when excute the results.
      * @return {this} this
      */
     useDebug() {
-        this.$state.set('DEBUG', true);
+        this._setState('DEBUG', true);
         return this;
     }
     /**
-     *
-     * Assign in model use pattern [snake_case , camelCase]
+     * The "usePattern" method is used to assign pattern [snake_case , camelCase].
      * @param  {string} pattern
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.usePattern('camelCase')
      *     }
      * }
-     * @return {this} this
      */
     usePattern(pattern) {
         const allowPattern = [
@@ -195,34 +243,49 @@ class Model extends AbstractModel_1.AbstractModel {
             this.$constants('PATTERN').camelCase
         ];
         this._assertError(!allowPattern.includes(pattern), `tspace-mysql support only pattern ["${this.$constants('PATTERN').snake_case}","${this.$constants('PATTERN').camelCase}"]`);
-        this.$state.set('PATTERN', pattern);
+        this._setState('PATTERN', pattern);
+        this._makeTableName();
+        return this;
+    }
+    useCamelCase() {
+        this._setState('PATTERN', this.$constants('PATTERN').camelCase);
+        this._makeTableName();
+        return this;
+    }
+    useSnakeCase() {
+        this._setState('PATTERN', this.$constants('PATTERN').snake_case);
+        this._makeTableName();
         return this;
     }
     /**
+     * The "useSoftDelete" refer to a feature that allows you to "soft delete" records from a database table instead of permanently deleting them.
      *
-     * Assign in model show data not be deleted
-     * Relations has reference this method
+     * Soft deleting means that the records are not physically removed from the database but are instead marked as deleted by setting a timestamp in a dedicated column.
+     *
+     * This feature is particularly useful when you want to retain a record of deleted data and potentially recover it later,
+     * or when you want to maintain referential integrity in your database
      * @param {string?} column default deleted_at
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useSoftDelete('deletedAt')
      *     }
      * }
-     * @return {this} this
      */
     useSoftDelete(column) {
-        this.$state.set('SOFT_DELETE', true);
+        this._setState('SOFT_DELETE', true);
         if (column)
-            this.$state.set('SOFT_DELETE_FORMAT', column);
+            this._setState('SOFT_DELETE_FORMAT', column);
         return this;
     }
     /**
-     *
-     * Assign timestamp when insert || updated created_at and update_at in table
+     * The "useTimestamp" method is used to assign a timestamp when creating a new record,
+     * or updating a record.
      * @param {object} timestampFormat
      * @property {string} timestampFormat.createdAt  - change new name column replace by default [created at]
      * @property {string} timestampFormat.updatedAt - change new name column replace by default updated at
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
@@ -232,12 +295,11 @@ class Model extends AbstractModel_1.AbstractModel {
      *        })
      *     }
      * }
-     * @return {this} this
      */
     useTimestamp(timestampFormat) {
-        this.$state.set('TIMESTAMP', true);
+        this._setState('TIMESTAMP', true);
         if (timestampFormat) {
-            this.$state.set('TIMESTAMP_FORMAT', {
+            this._setState('TIMESTAMP_FORMAT', {
                 CREATED_AT: timestampFormat.createdAt,
                 UPDATED_AT: timestampFormat.updatedAt
             });
@@ -245,126 +307,160 @@ class Model extends AbstractModel_1.AbstractModel {
         return this;
     }
     /**
-     *
-     * Assign table name in model
+     * This "useTable" method is used to assign the name of the table.
      * @param {string} table table name in database
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useTable('setTableNameIsUser') // => 'setTableNameIsUser'
      *     }
      * }
-     * @return {this} this
      */
     useTable(table) {
-        this.$state.set('TABLE_NAME', `\`${table}\``);
+        this._setState('TABLE_NAME', `\`${table}\``);
         return this;
     }
     /**
-     *
-     * Assign table name in model with signgular pattern
+     * This "useTableSingular" method is used to assign the name of the table with signgular pattern.
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useTableSingular() // => 'user'
      *     }
      * }
-     * @return {this} this
      */
     useTableSingular() {
         var _a;
         const table = this._classToTableName((_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name, { singular: true });
-        this.$state.set('TABLE_NAME', `\`${pluralize_1.default.singular(table)}\``);
+        this._setState('TABLE_NAME', `\`${this._valuePattern(table)}\``);
         return this;
     }
     /**
-     *
-     * Assign table name in model with pluarl pattern
+     * This "useTablePlural " method is used to assign the name of the table with pluarl pattern
+     * @return {this} this
      * @example
      * class User extends Model {
      *     constructor() {
      *        this.useTablePlural() // => 'users'
      *     }
      * }
-     * @return {this} this
      */
     useTablePlural() {
         var _a;
         const table = this._classToTableName((_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name);
-        this.$state.set('TABLE_NAME', `\`${pluralize_1.default.plural(table)}\``);
+        this._setState('TABLE_NAME', `\`${pluralize_1.default.plural(table)}\``);
         return this;
     }
     /**
-     *
-     * Assign schema column in model for validation data types
-     * @param {Object<NumberConstructor | StringConstructor | DateConstructor>} schema types (String Number and Date)
+     * This 'useValidationSchema' method is used to validate the schema when have some action create or update.
+     * @param {Object<ValidateSchema>} schema types (String Number and Date)
+     * @return {this} this
      * @example
      * class User extends Model {
      *   constructor() {
-     *     this.useValidationSchema()
-     *   }
+     *     this.useValidationSchema({
+     *      id : Number,
+     *       uuid :  Number,
+     *       name : {
+     *           type : String,
+     *           require : true
+     *           // json : true,
+     *           // enum : ["1","2","3"]
+     *      },
+     *      email : {
+     *           type : String,
+     *           require : true,
+     *           length : 199,
+     *           match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+     *           unique : true,
+     *           fn : async (email : string) => /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+     *       },
+     *       createdAt : Date,
+     *       updatedAt : Date,
+     *       deletedAt : Date
+     *    })
+     *  }
      * }
-     * @return {this} this
      */
     useValidationSchema(schema) {
-        this.$state.set('VALIDATE_SCHEMA', true);
-        this.$state.set('VALIDATE_SCHEMA_DEFINED', schema);
+        this._setState('VALIDATE_SCHEMA', true);
+        this._setState('VALIDATE_SCHEMA_DEFINED', schema);
         return this;
     }
     /**
-    *
-    * Assign schema column in model for validation data types
-    * @param {Object<NumberConstructor | StringConstructor | DateConstructor>} schema types (String Number and Date)
-    * @example
-    * class User extends Model {
-    *   constructor() {
-    *     this.useValidationSchema()
-    *   }
-    * }
-    * @return {this} this
-    */
+     * This 'useValidateSchema' method is used to validate the schema when have some action create or update.
+     * @param {Object<ValidateSchema>} schema types (String Number and Date)
+     * @return {this} this
+     * @example
+     * class User extends Model {
+     *   constructor() {
+     *     this.useValidationSchema({
+     *       id : Number,
+     *       uuid :  string,
+     *       name : {
+     *           type : String,
+     *           require : true
+     *      },
+     *      email : {
+     *           type : String,
+     *           require : true,
+     *           length : 199,
+     *           // json : true,
+     *           // enum : ["1","2","3"]
+     *           match: /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/,
+     *           unique : true,
+     *           fn : async (email : string) => /^[a-zA-Z0-9._]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)
+     *       },
+     *       createdAt : Date,
+     *       updatedAt : Date,
+     *       deletedAt : Date
+     *    })
+     *  }
+     * }
+     */
     useValidateSchema(schema) {
-        this.$state.set('VALIDATE_SCHEMA', true);
-        this.$state.set('VALIDATE_SCHEMA_DEFINED', schema);
-        return this;
+        return this.useValidationSchema(schema);
     }
     /**
-     * Assign hook function when execute returned results to callback function
-     * @param {Array<Function>} arrayFunctions functions for callback result
+     * The "useHooks" method is used to assign hook function when execute returned results to callback function.
+     * @param {Function[]} arrayFunctions functions for callback result
+     * @return {this} this
      * @example
      * class User extends Model {
      *   constructor() {
      *     this.useHook([(results) => console.log(results)])
      *   }
      * }
-     * @return {this}
     */
     useHooks(arrayFunctions) {
         for (const func of arrayFunctions) {
             if (typeof func !== "function")
                 throw new Error(`this '${func}' is not a function`);
-            this.$state.set('HOOKS', [...this.$state.get('HOOKS'), func]);
+            this._setState('HOOKS', [...this._getState('HOOKS'), func]);
         }
         return this;
     }
     /**
      * exceptColumns for method except
+     * @override
      * @return {promise<string>} string
      */
-    exceptColumns() {
+    _exceptColumns() {
         return __awaiter(this, void 0, void 0, function* () {
-            const excepts = this.$state.get('EXCEPTS');
+            const excepts = this._getState('EXCEPTS');
             const hasDot = excepts.some((except) => /\./.test(except));
             const names = excepts.map((except) => {
                 if (/\./.test(except))
                     return except.split('.')[0];
                 return null;
             }).filter((d) => d != null);
-            const tableNames = names.length ? [...new Set(names)] : [this.$state.get('TABLE_NAME')];
+            const tableNames = names.length ? [...new Set(names)] : [this._getState('TABLE_NAME')];
             const removeExcepts = [];
             for (const tableName of tableNames) {
-                if (this.$state.get('SCHEMA_TABLE') && (tableName === this.$state.get('TABLE_NAME').replace(/`/g, ''))) {
-                    const columns = Object.keys(this.$state.get('SCHEMA_TABLE'));
+                if (this._getState('SCHEMA_TABLE') && (tableName === this._getState('TABLE_NAME').replace(/`/g, ''))) {
+                    const columns = Object.keys(this._getState('SCHEMA_TABLE'));
                     const removeExcept = columns.filter((column) => {
                         return excepts.every((except) => {
                             if (/\./.test(except)) {
@@ -383,7 +479,7 @@ class Model extends AbstractModel_1.AbstractModel {
                     `${this.$constants('FROM')}`,
                     `${tableName}`
                 ].join(' ');
-                const rawColumns = yield this.queryStatement(sql);
+                const rawColumns = yield this._queryStatement(sql);
                 const columns = rawColumns.map((column) => column.Field);
                 const removeExcept = columns.filter((column) => {
                     return excepts.every((except) => {
@@ -407,8 +503,8 @@ class Model extends AbstractModel_1.AbstractModel {
      */
     buildMethodRelation(name, callback) {
         var _a, _b;
-        this.with(name);
-        const relation = this.$state.get('RELATIONS').find((data) => data.name === name);
+        this.relations(name);
+        const relation = this._getState('RELATIONS').find((data) => data.name === name);
         this._assertError(relation == null, `This Relation "${name}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
         const relationHasExists = (_b = Object.values(this.$constants('RELATIONSHIP'))) === null || _b === void 0 ? void 0 : _b.includes(relation.relation);
         this._assertError(!relationHasExists, `Unknown Relationship in [${this.$constants('RELATIONSHIP')}] !`);
@@ -456,6 +552,14 @@ class Model extends AbstractModel_1.AbstractModel {
             newInstance.$state.set('LIMIT', '');
         if ((options === null || options === void 0 ? void 0 : options.offset) == null)
             newInstance.$state.set('OFFSET', '');
+        if ((options === null || options === void 0 ? void 0 : options.groupBy) == null)
+            newInstance.$state.set('GROUP_BY', '');
+        if ((options === null || options === void 0 ? void 0 : options.orderBy) == null)
+            newInstance.$state.set('ORDER_BY', '');
+        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', '');
         return newInstance;
     }
     /**
@@ -465,18 +569,23 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {string} sql
      * @return {this} this
      */
-    queryStatement(sql) {
+    _queryStatement(sql) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this.$state.get('DEBUG'))
+                if (this._getState('DEBUG')) {
                     this.$utils.consoleDebug(sql);
-                this.$state.set('RETRY_QUERIES', Number(this.$state.get('RETRY_QUERIES')) + 1);
-                const result = yield this.$pool.query(sql);
-                return result;
+                    const result = yield this.$pool.query(sql);
+                    return result;
+                }
+                return yield this.$pool.query(sql);
             }
             catch (error) {
-                yield this._checkSchemaOrNextError(error);
-                return yield this.queryStatement(sql);
+                if ((_a = this._getState('JOIN')) === null || _a === void 0 ? void 0 : _a.length)
+                    throw error;
+                yield this._checkSchemaOrNextError(error, Number(this._getState('RETRY')));
+                this._setState('RETRY', Number(this._getState('RETRY')) + 1);
+                return yield this._queryStatement(sql);
             }
         });
     }
@@ -485,16 +594,23 @@ class Model extends AbstractModel_1.AbstractModel {
      * execute the query using raw sql syntax actions for insert update and delete
      * @override method
      * @param {Object} actions
-     * @property {Function} actions.sql
+     * @property {Function} actions.sqlresult
      * @property {Function} actions.returnId
      * @return {this} this
      */
-    actionStatement({ sql, returnId = false }) {
+    _actionStatement({ sql, returnId = false }) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this.$state.get('DEBUG'))
+                if (this._getState('DEBUG')) {
                     this.$utils.consoleDebug(sql);
-                this.$state.set('RETRY_QUERIES', Number(this.$state.get('RETRY_QUERIES')) + 1);
+                    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];
@@ -502,9 +618,12 @@ class Model extends AbstractModel_1.AbstractModel {
                 const { affectedRows: result } = yield this.$pool.query(sql);
                 return result;
             }
-            catch (e) {
-                yield this._checkSchemaOrNextError(e);
-                return yield this.actionStatement({
+            catch (error) {
+                if ((_a = this._getState('JOIN')) === null || _a === void 0 ? void 0 : _a.length)
+                    throw error;
+                yield this._checkSchemaOrNextError(error, Number(this._getState('RETRY')));
+                this._setState('RETRY', Number(this._getState('RETRY')) + 1);
+                return yield this._actionStatement({
                     sql,
                     returnId
                 });
@@ -516,8 +635,8 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param {string} table table name
      * @return {this} this
      */
-    tableName(table) {
-        this.$state.set('TABLE_NAME', `\`${table}\``);
+    table(table) {
+        this._setState('TABLE_NAME', `\`${table}\``);
         return this;
     }
     /**
@@ -526,7 +645,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     disableSoftDelete(condition = false) {
-        this.$state.set('SOFT_DELETE', condition);
+        this._setState('SOFT_DELETE', condition);
         return this;
     }
     /**
@@ -535,7 +654,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     ignoreSoftDelete(condition = false) {
-        this.$state.set('SOFT_DELETE', condition);
+        this._setState('SOFT_DELETE', condition);
         return this;
     }
     /**
@@ -544,13 +663,15 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     registry(func) {
-        this.$state.set('REGISTRY', Object.assign(Object.assign({}, func), { attach: this._attach, detach: this._detach }));
+        this._setState('REGISTRY', Object.assign(Object.assign({}, func), { attach: this._attach, detach: this._detach }));
         return this;
     }
     /**
+     * The 'with' method is used to eager load related (relations) data when retrieving records from a database.
      *
-     * Use relations in registry of model return result of relation query
+     * Eager loading allows you to retrieve a primary model and its related models in a more efficient
      * @param {...string} nameRelations ...name registry in models using (hasOne , hasMany , belongsTo , belongsToMany)
+     * @return {this} this
      * @example
      *   import { Model } from 'tspace-mysql'
      *   class User extends Model {
@@ -567,70 +688,48 @@ class Model extends AbstractModel_1.AbstractModel {
      *           this.belongsTo({ name : 'user' , model : User })
      *       }
      *   }
-     *  // use with for results of relationship
-     *  await new User().with('posts').findMany()
-     * @return {this} this
+     *  // use 'with' for results of relationship
+     *  await new User().relations('posts').findMany()
+     *
      */
     with(...nameRelations) {
-        const relations = this._handleRelations(nameRelations);
-        const setRelations = this.$state.get('RELATIONS').length
-            ? [...relations.map((w) => {
-                    const exists = this.$state.get('RELATIONS').find((r) => r.name === w.name);
-                    if (exists)
-                        return null;
-                    return w;
-                }).filter((d) => d != null),
-                ...this.$state.get('RELATIONS')]
-            : relations;
-        this.$state.set('RELATIONS', setRelations);
+        var _a;
+        this._setState('RELATIONS', (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.apply(nameRelations, 'default'));
         return this;
     }
     /**
+     * The 'withAll' method is used to eager load related (relations) data when retrieving records from a database.
      *
-     * Use relations in registry of model return ignore soft delete
+     * 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
      */
     withAll(...nameRelations) {
-        const relations = this._handleRelations(nameRelations);
-        relations.forEach(relation => relation.all = true);
-        const setRelations = this.$state.get('RELATIONS').length
-            ? [...relations.map((w) => {
-                    const exists = this.$state.get('RELATIONS').find((r) => r.name === w.name);
-                    if (exists)
-                        return null;
-                    return w;
-                }).filter((d) => d != null),
-                ...this.$state.get('RELATIONS')]
-            : relations;
-        this.$state.set('RELATIONS', setRelations);
+        var _a;
+        this._setState('RELATIONS', (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.apply(nameRelations, 'all'));
         return this;
     }
     /**
+     * The 'withTrashed' method is used to eager load related (relations) data when retrieving records from a database.
      *
-     * Use relations in registry of model return only in trash (soft delete)
+     * Eager loading allows you to retrieve a primary model and its related models in a more efficient
+     * It's method return results only in trash (soft deleted)
      * @param {...string} nameRelations if data exists return blank
      * @return {this} this
      */
     withTrashed(...nameRelations) {
-        const relations = this._handleRelations(nameRelations);
-        relations.forEach(relation => relation.trashed = true);
-        const setRelations = this.$state.get('RELATIONS').length
-            ? [...relations.map((w) => {
-                    const exists = this.$state.get('RELATIONS').find((r) => r.name === w.name);
-                    if (exists)
-                        return null;
-                    return w;
-                }).filter((d) => d != null),
-                ...this.$state.get('RELATIONS')]
-            : relations;
-        this.$state.set('RELATIONS', setRelations);
+        var _a;
+        this._setState('RELATIONS', (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.apply(nameRelations, 'trashed'));
         return this;
     }
     /**
+     * The 'withExists' method is used to eager load related (relations) data when retrieving records from a database.
      *
-     * Use relations in registry of model return only exists result of relation query
-     * @param {...string} nameRelations if data exists return blank
+     * Eager loading allows you to retrieve a primary model and its related models in a more efficient
+     * It's method return only exists result of relation query
+     * @param {...string} nameRelations
+     * @return {this} this
      * @example
      *   import { Model } from 'tspace-mysql'
      *   class User extends Model {
@@ -648,23 +747,12 @@ class Model extends AbstractModel_1.AbstractModel {
      *       }
      *   }
      *  // use with for results of relationship if relations is exists
-     *  await new User().withExists('posts').findMany()
-     * @return {this} this
+     *  await new User().relationsExists('posts').findMany()
      */
     withExists(...nameRelations) {
-        this.$state.set('RELATIONS_EXISTS', true);
-        const relations = (this._handleRelations(nameRelations));
-        relations.forEach(relation => relation.exists = true);
-        const setRelations = this.$state.get('RELATIONS').length
-            ? [...relations.map((w) => {
-                    const exists = this.$state.get('RELATIONS').find((r) => r.name === w.name);
-                    if (exists)
-                        return null;
-                    return w;
-                }).filter((d) => d != null),
-                ...this.$state.get('RELATIONS')]
-            : relations;
-        this.$state.set('RELATIONS', setRelations);
+        var _a;
+        this._setState('RELATIONS_EXISTS', true);
+        this._setState('RELATIONS', (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.apply(nameRelations, 'exists'));
         return this;
     }
     /**
@@ -692,11 +780,13 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     has(...nameRelations) {
-        return this.withExists(...nameRelations);
+        return this.relationsExists(...nameRelations);
     }
     /**
      *
-     * Use relation '${name}' registry of model return callback this query model
+     * The 'withQuery' method is particularly useful when you want to filter or add conditions records based on related data.
+     *
+     * Use relation '${name}' registry models then return callback queries
      * @param {string} nameRelation name relation in registry in your model
      * @param {function} callback query callback
      * @example
@@ -724,15 +814,15 @@ class Model extends AbstractModel_1.AbstractModel {
      *       }
      *   }
      *
-     *   await new User().with('posts')
-     *   .withQuery('posts', (query : Post) => {
-     *       return query.with('comments','user')
-     *       .withQuery('comments', (query : Comment) => {
-     *           return query.with('user','post')
+     *   await new User().relations('posts')
+     *   .relationsQuery('posts', (query : Post) => {
+     *       return query.relations('comments','user')
+     *       .relationsQuery('comments', (query : Comment) => {
+     *           return query.relations('user','post')
      *       })
-     *       .withQuery('user', (query : User) => {
-     *           return query.with('posts').withQuery('posts',(query : Post)=> {
-     *               return query.with('comments','user')
+     *       .relationsQuery('user', (query : User) => {
+     *           return query.relations('posts').relationsQuery('posts',(query : Post)=> {
+     *               return query.relations('comments','user')
      *               // relation n, n, ...n
      *           })
      *       })
@@ -741,12 +831,8 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     withQuery(nameRelation, callback) {
-        var _a, _b;
-        const relation = this.$state.get('RELATIONS').find((data) => data.name === nameRelation);
-        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
-        const relationHasExists = (_b = Object.values(this.$constants('RELATIONSHIP'))) === null || _b === void 0 ? void 0 : _b.includes(relation.relation);
-        this._assertError(!relationHasExists, `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
-        relation.query = callback(new relation.model());
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.callback(nameRelation, callback);
         return this;
     }
     /**
@@ -774,7 +860,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relations(...nameRelations) {
-        return this.with(...nameRelations);
+        return this.relations(...nameRelations);
     }
     /**
      *
@@ -801,7 +887,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationsExists(...nameRelations) {
-        return this.withExists(...nameRelations);
+        return this.relationsExists(...nameRelations);
     }
     /**
      *
@@ -833,15 +919,15 @@ class Model extends AbstractModel_1.AbstractModel {
      *       }
      *   }
      *
-     *   await new User().with('posts')
+     *   await new User().relations('posts')
      *   .relationQuery('posts', (query : Post) => {
-     *       return query.with('comments','user')
+     *       return query.relations('comments','user')
      *       .relationQuery('comments', (query : Comment) => {
-     *           return query.with('user','post')
+     *           return query.relations('user','post')
      *       })
      *       .relationQuery('user', (query : User) => {
-     *           return query.with('posts').relationQuery('posts',(query : Post)=> {
-     *               return query.with('comments','user')
+     *           return query.relations('posts').relationQuery('posts',(query : Post)=> {
+     *               return query.relations('comments','user')
      *               // relation n, n, ...n
      *           })
      *       })
@@ -859,7 +945,7 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationsAll(...nameRelations) {
-        return this.withAll(...nameRelations);
+        return this.relationsAll(...nameRelations);
     }
     /**
      *
@@ -868,10 +954,15 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return {this} this
      */
     relationsTrashed(...nameRelations) {
-        return this.withTrashed(...nameRelations);
+        return this.relationsTrashed(...nameRelations);
     }
     /**
-     * Assign the relation in model Objects
+     * The 'hasOne' relationship defines a one-to-one relationship between two database tables.
+     *
+     * It indicates that a particular record in the primary table is associated with one and only one record in the related table.
+     *
+     * This is typically used when you have a foreign key in the related table that references the primary table.
+     *
      * @param    {object} relations registry relation in your model
      * @property {string} relation.name
      * @property {string} relation.as
@@ -882,21 +973,24 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return   {this}   this
      */
     hasOne({ name, as, model, localKey, foreignKey, freezeTable }) {
-        const relation = {
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.hasOne({
             name,
-            model,
             as,
-            relation: this.$constants('RELATIONSHIP').hasOne,
+            model,
             localKey,
             foreignKey,
-            freezeTable,
-            query: null
-        };
-        this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
+            freezeTable
+        });
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'hasMany' relationship defines a one-to-many relationship between two database tables.
+     *
+     * It indicates that a record in the primary table can be associated with multiple records in the related table.
+     *
+     * This is typically used when you have a foreign key in the related table that references the primary table.
+     *
      * @param    {object} relations registry relation in your model
      * @property {string} relation.name
      * @property {string} relation.as
@@ -907,21 +1001,24 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return   {this}   this
      */
     hasMany({ name, as, model, localKey, foreignKey, freezeTable }) {
-        const relation = {
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.hasMany({
             name,
-            model,
             as,
-            relation: this.$constants('RELATIONSHIP').hasMany,
+            model,
             localKey,
             foreignKey,
-            freezeTable,
-            query: null
-        };
-        this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
+            freezeTable
+        });
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'belongsTo' relationship defines a one-to-one or many-to-one relationship between two database tables.
+     *
+     * It indicates that a record in the related table belongs to a single record in the primary table.
+     *
+     * This is typically used when you have a foreign key in the primary table that references the related table.
+     *
      * @param    {object} relations registry relation in your model
      * @property {string} relation.name
      * @property {string} relation.as
@@ -932,21 +1029,24 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return   {this}   this
      */
     belongsTo({ name, as, model, localKey, foreignKey, freezeTable }) {
-        const relation = {
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.belongsTo({
             name,
             as,
             model,
-            relation: this.$constants('RELATIONSHIP').belongsTo,
             localKey,
             foreignKey,
-            freezeTable,
-            query: null
-        };
-        this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
+            freezeTable
+        });
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'belongsToMany' relationship defines a many-to-many relationship between two database tables.
+     *
+     * It indicates that records in both the primary table and the related table can be associated
+     * with multiple records in each other's table through an intermediate table.
+     *
+     * This is commonly used when you have a many-to-many relationship between entities, such as users and roles or products and categories.
      * @param    {object} relations registry relation in your model
      * @property {string} relation.name
      * @property {string} relation.as
@@ -956,61 +1056,53 @@ class Model extends AbstractModel_1.AbstractModel {
      * @property {string} relation.freezeTable freeae table name
      * @property {string} relation.pivot table name of pivot
      * @property {string} relation.oldVersion return value of old version
+     * @property {class?} relation.modelPivot model for pivot
      * @return   {this}   this
      */
-    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion }) {
-        const relation = {
+    belongsToMany({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }) {
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.belongsToMany({
             name,
-            model,
             as,
-            relation: this.$constants('RELATIONSHIP').belongsToMany,
+            model,
             localKey,
             foreignKey,
             freezeTable,
             pivot,
             oldVersion,
-            query: null
-        };
-        this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
+            modelPivot
+        });
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'hasOneBuilder' method is useful for creating 'hasOne' relationship to function
+     *
      * @param    {object}  relation registry relation in your model
      * @type     {object}  relation
-     * @property {class}  model
+     * @property {class}   model
      * @property {string?} name
-     * @property {string?}  as
+     * @property {string?} as
      * @property {string?} localKey
      * @property {string?} foreignKey
      * @property {string?} freezeTable
-     * @param    {function?} callback callback of query
+     * @param    {Function?} callback callback of query
      * @return   {this} this
      */
     hasOneBuilder({ name, as, model, localKey, foreignKey, freezeTable }, callback) {
-        const nameRelation = name == null
-            ? this._functionRelationName()
-            : String(name);
-        const relation = {
-            name: nameRelation,
-            model,
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.hasOneBuilder({
+            name,
             as,
-            relation: this.$constants('RELATIONSHIP').hasOne,
+            model,
             localKey,
             foreignKey,
-            freezeTable,
-            query: null
-        };
-        const r = this._handleRelationsQuery(nameRelation, relation);
-        if (callback == null) {
-            r.query = new r.model();
-            return this;
-        }
-        r.query = callback(new r.model());
+            freezeTable
+        }, callback);
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'hasManyBuilder' method is useful for creating 'hasMany' relationship to function
+     *
      * @param    {object}  relation registry relation in your model
      * @type     {object}  relation
      * @property {class}  model
@@ -1023,29 +1115,19 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return   {this} this
      */
     hasManyBuilder({ name, as, model, localKey, foreignKey, freezeTable }, callback) {
-        const nameRelation = name == null
-            ? this._functionRelationName()
-            : String(name);
-        const relation = {
-            name: nameRelation,
-            model,
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.hasManyBuilder({
+            name,
             as,
-            relation: this.$constants('RELATIONSHIP').hasMany,
+            model,
             localKey,
             foreignKey,
-            freezeTable,
-            query: null
-        };
-        const r = this._handleRelationsQuery(nameRelation, relation);
-        if (callback == null) {
-            r.query = new r.model();
-            return this;
-        }
-        r.query = callback(new r.model());
+            freezeTable
+        }, callback);
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'belongsToBuilder' method is useful for creating 'belongsTo' relationship to function
      * @param    {object}  relation registry relation in your model
      * @type     {object}  relation
      * @property {class}  model
@@ -1058,29 +1140,19 @@ class Model extends AbstractModel_1.AbstractModel {
      * @return   {this} this
      */
     belongsToBuilder({ name, as, model, localKey, foreignKey, freezeTable }, callback) {
-        const nameRelation = name == null
-            ? this._functionRelationName()
-            : String(name);
-        const relation = {
-            name: nameRelation,
-            model,
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.belongsToBuilder({
+            name,
             as,
-            relation: this.$constants('RELATIONSHIP').belongsTo,
+            model,
             localKey,
             foreignKey,
-            freezeTable,
-            query: null
-        };
-        const r = this._handleRelationsQuery(nameRelation, relation);
-        if (callback == null) {
-            r.query = new r.model();
-            return this;
-        }
-        r.query = callback(new r.model());
+            freezeTable
+        }, callback);
         return this;
     }
     /**
-     * Assign the relation in model Objects
+     * The 'belongsToManyBuilder' method is useful for creating 'belongsToMany' relationship to function
      * @param    {object}  relation registry relation in your model
      * @type     {object}  relation
      * @property {class}  model
@@ -1092,62 +1164,42 @@ class Model extends AbstractModel_1.AbstractModel {
      * @param    {function?} callback callback of query
      * @return   {this} this
      */
-    belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot }, callback) {
-        const nameRelation = name == null
-            ? this._functionRelationName()
-            : String(name);
-        const relation = {
-            name: nameRelation,
-            model,
+    belongsToManyBuilder({ name, as, model, localKey, foreignKey, freezeTable, pivot, oldVersion, modelPivot }, callback) {
+        var _a;
+        (_a = this.$relation) === null || _a === void 0 ? void 0 : _a.belongsToManyBuilder({
+            name,
             as,
-            relation: this.$constants('RELATIONSHIP').belongsToMany,
+            model,
             localKey,
             foreignKey,
             freezeTable,
             pivot,
-            query: null
-        };
-        const r = this._handleRelationsQuery(nameRelation, relation);
-        if (callback == null) {
-            r.query = new r.model();
-            return this;
-        }
-        r.query = callback(new r.model());
+            oldVersion,
+            modelPivot
+        }, callback);
         return this;
     }
     /**
-     * where not null using NULL
-     * @override
-     * @return {this}
+     * The 'trashed' method is used to specify that you want to retrieve only the soft-deleted records from a database table.
+     *
+     * Soft deleting is a feature that allows you to mark records as deleted without physically removing them from the database. Instead,
+     * a special "deleted_at" timestamp column is set to a non-null value to indicate that the record has been deleted.
+     * @return {this} this
      */
-    whereTrashed() {
+    onlyTrashed() {
         this.disableSoftDelete();
-        this.whereNotNull(this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT')));
+        this.whereNotNull(this._valuePattern(this._getState('SOFT_DELETE_FORMAT')));
         return this;
     }
     /**
-     * return only in trashed (data has been remove)
-     * @return {promise}
+     * The 'trashed' method is used to specify that you want to retrieve only the soft-deleted records from a database table.
+     *
+     * Soft deleting is a feature that allows you to mark records as deleted without physically removing them from the database. Instead,
+     * a special "deleted_at" timestamp column is set to a non-null value to indicate that the record has been deleted.
+     * @return {this} this
      */
     trashed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.disableSoftDelete();
-            this.whereNotNull(this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT')));
-            const sql = this._buildQueryStatement();
-            return yield this._execute({ sql, type: 'GET' });
-        });
-    }
-    /**
-     * return all only in trashed (data has been remove)
-     * @return {promise}
-     */
-    onlyTrashed() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.disableSoftDelete();
-            this.whereNotNull(this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT')));
-            const sql = this._buildQueryStatement();
-            return yield this._execute({ sql, type: 'GET' });
-        });
+        return this.onlyTrashed();
     }
     /**
      * restore data in trashed
@@ -1156,93 +1208,123 @@ class Model extends AbstractModel_1.AbstractModel {
     restore() {
         return __awaiter(this, void 0, void 0, function* () {
             this.disableSoftDelete();
-            const updatedAt = this._valuePattern(this.$state.get('TIMESTAMP_FORMAT').UPDATED_AT);
-            const deletedAt = this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT'));
-            const query = this.$state.get('TIMESTAMP')
+            const updatedAt = this._valuePattern(this._getState('TIMESTAMP_FORMAT').UPDATED_AT);
+            const deletedAt = this._valuePattern(this._getState('SOFT_DELETE_FORMAT'));
+            const query = this._getState('TIMESTAMP')
                 ? `${deletedAt} = NULL , ${updatedAt} = '${this.$utils.timestamp()}'`
                 : `${deletedAt} = NULL`;
-            this.$state.set('UPDATE', [
+            this._setState('UPDATE', [
                 `${this.$constants('UPDATE')}`,
-                `${this.$state.get('TABLE_NAME')}`,
+                `${this._getState('TABLE_NAME')}`,
                 `SET ${query}`
             ].join(' '));
-            this.$state.set('SAVE', 'UPDATE');
+            this._setState('SAVE', 'UPDATE');
             return yield this.save();
         });
     }
     toTableName() {
-        return this._tableName();
+        return this.getTableName();
     }
     toTableNameAndColumn(column) {
-        return `\`${this._tableName()}\`.\`${this._valuePattern(column)}\``;
+        return `\`${this.getTableName()}\`.\`${this._valuePattern(column)}\``;
     }
     /**
-     * delete data from the database
      * @override Method
-     * @return {promise<boolean>}
+     * @return {promise<boolean>} promise boolean
      */
     delete() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.$state.get('WHERE'))
+            if (!this._getState('WHERE'))
                 throw new Error("Can't delete without where condition");
-            if (this.$state.get('SOFT_DELETE')) {
-                const deletedAt = this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT'));
-                const query = `${deletedAt} = '${this.$utils.timestamp()}'`;
-                let sql = [
-                    `${this.$constants('UPDATE')}`,
-                    `${this.$state.get('TABLE_NAME')}`,
-                    `${this.$constants('SET')}`,
-                    `${query}`
-                ].join(' ');
-                if (this.$state.get('TIMESTAMP')) {
-                    const updatedAt = this._valuePattern(this.$state.get('TIMESTAMP_FORMAT').UPDATED_AT);
-                    sql = `${sql} , ${updatedAt} = '${this.$utils.timestamp()}'`;
-                }
-                this.$state.set('UPDATE', `${sql} ${this.$state.get('WHERE')}`);
-                const result = yield this.actionStatement({ sql: this.$state.get('UPDATE') });
-                return Boolean(this.resultHandler((_a = !!result) !== null && _a !== void 0 ? _a : false));
+            this.limit(1);
+            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({
+                    [deletedAt]: this.$utils.timestamp()
+                })
+                    .toString();
+                const result = yield this._actionStatement({ sql });
+                const r = Boolean(this._resultHandler((_a = !!result) !== null && _a !== void 0 ? _a : false));
+                this._observer(r, 'updated');
+                return r;
             }
-            this.$state.set('DELETE', [
+            this._setState('DELETE', [
                 `${this.$constants('DELETE')}`,
-                `${this.$state.get('FROM')}`,
-                `${this.$state.get('TABLE_NAME')}`,
-                `${this.$state.get('WHERE')}`
+                `${this._getState('FROM')}`,
+                `${this._getState('TABLE_NAME')}`,
             ].join(' '));
-            const result = yield this.actionStatement({ sql: this.$state.get('DELETE') });
-            return Boolean(this.resultHandler((_b = !!result) !== null && _b !== void 0 ? _b : false));
+            const result = yield this._actionStatement({ sql: this._queryBuilder().delete() });
+            const r = Boolean(this._resultHandler((_b = !!result) !== null && _b !== void 0 ? _b : false));
+            this._observer(r, 'deleted');
+            return r;
         });
     }
     /**
-     *
      * @override Method
-     * @return {promise<Record<string,any> | null>}
+     * @return {promise<boolean>} promise boolean
+     */
+    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");
+            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({
+                    [deletedAt]: this.$utils.timestamp()
+                })
+                    .toString();
+                const result = yield this._actionStatement({ sql });
+                const r = Boolean(this._resultHandler((_a = !!result) !== null && _a !== void 0 ? _a : false));
+                this._observer(r, 'updated');
+                return r;
+            }
+            this._setState('DELETE', [
+                `${this.$constants('DELETE')}`,
+                `${this._getState('FROM')}`,
+                `${this._getState('TABLE_NAME')}`,
+            ].join(' '));
+            const result = yield this._actionStatement({ sql: this._queryBuilder().delete() });
+            const r = Boolean(this._resultHandler((_b = !!result) !== null && _b !== void 0 ? _b : false));
+            this._observer(r, 'deleted');
+            return r;
+        });
+    }
+    /**
+     * @override Method
+     * @return {promise<Record<string,any> | null>} Record | null
     */
     first() {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this._validateMethod('first');
-            if (this.$state.get('VOID'))
-                return this.resultHandler(undefined);
-            if ((_a = this.$state.get('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this.exceptColumns());
+            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.limit(1);
-            if (this.$state.get('RELATIONS_EXISTS')) {
+            if (this._getState('RELATIONS_EXISTS')) {
                 return yield this._execute({
-                    sql: this._queryRelationsExists(),
+                    sql: String((_b = this.$relation) === null || _b === void 0 ? void 0 : _b.loadExists()),
                     type: 'FIRST'
                 });
             }
             return yield this._execute({
-                sql: this._buildQueryStatement(),
+                sql: this._queryBuilder().select(),
                 type: 'FIRST'
             });
         });
     }
     /**
-     *
      * @override Method
-     * @return {promise<Record<string,any> | null>}
+     * @return {promise<Record<string,any> | null>} Record | null
     */
     findOne() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1250,25 +1332,24 @@ class Model extends AbstractModel_1.AbstractModel {
         });
     }
     /**
-     *
      * @override Method
-     * @return {promise<object | Error>}
+     * @return {promise<object | Error>} Record | throw error
     */
     firstOrError(message, options) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this._validateMethod('firstOrError');
-            if ((_a = this.$state.get('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this.exceptColumns());
+            if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
+                this.select(...yield this._exceptColumns());
             this.limit(1);
-            if (this.$state.get('RELATIONS_EXISTS')) {
+            if (this._getState('RELATIONS_EXISTS')) {
                 return yield this._execute({
-                    sql: this._queryRelationsExists(),
+                    sql: String((_b = this.$relation) === null || _b === void 0 ? void 0 : _b.loadExists()),
                     type: 'FIRST_OR_ERROR', message, options
                 });
             }
             return yield this._execute({
-                sql: this._buildQueryStatement(),
+                sql: this._queryBuilder().select(),
                 type: 'FIRST_OR_ERROR',
                 message,
                 options
@@ -1278,7 +1359,7 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override Method
-     * @return {promise<any>}
+     * @return {promise<any>} Record | throw error
     */
     findOneOrError(message, options) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1288,19 +1369,19 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override Method
-     * @return {promise<array>}
+     * @return {promise<array>} Array
     */
     get() {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this._validateMethod('get');
-            if (this.$state.get('VOID'))
+            if (this._getState('VOID'))
                 return [];
-            if ((_a = this.$state.get('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this.exceptColumns());
-            let sql = this._buildQueryStatement();
-            if (this.$state.get('RELATIONS_EXISTS'))
-                sql = this._queryRelationsExists();
+            if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
+                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());
             return yield this._execute({
                 sql,
                 type: 'GET'
@@ -1310,7 +1391,7 @@ class Model extends AbstractModel_1.AbstractModel {
     /**
      *
      * @override Method
-     * @return {promise<array>}
+     * @return {promise<array>} Array
     */
     findMany() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1318,15 +1399,14 @@ class Model extends AbstractModel_1.AbstractModel {
         });
     }
     /**
-     *
      * @override Method
      * @param {object?} paginationOptions by default page = 1 , limit = 15
      * @property {number} paginationOptions.limit
      * @property {number} paginationOptions.page
-     * @return {promise<Pagination>}
+     * @return {promise<Pagination>} Pagination
      */
     pagination(paginationOptions) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             this._validateMethod('pagination');
             let limit = 15;
@@ -1335,16 +1415,16 @@ class Model extends AbstractModel_1.AbstractModel {
                 limit = (paginationOptions === null || paginationOptions === void 0 ? void 0 : paginationOptions.limit) || limit;
                 page = (paginationOptions === null || paginationOptions === void 0 ? void 0 : paginationOptions.page) || page;
             }
-            if ((_a = this.$state.get('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this.exceptColumns());
+            if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
+                this.select(...yield this._exceptColumns());
             const offset = (page - 1) * limit;
-            this.$state.set('PER_PAGE', limit);
-            this.$state.set('PAGE', page);
+            this._setState('PER_PAGE', limit);
+            this._setState('PAGE', page);
             this.limit(limit);
             this.offset(offset);
-            let sql = this._buildQueryStatement();
-            if (this.$state.get('RELATIONS_EXISTS'))
-                sql = this._queryRelationsExists();
+            let sql = this._queryBuilder().select();
+            if (this._getState('RELATIONS_EXISTS'))
+                sql = String((_b = this.$relation) === null || _b === void 0 ? void 0 : _b.loadExists());
             return yield this._execute({
                 sql,
                 type: 'PAGINATION'
@@ -1357,7 +1437,7 @@ class Model extends AbstractModel_1.AbstractModel {
     * @param    {?object} paginationOptions by default page = 1 , limit = 15
     * @property {number}  paginationOptions.limit
     * @property {number}  paginationOptions.page
-    * @return   {promise<Pagination>}
+    * @return   {promise<Pagination>} Pagination
     */
     paginate(paginationOptions) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1365,40 +1445,35 @@ class Model extends AbstractModel_1.AbstractModel {
         });
     }
     /**
-     *
      * @override Method
      * @param {string} column
-     * @return {Promise<array>}
+     * @return {Promise<array>} Array
      */
     getGroupBy(column) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if ((_a = this.$state.get('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
-                this.select(...yield this.exceptColumns());
-            this.$state.set('GROUP_BY', `${this.$constants('GROUP_BY')} ${column}`);
-            this.$state.set('SELECT', [
-                `${this.$state.get('SELECT')},`,
+            if ((_a = this._getState('EXCEPTS')) === null || _a === void 0 ? void 0 : _a.length)
+                this.select(...yield this._exceptColumns());
+            this.selectRaw([
+                `\`${column}\`,`,
                 `${this.$constants('GROUP_CONCAT')}(id)`,
-                `${this.$constants('AS')} data`
+                `${this.$constants('AS')} \`data\``
             ].join(' '));
-            const sql = this._buildQueryStatement();
-            const results = yield this.queryStatement(sql);
+            this.groupBy(column);
+            const sql = this._queryBuilder().select();
+            const results = yield this._queryStatement(sql);
             let data = [];
             results.forEach((result) => {
                 var _a, _b;
                 const splits = (_b = (_a = result === null || result === void 0 ? void 0 : result.data) === null || _a === void 0 ? void 0 : _a.split(',')) !== null && _b !== void 0 ? _b : '0';
                 splits.forEach((split) => data = [...data, split]);
             });
-            const sqlChild = [
-                `${this.$constants('SELECT')}`,
-                `*`,
-                `${this.$constants('FROM')}`,
-                `${this.$state.get('TABLE_NAME')}`,
-                `${this.$constants('WHERE')} id`,
-                `${this.$constants('IN')}`,
-                `(${data.map((a) => `\'${a}\'`).join(',') || ['0']})`
-            ].join(' ');
-            const childData = yield this.queryStatement(sqlChild);
+            const sqlChild = new Model()
+                .copyModel(this)
+                .select('*')
+                .whereIn('id', data.map((a) => `\'${a}\'`))
+                .toString();
+            const childData = yield this._queryStatement(sqlChild);
             const child = yield this._executeGroup(childData);
             const resultData = results.map((result) => {
                 const id = result[column];
@@ -1408,12 +1483,37 @@ class Model extends AbstractModel_1.AbstractModel {
                     data: newData
                 });
             });
-            return this.resultHandler(resultData);
+            return this._resultHandler(resultData);
         });
     }
     /**
-     *
-     * update data in the database
+     * @override Method
+     * @param {object} data for insert
+     * @return {this} this
+     */
+    insert(data) {
+        if (!Object.keys(data).length)
+            throw new Error('This method must be required');
+        this._setState('DATA', data);
+        const query = this._queryInsertModel(data);
+        this._setState('INSERT', [
+            `${this.$constants('INSERT')}`,
+            `${this._getState('TABLE_NAME')}`,
+            `${query}`
+        ].join(' '));
+        this._setState('SAVE', 'INSERT');
+        return this;
+    }
+    /**
+     * @override Method
+     * @param {object} data for insert
+     * @return {this} this
+     */
+    create(data) {
+        return this.insert(data);
+    }
+    /**
+     * @override Method
      * @param {object} data
      * @param {array?} updateNotExists options for except update some records in your ${data}
      * @return {this} this
@@ -1432,99 +1532,96 @@ class Model extends AbstractModel_1.AbstractModel {
                 }
             }
         }
+        this._setState('DATA', data);
+        this.limit(1);
         const query = this._queryUpdateModel(data);
-        this.$state.set('UPDATE', [
+        this._setState('UPDATE', [
             `${this.$constants('UPDATE')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${query}`
         ].join(' '));
-        this.$state.set('SAVE', 'UPDATE');
+        this._setState('SAVE', 'UPDATE');
         return this;
     }
     /**
-     *
      * @override Method
      * @param {object} data
+     * @param {array?} updateNotExists options for except update some records in your ${data}
      * @return {this} this
      */
-    updateNotExists(data) {
+    updateMany(data, updateNotExists = []) {
         if (!Object.keys(data).length)
             throw new Error('This method must be required');
-        for (const column in data) {
-            const value = data[column];
-            data[column] = this._updateHandler(column, value);
+        if (updateNotExists.length) {
+            for (const c of updateNotExists) {
+                for (const column in data) {
+                    if (c !== column)
+                        continue;
+                    const value = data[column];
+                    data[column] = this._updateHandler(column, value);
+                    break;
+                }
+            }
         }
+        this._setState('DATA', data);
         const query = this._queryUpdateModel(data);
-        this.$state.set('UPDATE', [
+        this._setState('UPDATE', [
             `${this.$constants('UPDATE')}`,
-            `${this.$state.get('TABLE_NAME')}`,
-            `${query}`
-        ].join(' '));
-        this.$state.set('SAVE', 'UPDATE');
-        return this;
-    }
-    /**
-     *
-     * @override Method
-     * @param {object} data for insert
-     * @return {this} this
-     */
-    insert(data) {
-        if (!Object.keys(data).length)
-            throw new Error('This method must be required');
-        const query = this._queryInsertModel(data);
-        this.$state.set('INSERT', [
-            `${this.$constants('INSERT')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${query}`
         ].join(' '));
-        this.$state.set('SAVE', 'INSERT');
+        this._setState('SAVE', 'UPDATE');
         return this;
     }
     /**
-     *
      * @override Method
-     * @param {object} data for insert
+     * @param {object} data
      * @return {this} this
      */
-    create(data) {
+    updateNotExists(data) {
+        this.limit(1);
         if (!Object.keys(data).length)
             throw new Error('This method must be required');
-        const query = this._queryInsertModel(data);
-        this.$state.set('INSERT', [
-            `${this.$constants('INSERT')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+        for (const column in data) {
+            const value = data[column];
+            data[column] = this._updateHandler(column, value);
+        }
+        this._setState('DATA', data);
+        const query = this._queryUpdateModel(data);
+        this._setState('UPDATE', [
+            `${this.$constants('UPDATE')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${query}`
         ].join(' '));
-        this.$state.set('SAVE', 'INSERT');
+        this._setState('SAVE', 'UPDATE');
         return this;
     }
     /**
-     *
      * @override Method
      * @param {object} data for update or create
      * @return {this} this
      */
     updateOrCreate(data) {
+        this.limit(1);
         if (!Object.keys(data).length)
             throw new Error('This method must be required');
         const queryUpdate = this._queryUpdateModel(data);
         const queryInsert = this._queryInsertModel(data);
-        this.$state.set('INSERT', [
+        this._setState('DATA', data);
+        this._setState('INSERT', [
             `${this.$constants('INSERT')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${queryInsert}`
         ].join(' '));
-        this.$state.set('UPDATE', [
+        this._setState('UPDATE', [
             `${this.$constants('UPDATE')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${queryUpdate}`
         ].join(' '));
-        this.$state.set('SAVE', 'UPDATE_OR_INSERT');
+        this._setState('SAVE', 'UPDATE_OR_INSERT');
         return this;
     }
     /**
-     *
      * @override Method
      * @param {object} data for update or create
      * @return {this} this
@@ -1533,16 +1630,14 @@ class Model extends AbstractModel_1.AbstractModel {
         return this.updateOrCreate(data);
     }
     /**
-    *
-    * @override Method
-    * @param {object} data for update or create
-    * @return {this} this
-    */
+     * @override Method
+     * @param {object} data for update or create
+     * @return {this} this
+     */
     insertOrUpdate(data) {
         return this.updateOrCreate(data);
     }
     /**
-     *
      * @override Method
      * @param {object} data for update or create
      * @return {this} this
@@ -1551,7 +1646,6 @@ class Model extends AbstractModel_1.AbstractModel {
         return this.updateOrCreate(data);
     }
     /**
-     *
      * @override Method
      * @param {object} data for create
      * @return {this} this
@@ -1559,72 +1653,69 @@ class Model extends AbstractModel_1.AbstractModel {
     createOrSelect(data) {
         if (!Object.keys(data).length)
             throw new Error('This method must be required');
+        this._setState('DATA', data);
         const queryInsert = this._queryInsertModel(data);
-        this.$state.set('INSERT', [
+        this._setState('INSERT', [
             `${this.$constants('INSERT')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${queryInsert}`
         ].join(' '));
-        this.$state.set('SAVE', 'INSERT_OR_SELECT');
+        this._setState('SAVE', 'INSERT_OR_SELECT');
         return this;
     }
     /**
-    *
-    * @override Method
-    * @param {object} data for update or create
-    * @return {this} this
-    */
+     * @override Method
+     * @param {object} data for update or create
+     * @return {this} this
+     */
     insertOrSelect(data) {
         return this.createOrSelect(data);
     }
     /**
-     *
-     * insert multiple data into the database
      * @override Method
-     * @param {array<object>} data create multiple data
+     * @param {Record<string,any>[]} data create multiple data
      * @return {this} this this
      */
     createMultiple(data) {
+        this._setState('DATA', data);
         const query = this._queryInsertMultipleModel(data);
-        this.$state.set('INSERT', [
+        this._setState('INSERT', [
             `${this.$constants('INSERT')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${query}`
         ].join(' '));
-        this.$state.set('SAVE', 'INSERT_MULTIPLE');
+        this._setState('SAVE', 'INSERT_MULTIPLE');
         return this;
     }
     /**
      *
-     * insert muliple data into the database
      * @override Method
-     * @param {array<object>} data create multiple data
-     * @return {this} this this
+     * @param {Record<string,any>[]} data create multiple data
+     * @return {this} this
      */
     insertMultiple(data) {
         return this.createMultiple(data);
     }
     /**
-     *
-     * @param {object} data create not exists data
      * @override Method
-     * @return {this} this this
+     * @param {object} data create not exists data
+     * @return {this} this
      */
     createNotExists(data) {
         this._assertError(Array.isArray(data), 'Data must be an array. Only object are supported');
+        this._setState('DATA', data);
         const query = this._queryInsertModel(data);
-        this.$state.set('INSERT', [
+        this._setState('INSERT', [
             `${this.$constants('INSERT')}`,
-            `${this.$state.get('TABLE_NAME')}`,
+            `${this._getState('TABLE_NAME')}`,
             `${query}`
         ].join(' '));
-        this.$state.set('SAVE', 'INSERT_NOT_EXISTS');
+        this._setState('SAVE', 'INSERT_NOT_EXISTS');
         return this;
     }
     /**
-     *
-     * @param {object} data create not exists data
      * @override Method
+     * @param {object} data create not exists data
      * @return {this} this this
      */
     insertNotExists(data) {
@@ -1641,65 +1732,45 @@ class Model extends AbstractModel_1.AbstractModel {
                 `${this.$constants('SHOW')}`,
                 `${this.$constants('COLUMNS')}`,
                 `${this.$constants('FROM')}`,
-                `\`${this.$state.get('TABLE_NAME').replace(/\`/g, '')}\``
+                `\`${this._getState('TABLE_NAME').replace(/\`/g, '')}\``
             ].join(' ');
-            return yield this.queryStatement(sql);
+            return yield this._queryStatement(sql);
         });
     }
     getSchemaModel() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.$state.get('SCHEMA_TABLE');
-        });
-    }
-    getTableName() {
-        var _a;
-        return (_a = this.$state.get('TABLE_NAME')) === null || _a === void 0 ? void 0 : _a.replace(/`/g, '');
+        return this._getState('SCHEMA_TABLE');
     }
     /**
-     *
      * @override Method
      * @return {Promise<Record<string,any> | any[] | null | undefined>}
      */
     save() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._validateMethod('save');
             const attributes = this.$attributes;
             if (attributes != null) {
                 while (true) {
-                    if (this.$state.get('WHERE')) {
-                        const query = this._queryUpdateModel(attributes);
-                        this.$state.set('UPDATE', [
-                            `${this.$constants('UPDATE')}`,
-                            `${this.$state.get('TABLE_NAME')}`,
-                            `${query}`
-                        ].join(' '));
-                        this.$state.set('SAVE', 'UPDATE');
+                    if (this._getState('WHERE')) {
+                        this.update(attributes);
                         break;
                     }
-                    const query = this._queryInsertModel(attributes);
-                    this.$state.set('INSERT', [
-                        `${this.$constants('INSERT')}`,
-                        `${this.$state.get('TABLE_NAME')}`,
-                        `${query}`
-                    ].join(' '));
-                    this.$state.set('SAVE', 'INSERT');
+                    this.create(attributes);
                     break;
                 }
             }
-            switch (String(this.$state.get('SAVE'))) {
+            this._validateMethod('save');
+            switch (String(this._getState('SAVE'))) {
                 case 'INSERT': return yield this._insertModel();
                 case 'UPDATE': return yield this._updateModel();
                 case 'INSERT_MULTIPLE': return yield this._createMultipleModel();
                 case 'INSERT_NOT_EXISTS': return yield this._insertNotExistsModel();
                 case 'UPDATE_OR_INSERT': return yield this._updateOrInsertModel();
                 case 'INSERT_OR_SELECT': return yield this._insertOrSelectModel();
-                default: throw new Error(`Unknown this [${this.$state.get('SAVE')}]`);
+                default: throw new Error(`Unknown this [${this._getState('SAVE')}]`);
             }
         });
     }
     /**
      *
-     * fake data into to this table
      * @override Method
      * @param {number} rows number of rows
      * @return {promise<any>}
@@ -1712,11 +1783,11 @@ class Model extends AbstractModel_1.AbstractModel {
                 `${this.$constants('SHOW')}`,
                 `${this.$constants('FIELDS')}`,
                 `${this.$constants('FROM')}`,
-                `${this.$state.get('TABLE_NAME')}`
+                `${this._getState('TABLE_NAME')}`
             ].join(' ');
-            const fields = yield this.queryStatement(sql);
+            const fields = yield this._queryStatement(sql);
             for (let row = 0; row < rows; row++) {
-                this._assertError(this.$state.get('TABLE_NAME') === '' || this.$state.get('TABLE_NAME') == null, "Unknow this table");
+                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);
@@ -1727,17 +1798,17 @@ class Model extends AbstractModel_1.AbstractModel {
                 data = [...data, columnAndValue];
             }
             const query = this._queryInsertMultipleModel(data);
-            this.$state.set('INSERT', [
+            this._setState('INSERT', [
                 `${this.$constants('INSERT')}`,
-                `${this.$state.get('TABLE_NAME')}`,
+                `${this._getState('TABLE_NAME')}`,
                 `${query}`
             ].join(' '));
-            this.$state.set('SAVE', 'INSERT_MULTIPLE');
+            this._setState('SAVE', 'INSERT_MULTIPLE');
             return yield this.save();
         });
     }
     _valuePattern(value) {
-        switch (this.$state.get('PATTERN')) {
+        switch (this._getState('PATTERN')) {
             case this.$constants('PATTERN').snake_case: {
                 return value.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
             }
@@ -1748,93 +1819,24 @@ class Model extends AbstractModel_1.AbstractModel {
         }
     }
     _isPatternSnakeCase() {
-        return this.$state.get('PATTERN') === this.$constants('PATTERN').snake_case;
+        return this._getState('PATTERN') === this.$constants('PATTERN').snake_case;
     }
     _classToTableName(className, { singular = false } = {}) {
         if (className == null)
             className = this.constructor.name;
         const tb = className.replace(/([A-Z])/g, (str) => '_' + str.toLowerCase()).slice(1);
         if (singular)
-            return this._valuePattern(tb);
+            return pluralize_1.default.singular(this._valuePattern(tb));
         return pluralize_1.default.plural(this._valuePattern(tb));
     }
     _makeTableName() {
-        const tb = this._classToTableName();
-        this.$state.set('SELECT', `${this.$constants('SELECT')} *`);
-        this.$state.set('FROM', `${this.$constants('FROM')}`);
-        this.$state.set('TABLE_NAME', `\`${tb}\``);
+        const tableName = this._classToTableName();
+        this._setState('TABLE_NAME', `\`${tableName}\``);
         return this;
     }
-    _tableName() {
-        var _a;
-        return (_a = this.$state.get('TABLE_NAME')) === null || _a === void 0 ? void 0 : _a.replace(/`/g, '');
-    }
-    _valueInRelation(relationModel) {
-        var _a, _b, _c, _d;
-        this._assertError((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Promise, 'Nested Relation isn\'t supported Promise method');
-        this._assertError(!((relationModel === null || relationModel === void 0 ? void 0 : relationModel.query) instanceof Model), 'Callback function supported instance of Model only');
-        const relation = relationModel.relation;
-        const model = (_a = relationModel.model) === null || _a === void 0 ? void 0 : _a.name;
-        const oldVersion = relationModel.oldVersion;
-        const table = relationModel.freezeTable
-            ? relationModel.freezeTable
-            : (_b = relationModel.query) === null || _b === void 0 ? void 0 : _b._tableName();
-        let pivot = null;
-        const name = relationModel.name;
-        const as = relationModel.as;
-        this._assertError(!model || model == null, 'Not found model');
-        let localKey = relationModel.localKey
-            ? relationModel.localKey
-            : this.$state.get('PRIMARY_KEY');
-        let foreignKey = relationModel.foreignKey
-            ? relationModel.foreignKey
-            : this._valuePattern([
-                `${pluralize_1.default.singular(this.$state.get('TABLE_NAME').replace(/\`/g, ''))}`,
-                `${this.$state.get('PRIMARY_KEY')}`
-            ].join('_'));
-        const checkRelationIsBelongsTo = [
-            relationModel.localKey == null,
-            relationModel.foreignKey == null,
-            relation === this.$constants('RELATIONSHIP').belongsTo
-        ].every(r => r);
-        if (checkRelationIsBelongsTo) {
-            foreignKey = localKey;
-            localKey = this._valuePattern([
-                `${pluralize_1.default.singular(table !== null && table !== void 0 ? table : '')}`,
-                `${this.$state.get('PRIMARY_KEY')}`
-            ].join('_'));
-        }
-        const checkRelationIsBelongsToMany = [
-            relationModel.localKey == null,
-            relationModel.foreignKey == null,
-            relation === this.$constants('RELATIONSHIP').belongsToMany
-        ].every(r => r);
-        if (checkRelationIsBelongsToMany) {
-            localKey = this._valuePattern([
-                `${pluralize_1.default.singular(table !== null && table !== void 0 ? table : '')}`,
-                `${this.$state.get('PRIMARY_KEY')}`
-            ].join('_'));
-            foreignKey = 'id';
-            pivot = (_c = relationModel.pivot) !== null && _c !== void 0 ? _c : this._valuePattern([
-                pluralize_1.default.singular(this === null || this === void 0 ? void 0 : this._tableName()),
-                pluralize_1.default.singular((_d = relationModel.query) === null || _d === void 0 ? void 0 : _d._tableName())
-            ].sort().join('_'));
-        }
-        return {
-            name,
-            as,
-            relation,
-            table,
-            localKey,
-            foreignKey,
-            model,
-            pivot,
-            oldVersion
-        };
-    }
     _handleSoftDelete() {
-        if (this.$state.get('SOFT_DELETE')) {
-            const deletedAt = this._valuePattern(this.$state.get('SOFT_DELETE_FORMAT'));
+        if (this._getState('SOFT_DELETE')) {
+            const deletedAt = this._valuePattern(this._getState('SOFT_DELETE_FORMAT'));
             this.whereNull(deletedAt);
         }
         return this;
@@ -1843,56 +1845,17 @@ class Model extends AbstractModel_1.AbstractModel {
      *
      * generate sql statements
      * @override
-     * @return {string} string generated query string
-     */
-    _buildQueryStatement() {
-        let sql = [];
-        while (true) {
-            this._handleSoftDelete();
-            if (this.$state.get('INSERT')) {
-                sql = [
-                    this.$state.get('INSERT')
-                ];
-                break;
-            }
-            if (this.$state.get('UPDATE')) {
-                sql = [
-                    this.$state.get('UPDATE'),
-                    this.$state.get('WHERE'),
-                    this.$state.get('LIMIT'),
-                ];
-                break;
-            }
-            if (this.$state.get('DELETE')) {
-                sql = [
-                    this.$state.get('DELETE')
-                ];
-                break;
-            }
-            sql = [
-                this.$state.get('SELECT'),
-                this.$state.get('FROM'),
-                this.$state.get('TABLE_NAME'),
-                this.$state.get('JOIN'),
-                this.$state.get('WHERE'),
-                this.$state.get('GROUP_BY'),
-                this.$state.get('HAVING'),
-                this.$state.get('ORDER_BY'),
-                this.$state.get('LIMIT'),
-                this.$state.get('OFFSET')
-            ];
-            break;
-        }
-        const filterSql = sql.filter(data => data !== '' || data == null);
-        const query = filterSql.join(' ');
-        return query;
+     */
+    _queryBuilder() {
+        this._handleSoftDelete();
+        return this._buildQueryStatement();
     }
     _showOnly(data) {
         let result = [];
-        const hasNameRelation = this.$state.get('RELATIONS').map((w) => { var _a; return (_a = w.as) !== null && _a !== void 0 ? _a : w.name; });
+        const hasNameRelation = this._getState('RELATIONS').map((w) => { var _a; return (_a = w.as) !== null && _a !== void 0 ? _a : w.name; });
         data.forEach((d) => {
             let newData = {};
-            this.$state.get('ONLY').forEach((only) => {
+            this._getState('ONLY').forEach((only) => {
                 if (d.hasOwnProperty(only))
                     newData = Object.assign(Object.assign({}, newData), { [only]: d[only] });
             });
@@ -1904,313 +1867,133 @@ class Model extends AbstractModel_1.AbstractModel {
         });
         return result;
     }
-    _validateSchema(results) {
-        if (!results.length)
-            return;
-        const validateSchema = Boolean(this.$state.get('VALIDATE_SCHEMA'));
-        if (!validateSchema)
-            return;
-        const schemaTable = this.$state.get('SCHEMA_TABLE');
-        const schemaTableDefined = this.$state.get('VALIDATE_SCHEMA_DEFINED');
-        this._assertError(schemaTableDefined == null && schemaTable == null, "Can't validate schema withouted schema");
-        const schema = schemaTableDefined !== null && schemaTableDefined !== void 0 ? schemaTableDefined : Object.keys(schemaTable).reduce((acc, key) => {
-            acc[key] = schemaTable[key].valueType;
-            return acc;
-        }, {});
-        if (schema == null)
-            return;
-        const typeOf = (data) => Object.prototype.toString.apply(data).slice(8, -1).toLocaleLowerCase();
-        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]/;
-        const select = this.$state.get('SELECT');
-        const selectedAll = select.replace('SELECT', '').trim() === '*';
-        for (const result of results) {
-            const schemaKeys = Object.keys(schema);
-            const resultKeys = Object.keys(result);
-            if (schemaKeys.some(s => !resultKeys.includes(s)) && selectedAll) {
-                const columns = schemaKeys.filter(x => !resultKeys.includes(x));
-                this._assertError(`Not found this column "${columns.join(', ')}" in result`);
+    _validateSchema(data, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validateSchema = this._getState('VALIDATE_SCHEMA');
+            if (!validateSchema)
+                return;
+            const schemaTable = this._getState('SCHEMA_TABLE');
+            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`);
             }
-            for (const column in result) {
+            const schemaTableDefined = this._getState('VALIDATE_SCHEMA_DEFINED');
+            const schema = schemaTableDefined !== null && schemaTableDefined !== void 0 ? schemaTableDefined : Object.keys(schemaTable).reduce((acc, key) => {
+                acc[key] = schemaTable[key].valueType;
+                return acc;
+            }, {});
+            if (schema == null)
+                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];
-                if (s == null && selectedAll) {
-                    if (!schemaKeys.every(s => resultKeys.includes(s))) {
-                        this._assertError(`Not found this column "${column}" in result`);
+                const r = data[column];
+                const typeOf = (r) => this.$utils.typeOf(r);
+                if (typeOf(s) !== 'object') {
+                    if (r == null)
+                        continue;
+                    if (regexDate.test(r) || regexDateTime.test(r)) {
+                        if (typeOf(new Date(r)) === typeOf(new s()))
+                            continue;
+                        this._assertError(`This column "${column}" is must be type "${typeOf(new s())}"`);
                     }
+                    if (typeOf(r) === typeOf(new s()))
+                        continue;
+                    this._assertError(`This column "${column}" is must be type "${typeOf(new s())}"`);
                     continue;
                 }
-                if (s == null)
+                if (s.require && action === 'insert')
+                    this._assertError(r === '' || r == null, `This column "${column}" is required`);
+                if (r == null)
                     continue;
-                if (regexDate.test(result[column]) || regexDateTime.test(result[column])) {
-                    if (typeOf(new Date(result[column])) === typeOf(new s()))
-                        continue;
-                    this._assertError(`This column "${column}" is invalid schema field type`);
+                this._assertError((regexDate.test(r) || regexDateTime.test(r)) && typeOf(new Date(r)) !== typeOf(new s.type()) `This column "${column}" is must be type "${typeOf(new s.type())}"`);
+                this._assertError(typeOf(r) !== typeOf(new s.type()), `This column "${column}" is must be type "${typeOf(new s.type())}"`);
+                if (s.json) {
+                    try {
+                        JSON.parse(r);
+                    }
+                    catch (_) {
+                        this._assertError(`This column "${column}" is must be JSON`);
+                    }
+                }
+                if (s.length)
+                    this._assertError((`${r}`.length > s.length), `This column "${column}" is more than "${s.length}" length of characters`);
+                if (s.maxLength)
+                    this._assertError((`${r}`.length > s.maxLength), `This column "${column}" is more than "${s.maxLength}" length of characters`);
+                if (s.minLength)
+                    this._assertError((`${r}`.length < s.minLength), `This column "${column}" is less than "${s.minLength}" length of characters`);
+                if (s.max)
+                    this._assertError(r > s.max, `This column "${column}" is more than "${s.max}"`);
+                if (s.min)
+                    this._assertError(r < s.min, `This column "${column}" is less than "${s.min}"`);
+                if (s.enum && s.enum.length) {
+                    this._assertError(!s.enum.some((e) => e === r), `This column "${column}" is must be in ${s.enum.map((e) => `"${e}"`)}`);
+                }
+                if (s.match)
+                    this._assertError(!s.match.test(r), `This column "${column}" is not match a regular expression`);
+                if (s.fn)
+                    this._assertError(!(yield s.fn(r)), `This column "${column}" is not valid with function`);
+                if (s.unique && action === 'insert') {
+                    const exist = yield new Model()
+                        .copyModel(this, { select: true, where: true, limit: true })
+                        .where([column], r)
+                        .debug(this._getState('DEBUG'))
+                        .exists();
+                    this._assertError(exist, `This column "${column}" is duplicated`);
                 }
-                if (result[column] == null)
-                    continue;
-                if (typeOf(result[column]) === typeOf(new s()))
-                    continue;
-                this._assertError(`This column "${column}" is invalid schema field type`);
             }
-        }
-        return;
+            return;
+        });
     }
     _execute({ sql, type, message, options }) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            let result = yield this.queryStatement(sql);
-            this._validateSchema(result);
+            let result = yield this._queryStatement(sql);
             if (!result.length)
                 return this._returnEmpty(type, result, message, options);
-            const relations = this.$state.get('RELATIONS');
+            const relations = this._getState('RELATIONS');
             if (!relations.length)
                 return (yield this._returnResult(type, result)) || this._returnEmpty(type, result, message, options);
             for (const relation of relations) {
-                const relationIsBelongsToMany = relation.relation === this.$constants('RELATIONSHIP').belongsToMany;
-                if (relationIsBelongsToMany) {
-                    result = yield this._belongsToMany(result, relation);
-                    continue;
-                }
-                const dataFromRelation = yield this._relation(result, relation);
-                result = this._relationMapData(result, dataFromRelation, relation);
+                result = (_b = yield ((_a = this.$relation) === null || _a === void 0 ? void 0 : _a.load(result, relation))) !== null && _b !== void 0 ? _b : [];
             }
-            if (this.$state.get('HIDDEN').length)
+            if (this._getState('HIDDEN').length)
                 this._hiddenColumnModel(result);
             return (yield this._returnResult(type, result)) || this._returnEmpty(type, result, message, options);
         });
     }
     _executeGroup(dataParents, type = 'GET') {
-        var _a;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             if (!dataParents.length)
                 return this._returnEmpty(type, dataParents);
-            const relations = this.$state.get('RELATIONS');
+            const relations = this._getState('RELATIONS');
             if (relations.length) {
                 for (const relation of relations) {
-                    if (relation.relation === this.$constants('RELATIONSHIP').belongsToMany) {
-                        return this._belongsToMany(dataParents, relation);
-                    }
-                    let dataChilds = yield this._relation(dataParents, relation);
-                    dataParents = this._relationMapData(dataParents, dataChilds, relation);
+                    dataParents = (_b = yield ((_a = this.$relation) === null || _a === void 0 ? void 0 : _a.load(dataParents, relation))) !== null && _b !== void 0 ? _b : [];
                 }
             }
-            if ((_a = this.$state.get('HIDDEN')) === null || _a === void 0 ? void 0 : _a.length)
+            if ((_c = this._getState('HIDDEN')) === null || _c === void 0 ? void 0 : _c.length)
                 this._hiddenColumnModel(dataParents);
             const resultData = yield this._returnResult(type, dataParents);
             return resultData || this._returnEmpty(type, dataParents);
         });
     }
-    _relationMapData(dataParents, dataChilds, relations) {
-        const { name, as, relation, localKey, foreignKey } = this._valueInRelation(relations);
-        const keyRelation = as !== null && as !== void 0 ? as : name;
-        for (const dataParent of dataParents) {
-            const relationIsHasOneOrBelongsTo = [
-                this.$constants('RELATIONSHIP').hasOne,
-                this.$constants('RELATIONSHIP').belongsTo
-            ].some(r => r === relation);
-            dataParent[keyRelation] = [];
-            if (relationIsHasOneOrBelongsTo)
-                dataParent[keyRelation] = null;
-            if (!dataChilds.length)
-                continue;
-            for (const dataChild of dataChilds) {
-                if (dataChild[foreignKey] === dataParent[localKey]) {
-                    const relationIsHasOneOrBelongsTo = [
-                        this.$constants('RELATIONSHIP').hasOne,
-                        this.$constants('RELATIONSHIP').belongsTo
-                    ].some(r => r === relation);
-                    if (relationIsHasOneOrBelongsTo) {
-                        dataParent[keyRelation] = dataParent[keyRelation] || dataChild;
-                        continue;
-                    }
-                    if (dataParent[keyRelation] == null)
-                        dataParent[keyRelation] = [];
-                    dataParent[keyRelation].push(dataChild);
-                }
-            }
-        }
-        return dataParents;
-    }
-    _handleRelationsExists(relation) {
-        var _a;
-        this._assertError(!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length), `unknown [relation]`);
-        const { localKey, foreignKey } = this._valueInRelation(relation);
-        const query = relation.query;
-        this._assertError(query == null, `Unknown callback query in [Relation : '${relation.name}']`);
-        const clone = new Model().clone(query);
-        if (clone.$state.get('RELATIONS').length) {
-            for (const r of clone.$state.get('RELATIONS')) {
-                if (r.query == null)
-                    continue;
-                const sql = clone._handleRelationsExists(r);
-                clone.whereExists(sql);
-            }
-        }
-        const sql = clone
-            .bind(this.$pool.get())
-            .select(this.$state.get('PRIMARY_KEY'))
-            .whereReference(`\`${this._tableName()}\`.\`${localKey}\``, `\`${query._tableName()}\`.\`${foreignKey}\``)
-            .toString();
-        return sql;
-    }
-    _queryRelationsExists() {
-        var _a;
-        const relations = this.$state.get('RELATIONS');
-        for (const index in relations) {
-            const relation = relations[index];
-            if (!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length))
-                continue;
-            if (relation.exists == null)
-                continue;
-            const { localKey, foreignKey, pivot } = this._valueInRelation(relation);
-            const query = relation.query;
-            this._assertError(query == null, `Unknown callback query in [Relation : '${relation.name}']`);
-            let clone = new Model().clone(query);
-            if (clone.$state.get('RELATIONS').length) {
-                for (const r of clone.$state.get('RELATIONS')) {
-                    if (r.query == null)
-                        continue;
-                    const sql = clone._handleRelationsExists(r);
-                    clone.whereExists(sql);
-                }
-            }
-            if (relation.relation === this.$constants('RELATIONSHIP').belongsToMany) {
-                const thisPivot = new Model();
-                thisPivot.$state.set('TABLE_NAME', `\`${pivot}\``);
-                const sql = clone
-                    .bind(this.$pool.get())
-                    .whereReference(`\`${query._tableName()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${localKey}\``)
-                    .toString();
-                thisPivot.whereExists(sql);
-                const sqlPivot = thisPivot
-                    .bind(this.$pool.get())
-                    .whereReference(`\`${this._tableName()}\`.\`${foreignKey}\``, `\`${pivot}\`.\`${this._valuePattern([pluralize_1.default.singular(this._tableName()), foreignKey].join("_"))}\``)
-                    .toString();
-                this.whereExists(sqlPivot);
-                continue;
-            }
-            const sql = clone
-                .bind(this.$pool.get())
-                .select(this.$state.get('PRIMARY_KEY'))
-                .whereReference(`\`${this._tableName()}\`.\`${localKey}\``, `\`${query._tableName()}\`.\`${foreignKey}\``)
-                .toString();
-            this.whereExists(sql);
-        }
-        const sql = this._buildQueryStatement();
-        return sql;
-    }
-    _relation(parents, relation) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!((_a = Object.keys(relation)) === null || _a === void 0 ? void 0 : _a.length))
-                return [];
-            const { localKey, foreignKey } = this._valueInRelation(relation);
-            const localKeyId = parents.map((parent) => {
-                const data = parent[localKey];
-                if (!parent.hasOwnProperty(localKey)) {
-                    this._assertError(data == null, `Unknown relationship without primary or foreign key in Relation : [${relation === null || relation === void 0 ? void 0 : relation.name}]`);
-                }
-                return data;
-            }).filter((data) => data != null);
-            const dataPerentId = Array.from(new Set(localKeyId)) || [];
-            if (!dataPerentId.length && this.$state.get('RELATIONS_EXISTS'))
-                return [];
-            const query = yield relation.query;
-            this._assertError(query == null, `Unknown callback query in [Relation : ${relation.name}]`);
-            const dataFromRelation = yield query
-                .bind(this.$pool.get())
-                .whereIn(foreignKey, dataPerentId)
-                .debug(this.$state.get('DEBUG'))
-                .when(relation.trashed, (query) => query.whereTrashed())
-                .when(relation.all, (query) => query.disableSoftDelete())
-                .get();
-            return dataFromRelation;
-        });
-    }
-    _belongsToMany(dataFromParent, relation) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const { name, foreignKey, localKey, pivot, oldVersion } = this._valueInRelation(relation);
-            const pivotTable = String(((_a = relation.pivot) !== null && _a !== void 0 ? _a : pivot));
-            const localKeyId = dataFromParent.map((parent) => {
-                const data = parent[foreignKey];
-                if (!parent.hasOwnProperty(foreignKey)) {
-                    this._assertError(data == null, `Unknown relationship without primary or foreign key in Relation : [${relation === null || relation === void 0 ? void 0 : relation.name}]`);
-                }
-                return data;
-            }).filter((data) => data != null);
-            const dataPerentId = Array.from(new Set(localKeyId));
-            if (!dataPerentId.length && this.$state.get('RELATIONS_EXISTS'))
-                return [];
-            const modelOther = new relation.model();
-            const other = this._classToTableName(modelOther.constructor.name, { singular: true });
-            const otherlocalKey = 'id';
-            const otherforeignKey = this._valuePattern(`${other}Id`);
-            const localKeyPivotTable = this._valuePattern([pluralize_1.default.singular(this._tableName()), foreignKey].join("_"));
-            const sql = new Model().copyModel(modelOther)
-                .whereReference(`\`${modelOther._tableName()}\`.\`${foreignKey}\``, `\`${pivotTable}\`.\`${localKey}\``)
-                .toString();
-            const queryChildModel = new Model();
-            queryChildModel.$state.set('TABLE_NAME', `\`${pivotTable}\``);
-            const sqldataChilds = queryChildModel
-                .whereIn(localKeyPivotTable, dataPerentId)
-                .when(relation.exists, (query) => query.whereExists(sql))
-                .when(relation.trashed, (query) => query.whereTrashed())
-                .when(relation.all, (query) => query.disableSoftDelete())
-                .toString();
-            const dataChilds = yield this.queryStatement(sqldataChilds);
-            const otherId = dataChilds.map((sub) => sub[otherforeignKey]).filter((data) => data != null);
-            const otherArrId = Array.from(new Set(otherId)) || [];
-            const otherdataChilds = yield this.queryStatement(modelOther
-                .whereIn(otherlocalKey, otherArrId)
-                .debug(this.$state.get('DEBUG'))
-                .when(relation.trashed, (query) => query.disableSoftDelete())
-                .toString());
-            if (oldVersion) {
-                dataChilds.forEach((sub) => {
-                    otherdataChilds.forEach((otherSub) => {
-                        if (otherSub[otherlocalKey] === sub[otherforeignKey]) {
-                            sub[other] = otherSub;
-                        }
-                    });
-                });
-                dataFromParent.forEach((dataPerent) => {
-                    if (dataPerent[name] == null)
-                        dataPerent[name] = [];
-                    dataChilds.forEach((sub) => {
-                        if (sub[localKeyPivotTable] === dataPerent[foreignKey]) {
-                            dataPerent[name].push(sub);
-                        }
-                    });
-                });
-                if (this.$state.get('HIDDEN').length)
-                    this._hiddenColumnModel(dataFromParent);
-                return dataFromParent;
-            }
-            dataFromParent.forEach((dataPerent) => {
-                if (dataPerent[name] == null)
-                    dataPerent[name] = [];
-                dataChilds.forEach((sub) => {
-                    if (sub[localKeyPivotTable] === dataPerent[foreignKey]) {
-                        const data = otherdataChilds.find(u => u[foreignKey] === sub[localKey]);
-                        if (data != null) {
-                            data.pivot = Object.assign({}, sub);
-                            dataPerent[name].push(data);
-                        }
-                    }
-                });
-            });
-            if (this.$state.get('HIDDEN').length)
-                this._hiddenColumnModel(dataFromParent);
-            return dataFromParent;
-        });
-    }
     _pagination(data) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const currentPage = +(this.$state.get('PAGE'));
-            const limit = Number(this.$state.get('PER_PAGE'));
-            this._assertError(limit < 1, "minimun less 1 of limit");
-            const total = yield new Model().copyModel(this, { where: true }).count('*');
+            const currentPage = +(this._getState('PAGE'));
+            const limit = Number(this._getState('PER_PAGE'));
+            this._assertError(limit < 1, "This pagination needed limit minimun less 1 for limit");
+            const total = yield new Model()
+                .copyModel(this, { where: true, select: true })
+                .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
+                .count();
             let lastPage = Math.ceil(total / limit) || 0;
             lastPage = lastPage > 1 ? lastPage : 1;
             const nextPage = currentPage + 1;
@@ -2226,12 +2009,12 @@ class Model extends AbstractModel_1.AbstractModel {
                 prevPage,
             };
             if (this._isPatternSnakeCase()) {
-                return this.$utils.snakeCase(this.resultHandler({
+                return this.$utils.snakeCase(this._resultHandler({
                     meta,
                     data
                 }));
             }
-            return this.resultHandler({
+            return this._resultHandler({
                 meta,
                 data
             });
@@ -2266,9 +2049,9 @@ class Model extends AbstractModel_1.AbstractModel {
                     emptyData = {
                         meta: {
                             total: 0,
-                            limit: Number(this.$state.get('PER_PAGE')),
+                            limit: Number(this._getState('PER_PAGE')),
                             totalPage: 0,
-                            currentPage: Number(this.$state.get('PAGE')),
+                            currentPage: Number(this._getState('PAGE')),
                             lastPage: 0,
                             nextPage: 0,
                             prevPage: 0
@@ -2277,24 +2060,22 @@ class Model extends AbstractModel_1.AbstractModel {
                     };
                     break;
                 }
-                default: {
-                    throw new Error('Missing method first get or pagination');
-                }
+                default: this._assertError('Missing method first get or pagination');
             }
             if (this._isPatternSnakeCase()) {
-                const empty = this.$utils.snakeCase(this.resultHandler(emptyData));
-                yield this.$utils.hookHandle(this.$state.get('HOOKS'), empty);
+                const empty = this.$utils.snakeCase(this._resultHandler(emptyData));
+                yield this.$utils.hookHandle(this._getState('HOOKS'), empty);
                 return empty;
             }
-            const empty = this.resultHandler(emptyData);
-            yield this.$utils.hookHandle(this.$state.get('HOOKS'), empty);
+            const empty = this._resultHandler(emptyData);
+            yield this.$utils.hookHandle(this._getState('HOOKS'), empty);
             return empty;
         });
     }
     _returnResult(type, data) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const registry = this.$state.get('REGISTRY');
+            const registry = this._getState('REGISTRY');
             if (((_a = Object.keys(registry)) === null || _a === void 0 ? void 0 : _a.length) && registry != null) {
                 for (const d of data) {
                     for (const name in registry) {
@@ -2302,14 +2083,15 @@ class Model extends AbstractModel_1.AbstractModel {
                     }
                 }
             }
-            const functionRelation = this.$state.get('FUNCTION_RELATION');
+            const functionRelation = this._getState('FUNCTION_RELATION');
             if (functionRelation) {
                 for (const d of data) {
-                    for (const r of this.$state.get('RELATION')) {
+                    for (const r of this._getState('RELATION')) {
                         d[`$${r.name}`] = (cb) => __awaiter(this, void 0, void 0, function* () {
+                            var _f, _g;
                             const query = cb ? cb(new r.model()) : new r.model();
                             r.query = query;
-                            const dataFromRelation = yield this._relation([d], r);
+                            const dataFromRelation = (_g = yield ((_f = this.$relation) === null || _f === void 0 ? void 0 : _f.load([d], r))) !== null && _g !== void 0 ? _g : [];
                             const relationIsHasOneOrBelongsTo = [
                                 this.$constants('RELATIONSHIP').hasOne,
                                 this.$constants('RELATIONSHIP').belongsTo
@@ -2321,54 +2103,54 @@ class Model extends AbstractModel_1.AbstractModel {
                     }
                 }
             }
-            if ((_b = this.$state.get('ONLY')) === null || _b === void 0 ? void 0 : _b.length)
+            if ((_b = this._getState('ONLY')) === null || _b === void 0 ? void 0 : _b.length)
                 data = this._showOnly(data);
             let result = null;
             switch (type) {
                 case 'FIRST': {
-                    if (this.$state.get('PLUCK')) {
-                        const pluck = this.$state.get('PLUCK');
+                    if (this._getState('PLUCK')) {
+                        const pluck = this._getState('PLUCK');
                         const newData = data.shift();
                         const checkProperty = newData.hasOwnProperty(pluck);
                         this._assertError(!checkProperty, `Can't find property '${pluck}' of result`);
-                        result = this.resultHandler(newData[pluck]);
+                        result = this._resultHandler(newData[pluck]);
                         break;
                     }
-                    result = this.resultHandler((_c = data.shift()) !== null && _c !== void 0 ? _c : null);
+                    result = this._resultHandler((_c = data.shift()) !== null && _c !== void 0 ? _c : null);
                     break;
                 }
                 case 'FIRST_OR_ERROR': {
-                    if (this.$state.get('PLUCK')) {
-                        const pluck = this.$state.get('PLUCK');
+                    if (this._getState('PLUCK')) {
+                        const pluck = this._getState('PLUCK');
                         const newData = data.shift();
                         const checkProperty = newData.hasOwnProperty(pluck);
                         this._assertError(!checkProperty, `Can't find property '${pluck}' of result`);
-                        result = (_d = this.resultHandler(newData[pluck])) !== null && _d !== void 0 ? _d : null;
+                        result = (_d = this._resultHandler(newData[pluck])) !== null && _d !== void 0 ? _d : null;
                         break;
                     }
-                    result = this.resultHandler((_e = data.shift()) !== null && _e !== void 0 ? _e : null);
+                    result = this._resultHandler((_e = data.shift()) !== null && _e !== void 0 ? _e : null);
                     break;
                 }
                 case 'GET': {
-                    if (this.$state.get('CHUNK')) {
+                    if (this._getState('CHUNK')) {
                         const r = data.reduce((resultArray, item, index) => {
-                            const chunkIndex = Math.floor(index / this.$state.get('CHUNK'));
+                            const chunkIndex = Math.floor(index / this._getState('CHUNK'));
                             if (!resultArray[chunkIndex])
                                 resultArray[chunkIndex] = [];
                             resultArray[chunkIndex].push(item);
                             return resultArray;
                         }, []);
-                        result = this.resultHandler(r);
+                        result = this._resultHandler(r);
                         break;
                     }
-                    if (this.$state.get('PLUCK')) {
-                        const pluck = this.$state.get('PLUCK');
+                    if (this._getState('PLUCK')) {
+                        const pluck = this._getState('PLUCK');
                         const newData = data.map((d) => d[pluck]);
                         this._assertError(newData.every((d) => d == null), `Can't find property '${pluck}' of result`);
-                        result = this.resultHandler(newData);
+                        result = this._resultHandler(newData);
                         break;
                     }
-                    result = this.resultHandler(data);
+                    result = this._resultHandler(data);
                     break;
                 }
                 case 'PAGINATION': {
@@ -2379,12 +2161,12 @@ class Model extends AbstractModel_1.AbstractModel {
                     throw new Error('Missing method first get or pagination');
                 }
             }
-            yield this.$utils.hookHandle(this.$state.get('HOOKS'), result);
+            yield this.$utils.hookHandle(this._getState('HOOKS'), result);
             return result;
         });
     }
     _hiddenColumnModel(data) {
-        const hiddens = this.$state.get('HIDDEN');
+        const hiddens = this._getState('HIDDEN');
         for (const hidden of hiddens) {
             for (const objColumn of data) {
                 delete objColumn[hidden];
@@ -2396,11 +2178,11 @@ class Model extends AbstractModel_1.AbstractModel {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this._assertError(!Array.isArray(dataId), `this ${dataId} is not an array`);
-            const relation = (_a = this.$state.get('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
+            const relation = (_a = this._getState('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
             this._assertError(!relation, `unknown name relation ['${name}'] in model`);
             const thisTable = this.$utils.columnRelation(this.constructor.name);
             const relationTable = this._classToTableName(relation.model.name, { singular: true });
-            const result = this.$state.get('RESULT');
+            const result = this._getState('RESULT');
             try {
                 const pivotTable = `${thisTable}_${relationTable}`;
                 const success = yield new DB_1.DB().table(pivotTable).createMultiple(dataId.map((id) => {
@@ -2429,11 +2211,11 @@ class Model extends AbstractModel_1.AbstractModel {
     _detach(name, dataId) {
         return __awaiter(this, void 0, void 0, function* () {
             this._assertError(!Array.isArray(dataId), `this ${dataId} is not an array`);
-            const relation = this.$state.get('RELATION').find((data) => data.name === name);
+            const relation = this._getState('RELATION').find((data) => data.name === name);
             this._assertError(!relation, `unknown name relation [${name}] in model`);
             const thisTable = this.$utils.columnRelation(this.constructor.name);
             const relationTable = this._classToTableName(relation.model.name, { singular: true });
-            const result = this.$state.get('RESULT');
+            const result = this._getState('RESULT');
             try {
                 const pivotTable = `${thisTable}_${relationTable}`;
                 for (const id of dataId) {
@@ -2466,8 +2248,9 @@ class Model extends AbstractModel_1.AbstractModel {
         });
     }
     _queryUpdateModel(objects) {
-        if (this.$state.get('TIMESTAMP')) {
-            const updatedAt = this._valuePattern(this.$state.get('TIMESTAMP_FORMAT').UPDATED_AT);
+        this.$utils.covertDataToDateIfDate(objects);
+        if (this._getState('TIMESTAMP')) {
+            const updatedAt = this._valuePattern(this._getState('TIMESTAMP_FORMAT').UPDATED_AT);
             objects = Object.assign(Object.assign({}, objects), { [updatedAt]: this.$utils.timestamp() });
         }
         const keyValue = Object.entries(objects).map(([column, value]) => {
@@ -2481,21 +2264,22 @@ class Model extends AbstractModel_1.AbstractModel {
         });
         return `${this.$constants('SET')} ${keyValue.join(', ')}`;
     }
-    _queryInsertModel(objects) {
-        const hasTimestamp = Boolean(this.$state.get('TIMESTAMP'));
+    _queryInsertModel(data) {
+        this.$utils.covertDataToDateIfDate(data);
+        const hasTimestamp = Boolean(this._getState('TIMESTAMP'));
         if (hasTimestamp) {
-            const format = this.$state.get('TIMESTAMP_FORMAT');
+            const format = this._getState('TIMESTAMP_FORMAT');
             const createdAt = this._valuePattern(String(format === null || format === void 0 ? void 0 : format.CREATED_AT));
             const updatedAt = this._valuePattern(String(format === null || format === void 0 ? void 0 : format.UPDATED_AT));
-            objects = Object.assign(Object.assign({}, objects), { [createdAt]: this.$utils.timestamp(), [updatedAt]: this.$utils.timestamp() });
+            data = Object.assign({ [createdAt]: this.$utils.timestamp(), [updatedAt]: this.$utils.timestamp() }, data);
         }
-        const hasUUID = objects.hasOwnProperty(this.$state.get('UUID_FORMAT'));
-        if (this.$state.get('UUID') && !hasUUID) {
-            const uuidFormat = this.$state.get('UUID_FORMAT');
-            objects = Object.assign(Object.assign({}, objects), { [uuidFormat]: this.$utils.generateUUID() });
+        const hasUUID = data.hasOwnProperty(this._getState('UUID_FORMAT'));
+        if (this._getState('UUID') && !hasUUID) {
+            const uuidFormat = this._getState('UUID_FORMAT');
+            data = Object.assign({ [uuidFormat]: this.$utils.generateUUID() }, data);
         }
-        const columns = Object.keys(objects).map((column) => `\`${column}\``);
-        const values = Object.values(objects).map((value) => {
+        const columns = Object.keys(data).map((column) => `\`${column}\``);
+        const values = Object.values(data).map((value) => {
             if (typeof value === 'string' && !(value.includes(this.$constants('RAW'))))
                 value = value === null || value === void 0 ? void 0 : value.replace(/'/g, '');
             return `${value == null || value === 'NULL'
@@ -2504,20 +2288,22 @@ class Model extends AbstractModel_1.AbstractModel {
                     ? `${this.$utils.covertBooleanToNumber(value)}`.replace(this.$constants('RAW'), '')
                     : `'${this.$utils.covertBooleanToNumber(value)}'`}`;
         });
-        return [
+        const sql = [
             `(${columns.join(', ')})`,
             `${this.$constants('VALUES')}`,
             `(${values.join(', ')})`,
         ].join(' ');
+        return sql;
     }
     _queryInsertMultipleModel(data) {
         var _a;
         let values = [];
         let columns = Object.keys((_a = [...data]) === null || _a === void 0 ? void 0 : _a.shift()).map((column) => `\`${column}\``);
         for (let objects of data) {
-            const hasTimestamp = this.$state.get('TIMESTAMP');
+            this.$utils.covertDataToDateIfDate(data);
+            const hasTimestamp = this._getState('TIMESTAMP');
             if (hasTimestamp) {
-                const format = this.$state.get('TIMESTAMP_FORMAT');
+                const format = this._getState('TIMESTAMP_FORMAT');
                 const createdAt = this._valuePattern(format.CREATED_AT);
                 const updatedAt = this._valuePattern(format.UPDATED_AT);
                 objects = Object.assign(Object.assign({}, objects), { [createdAt]: this.$utils.timestamp(), [updatedAt]: this.$utils.timestamp() });
@@ -2527,9 +2313,9 @@ class Model extends AbstractModel_1.AbstractModel {
                     `\`${updatedAt}\``
                 ];
             }
-            const hasUUID = objects.hasOwnProperty(this.$state.get('UUID_FORMAT'));
-            if (this.$state.get('UUID') && !hasUUID) {
-                const uuidFormat = this.$state.get('UUID_FORMAT');
+            const hasUUID = objects.hasOwnProperty(this._getState('UUID_FORMAT'));
+            if (this._getState('UUID') && !hasUUID) {
+                const uuidFormat = this._getState('UUID_FORMAT');
                 objects = Object.assign(Object.assign({}, objects), { [uuidFormat]: this.$utils.generateUUID() });
                 columns = [
                     ...columns,
@@ -2558,137 +2344,202 @@ class Model extends AbstractModel_1.AbstractModel {
     }
     _insertNotExistsModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!this.$state.get('WHERE'), "Can't insert [insertNotExists] without where condition");
-            const clone = new Model().copyModel(this, { where: true }).bind(this.$pool.get());
-            const check = (yield clone.exists()) || false;
+            this._assertError(!this._getState('WHERE'), "This method 'createNotExists' is require to use 'where'");
+            const check = (yield new Model()
+                .copyModel(this, { where: true, select: true, limit: true })
+                .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
+                .exists()) || false;
             if (check)
-                return this.resultHandler(null);
-            const [result, id] = yield this.actionStatement({
-                sql: this.$state.get('INSERT'),
+                return this._resultHandler(null);
+            yield this._validateSchema(this._getState('DATA'), 'insert');
+            const [result, id] = yield this._actionStatement({
+                sql: this._queryBuilder().insert(),
                 returnId: true
             });
             if (!result)
-                return this.resultHandler(null);
-            return yield new Model().copyModel(this).bind(this.$pool.get()).where('id', id).first();
+                return this._resultHandler(null);
+            const resultData = yield new Model()
+                .copyModel(this, { select: true })
+                .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
+                .where('id', id)
+                .first();
+            return this._resultHandler(resultData);
         });
     }
     _insertModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            const [result, id] = yield this.actionStatement({
-                sql: this.$state.get('INSERT'),
+            yield this._validateSchema(this._getState('DATA'), 'insert');
+            const [result, id] = yield this._actionStatement({
+                sql: this._queryBuilder().insert(),
                 returnId: true
             });
-            if (this.$state.get('VOID'))
-                return this.resultHandler(undefined);
+            if (this._getState('VOID'))
+                return this._resultHandler(undefined);
             if (!result)
-                return this.resultHandler(null);
-            const resultData = yield new Model().copyModel(this)
+                return this._resultHandler(null);
+            const resultData = yield new Model()
+                .copyModel(this, { select: true })
                 .where('id', id)
                 .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
                 .first();
-            return this.resultHandler(resultData);
+            this._observer(resultData, 'created');
+            return this._resultHandler(resultData);
         });
     }
     _createMultipleModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            const [result, id] = yield this.actionStatement({
-                sql: this.$state.get('INSERT'),
+            for (const data of this._getState('DATA')) {
+                yield this._validateSchema(data, 'insert');
+            }
+            const [result, id] = yield this._actionStatement({
+                sql: this._queryBuilder().insert(),
                 returnId: true
             });
-            if (this.$state.get('VOID'))
-                return this.resultHandler(undefined);
+            if (this._getState('VOID'))
+                return this._resultHandler(undefined);
             if (!result)
-                return this.resultHandler(null);
+                return this._resultHandler(null);
             const arrayId = [...Array(result)].map((_, i) => i + id);
-            const data = new Model().copyModel(this).bind(this.$pool.get()).whereIn('id', arrayId).get();
+            const data = yield new Model()
+                .copyModel(this, { select: true, limit: true })
+                .bind(this.$pool.get())
+                .whereIn('id', arrayId)
+                .debug(this._getState('DEBUG'))
+                .get();
             const resultData = data || [];
-            return this.resultHandler(resultData);
+            this._observer(resultData, 'created');
+            return this._resultHandler(resultData);
         });
     }
     _updateOrInsertModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!this.$state.get('WHERE'), "Can not update or insert [updateOrInsert] without where condition");
-            const clone = new Model().copyModel(this, { where: true }).bind(this.$pool.get());
-            const check = (yield clone.exists()) || false;
+            this._assertError(!this._getState('WHERE'), "This method 'createOrUpdate' is require to use 'where'");
+            const check = (yield new Model()
+                .copyModel(this, { select: true, where: true, limit: true })
+                .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
+                .exists()) || false;
             switch (check) {
                 case false: {
-                    const [result, id] = yield this.actionStatement({
-                        sql: this.$state.get('INSERT'),
+                    yield this._validateSchema(this._getState('DATA'), 'insert');
+                    const [result, id] = yield this._actionStatement({
+                        sql: this._queryBuilder().insert(),
                         returnId: true
                     });
-                    if (this.$state.get('VOID') || !result)
-                        return this.resultHandler(undefined);
-                    const data = yield new Model().copyModel(this).bind(this.$pool.get()).where('id', id).first();
-                    const resultData = data == null
-                        ? null
-                        : Object.assign(Object.assign({}, data), { $action: 'insert' });
-                    return this.resultHandler(resultData);
+                    if (this._getState('VOID') || !result)
+                        return this._resultHandler(undefined);
+                    const data = yield new Model()
+                        .copyModel(this, { select: true })
+                        .bind(this.$pool.get())
+                        .where('id', id)
+                        .debug(this._getState('DEBUG'))
+                        .first();
+                    const resultData = data == null ? null : Object.assign(Object.assign({}, data), { $action: 'insert' });
+                    const r = this._resultHandler(resultData);
+                    this._observer(r, 'created');
+                    return r;
                 }
                 case true: {
-                    const result = yield this.actionStatement({
-                        sql: new Model().copyModel(this, { update: true, where: true }).toString()
+                    yield this._validateSchema(this._getState('DATA'), 'update');
+                    const result = yield this._actionStatement({
+                        sql: this._queryBuilder().update()
                     });
-                    if (this.$state.get('VOID') || !result)
-                        return this.resultHandler(undefined);
-                    const data = yield new Model().copyModel(this, { where: true }).bind(this.$pool.get()).get();
+                    if (this._getState('VOID') || !result)
+                        return this._resultHandler(undefined);
+                    const data = yield new Model()
+                        .copyModel(this, { where: true, select: true, limit: true })
+                        .bind(this.$pool.get())
+                        .debug(this._getState('DEBUG'))
+                        .get();
                     if ((data === null || data === void 0 ? void 0 : data.length) > 1) {
                         for (const v of data)
                             v.$action = 'update';
-                        return this.resultHandler(data || []);
+                        const r = this._resultHandler(data);
+                        this._observer(r, 'updated');
+                        return r;
                     }
                     const resultData = Object.assign(Object.assign({}, data === null || data === void 0 ? void 0 : data.shift()), { $action: 'update' }) || null;
-                    return this.resultHandler(resultData);
+                    const r = this._resultHandler(resultData);
+                    this._observer(r, 'updated');
+                    return r;
                 }
             }
         });
     }
     _insertOrSelectModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!this.$state.get('WHERE'), "Can not create or select [createOrSelect] without where condition");
-            const clone = new Model().copyModel(this, { where: true }).bind(this.$pool.get());
-            const check = (yield clone.exists()) || false;
+            this._assertError(!this._getState('WHERE'), "This method 'createOrSelect' is require to use 'where'");
+            const check = (yield new Model()
+                .copyModel(this, { select: true, where: true, limit: true })
+                .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
+                .exists()) || false;
             switch (check) {
                 case false: {
-                    const [result, id] = yield this.actionStatement({
-                        sql: String(this.$state.get('INSERT')),
+                    yield this._validateSchema(this._getState('DATA'), 'insert');
+                    const [result, id] = yield this._actionStatement({
+                        sql: this._queryBuilder().insert(),
                         returnId: true
                     });
-                    if (this.$state.get('VOID') || !result)
-                        return this.resultHandler(undefined);
-                    const data = yield new Model().copyModel(this).bind(this.$pool.get()).where('id', id).first();
+                    if (this._getState('VOID') || !result)
+                        return this._resultHandler(undefined);
+                    const data = yield new Model()
+                        .copyModel(this, { select: true })
+                        .bind(this.$pool.get())
+                        .where('id', id)
+                        .debug(this._getState('DEBUG'))
+                        .first();
                     const resultData = data == null
                         ? null
                         : Object.assign(Object.assign({}, data), { $action: 'insert' });
-                    return this.resultHandler(resultData);
+                    const r = this._resultHandler(resultData);
+                    this._observer(r, 'created');
+                    return r;
                 }
                 case true: {
-                    if (this.$state.get('VOID'))
-                        return this.resultHandler(undefined);
-                    const data = yield new Model().copyModel(this, { where: true }).bind(this.$pool.get()).get();
+                    if (this._getState('VOID'))
+                        return this._resultHandler(undefined);
+                    const data = yield new Model()
+                        .copyModel(this, { select: true, where: true, limit: true })
+                        .bind(this.$pool.get())
+                        .debug(this._getState('DEBUG'))
+                        .get();
                     if ((data === null || data === void 0 ? void 0 : data.length) > 1) {
                         for (const v of data)
                             v.$action = 'select';
-                        return this.resultHandler(data || []);
+                        return data;
                     }
                     const resultData = Object.assign(Object.assign({}, data === null || data === void 0 ? void 0 : data.shift()), { $action: 'select' }) || null;
-                    return this.resultHandler(resultData);
+                    return this._resultHandler(resultData);
                 }
             }
         });
     }
     _updateModel() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._assertError(!String(this.$state.get('WHERE')), "can not update [ update ] without where condition");
-            const sql = this._buildQueryStatement();
-            const result = yield this.actionStatement({ sql });
-            if (this.$state.get('VOID') || !result || result == null)
-                return this.resultHandler(undefined);
-            const data = yield new Model().copyModel(this, { where: true }).bind(this.$pool.get()).get();
+            this._assertError(!String(this._getState('WHERE')), "This method 'update' is require to use 'where'");
+            yield this._validateSchema(this._getState('DATA'), 'update');
+            const sql = this._queryBuilder().update();
+            const result = yield this._actionStatement({ sql });
+            if (this._getState('VOID') || !result || result == null)
+                return this._resultHandler(undefined);
+            const data = yield new Model()
+                .copyModel(this, { where: true, select: true, limit: true, orderBy: true })
+                .bind(this.$pool.get())
+                .debug(this._getState('DEBUG'))
+                .get();
             if ((data === null || data === void 0 ? void 0 : data.length) > 1) {
-                return this.resultHandler(data || []);
+                const r = this._resultHandler(data);
+                this._observer(r, 'updated');
+                return r;
             }
             const resultData = (data === null || data === void 0 ? void 0 : data.shift()) || null;
-            return this.resultHandler(resultData);
+            const r = this._resultHandler(resultData);
+            this._observer(r, 'updated');
+            return r;
         });
     }
     _assertError(condition = true, message = 'error') {
@@ -2699,38 +2550,15 @@ class Model extends AbstractModel_1.AbstractModel {
             throw new Error(message);
         return;
     }
-    _functionRelationName() {
-        const functionName = [...this.$logger.get()][this.$logger.get().length - 2];
-        return functionName.replace(/([A-Z])/g, (str) => `_${str.toLowerCase()}`);
-    }
-    _handleRelations(nameRelations) {
-        return nameRelations.map((name) => {
-            var _a, _b, _c;
-            const relation = (_a = this.$state.get('RELATION')) === null || _a === void 0 ? void 0 : _a.find((data) => data.name === name);
-            this._assertError(relation == null, `This Relation "${name}" not be register in Model "${(_b = this.constructor) === null || _b === void 0 ? void 0 : _b.name}"`);
-            const relationHasExists = (_c = Object.values(this.$constants('RELATIONSHIP'))) === null || _c === void 0 ? void 0 : _c.includes(relation.relation);
-            this._assertError(!relationHasExists, `Unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
-            if (relation.query == null)
-                relation.query = new relation.model();
-            return relation;
-        });
-    }
-    _handleRelationsQuery(nameRelation, relation) {
-        var _a;
-        this.$state.set('RELATION', [...this.$state.get('RELATION'), relation]);
-        this.with(nameRelation);
-        const r = this.$state.get('RELATIONS').find((data) => data.name === nameRelation);
-        this._assertError(relation == null, `This Relation "${nameRelation}" not be register in Model "${(_a = this.constructor) === null || _a === void 0 ? void 0 : _a.name}"`);
-        this._assertError(!Object.values(this.$constants('RELATIONSHIP')).includes(r.relation), `unknown relationship in [${this.$constants('RELATIONSHIP')}] !`);
-        return r;
-    }
     _validateMethod(method) {
         const methodChangeStatements = [
             'insert',
             'create',
             'update',
+            'updateMany',
             'updateNotExists',
             'delete',
+            'deleteMany',
             'forceDelete',
             'restore',
             'faker',
@@ -2768,58 +2596,78 @@ class Model extends AbstractModel_1.AbstractModel {
             }
         }
     }
-    _checkSchemaOrNextError(e) {
+    _checkSchemaOrNextError(e, retry = 1) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this.$state.get('RETRY_QUERIES') > 3)
+                if (retry > 3 || this._getState('RETRY') > 3)
                     throw e;
-                const schemaTable = this.$state.get('SCHEMA_TABLE');
+                const schemaTable = this._getState('SCHEMA_TABLE');
                 if (schemaTable == null)
-                    throw e;
+                    return this._stoppedRetry(e);
+                if (!(e instanceof Error))
+                    return this._stoppedRetry(e);
                 const errorMessage = (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : '';
                 if (errorMessage.toLocaleLowerCase().includes('unknown column')) {
                     const pattern = /'([^']+)'/;
-                    const column = errorMessage.match(pattern)
-                        ? String(errorMessage.match(pattern)[0]).replace(/'/g, '').split('.').pop()
+                    const isPattern = errorMessage.match(pattern);
+                    const column = isPattern
+                        ? String(Array.isArray(isPattern) ? isPattern[0] : '').replace(/'/g, '').split('.').pop()
                         : null;
                     if (column == null)
-                        throw e;
+                        return this._stoppedRetry(e);
                     const type = (_c = (_b = schemaTable[column]) === null || _b === void 0 ? void 0 : _b.type) !== null && _c !== void 0 ? _c : null;
                     const attributes = (_e = (_d = schemaTable[column]) === null || _d === void 0 ? void 0 : _d.attributes) !== null && _e !== void 0 ? _e : null;
                     if (type == null || attributes == null)
-                        throw e;
+                        return this._stoppedRetry(e);
                     const entries = Object.entries(schemaTable);
                     const indexWithColumn = entries.findIndex(([key]) => key === column);
                     const findAfterIndex = indexWithColumn ? entries[indexWithColumn - 1][0] : null;
                     if (findAfterIndex == null)
-                        throw e;
+                        return this._stoppedRetry(e);
                     const sql = [
                         `${this.$constants('ALTER_TABLE')}`,
-                        `${this.$state.get('TABLE_NAME')}`,
+                        `${this._getState('TABLE_NAME')}`,
                         `${this.$constants('ADD')}`,
                         `\`${column}\` ${type} ${attributes.join(' ')}`,
                         `${this.$constants('AFTER')}`,
                         `\`${findAfterIndex !== null && findAfterIndex !== void 0 ? findAfterIndex : ''}\``
                     ].join(' ');
-                    yield this.queryStatement(sql);
+                    yield this._queryStatement(sql);
                     return;
                 }
                 if (!errorMessage.toLocaleLowerCase().includes("doesn't exist"))
-                    throw e;
-                const tableName = this.$state.get('TABLE_NAME');
+                    return this._stoppedRetry(e);
+                const tableName = this._getState('TABLE_NAME');
                 const sql = new Schema_1.Schema().createTable(tableName, schemaTable);
-                yield this.queryStatement(sql);
-                return;
+                yield this._queryStatement(sql);
             }
             catch (e) {
-                throw e;
+                if (retry > 3)
+                    throw e;
+                yield this._checkSchemaOrNextError(e, retry + 1);
             }
         });
     }
+    _stoppedRetry(e) {
+        this._setState('RETRY', 3);
+        throw e;
+    }
+    _observer(result, type) {
+        if (this._getState('OBSERVER') == null)
+            return;
+        const observer = this._getState('OBSERVER');
+        switch (type.toLocaleLowerCase()) {
+            case 'created': return new observer().created(result);
+            case 'updated': return new observer().updated(result);
+            case 'deleted': return new observer().deleted(result);
+        }
+        return;
+    }
     _initialModel() {
         this.$state = new StateHandler_1.StateHandler(this.$constants('MODEL'));
         this._makeTableName();
+        this.$relation = new RelationHandler_1.RelationHandler(this);
         return this;
     }
 }